filename_1,filename_2,code_1,code_2,labels,notes
51151974,c23278ec,"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 java.io.*;
import java.sql.Array;
import java.util.*;

public class P1551C {
    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();
                String[] s = new String[n];
                int[][] freq = new int[n][6];
                for (int i = 0; i < n; i++) {
                    s[i] = in.nextLine();
                    for (char c : s[i].toCharArray()) {
                        freq[i][c - 'a']++;
                        freq[i][5]++;
                    }
                }
                int totmax = 0;
                for (int i = 0; i < 5; i++) {
                    List<Integer> diffs = new ArrayList<>(n);
                    for (int j = 0; j < n; j++) {
                        diffs.add(2 * freq[j][i] - freq[j][5]);
                    }
                    Collections.sort(diffs);
                    Collections.reverse(diffs);
                    int curr = 0, cnt = 0;
                    while (cnt < diffs.size() && curr + diffs.get(cnt) > 0) {
                        curr += diffs.get(cnt++);
                    }
                    totmax = Math.max(totmax, cnt);
                }
                out.println(totmax);
            }
        }
    }

    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 String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        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;
        }

    }

}



",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
0df4050e,d9199dfd,"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.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();  
    }
    
}  
",1,Plagiarised
df594a00,fcbe7917,"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) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}","import java.io.*;
import java.util.*;

public class E_Air_Conditioners{

    public static void main(String Args[]) throws Exception{
        BufferedReader br = new BufferedReader (new InputStreamReader(System.in));

        int t= Integer.parseInt(br.readLine());
        StringTokenizer st;

        while(t-->0){
            String gap=br.readLine();
            
            st=new StringTokenizer(br.readLine());
            int n= Integer.parseInt(st.nextToken());
            int k= Integer.parseInt(st.nextToken());

            int pos[]=new int[k];
            st=new StringTokenizer(br.readLine());

            for(int i=0;i<k;i++){
                pos[i]=Integer.parseInt(st.nextToken())-1;
            }

            int temp[]=new int[k];
            st=new StringTokenizer(br.readLine());

            int ans[]=new int[n];
            int l[]=new int[n];
            int r[]=new int[n];

            Arrays.fill(ans,Integer.MAX_VALUE);

            for(int i=0;i<k;i++){
                temp[i]=Integer.parseInt(st.nextToken());
                ans[pos[i]]=temp[i];
            }



            int min=Integer.MAX_VALUE;
            for(int i=0;i<n;i++){
                if(min==Integer.MAX_VALUE){
                    min=ans[i];
                }
                else{
                    min=Math.min(min+1,ans[i]);
                }
                l[i]=min;
            }

            min=Integer.MAX_VALUE;
            for(int i=n-1;i>=0;i--){
                if(min==Integer.MAX_VALUE){
                    min=ans[i];
                }
                else{
                    min=Math.min(min+1,ans[i]);
                }
                r[i]=min;
            }

            for(int i=0;i<n;i++){
                System.out.print(Math.min(l[i],r[i])+"" "");
            }
            System.out.println();

        }

    }
}
",0,Non-plagiarised
3ff60986,d0b4b96c,"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 int N = (int)2e5 +10;
    static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
    static
    {
        for(int i=0; i<N; i++)
        {
            adj.add(new ArrayList<>());
        }
    }
    static int[][] a = new int[2][N];

    static long[][] dp = new long[2][N];

    static void dfs(int v, int p){
        dp[0][v] = 0;
        dp[1][v]=0;

        for(int u: adj.get(v))
        {
            if(u!=p) {


                dfs(u, v);
                dp[0][v] += Math.max(Math.abs(a[0][v] - a[1][u]) + dp[1][u], Math.abs(a[0][v] - a[0][u]) + dp[0][u]);
                dp[1][v] += Math.max(Math.abs(a[1][v] - a[1][u]) + dp[1][u], Math.abs(a[1][v] - a[0][u]) + dp[0][u]);
            }


        }
    }





    public static void main(String[] args) throws IOException{
	// write your code here
        FastReader sc = new FastReader();

        int t = sc.nextInt();
        while(t-->0)
        {
            int n = sc.nextInt();
            for(int i=1; i<=n; i++)
            {
                a[0][i] = sc.nextInt();
                a[1][i] = sc.nextInt();
                adj.set(i, new ArrayList<>());
            }


            for(int i=1; i<n; i++)
            {
                int u = sc.nextInt();
                int v = sc.nextInt();
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            dfs(1, 0);
            System.out.println(Math.max(dp[0][1], dp[1][1]));
        }

    }
}

","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 int N = (int)2e5 +10;
    static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
    static
    {
        for(int i=0; i<N; i++)
        {
            adj.add(new ArrayList<>());
        }
    }
    static int[][] a = new int[2][N];

    static long[][] dp = new long[2][N];

    static void dfs(int v, int p){
        dp[0][v] = 0;
        dp[1][v]=0;

        for(int u: adj.get(v))
        {
            if(u!=p) {


                dfs(u, v);
                dp[0][v] += Math.max(Math.abs(a[0][v] - a[1][u]) + dp[1][u], Math.abs(a[0][v] - a[0][u]) + dp[0][u]);
                dp[1][v] += Math.max(Math.abs(a[1][v] - a[1][u]) + dp[1][u], Math.abs(a[1][v] - a[0][u]) + dp[0][u]);
            }


        }
    }





    public static void main(String[] args) throws IOException{
	// write your code here
        FastReader sc = new FastReader();

        int t = sc.nextInt();
        while(t-->0)
        {
            int n = sc.nextInt();
            for(int i=1; i<=n; i++)
            {
                a[0][i] = sc.nextInt();
                a[1][i] = sc.nextInt();
                adj.set(i, new ArrayList<>());
            }


            for(int i=1; i<n; i++)
            {
                int u = sc.nextInt();
                int v = sc.nextInt();
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            dfs(1, 0);
            System.out.println(Math.max(dp[0][1], dp[1][1]));
        }

    }
}

",1,Plagiarised
1230c43e,ce0b2178,"//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.io.*;
import java.util.*;

public class D {
	
	static class Pair implements Comparable<Pair>{
		int a;
		char b;

		public Pair(int a, char b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Pair p) {
			if(this.b == p.b) 
				return this.a - p.a;
			return this.b - p.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();
			int arr[] = scan.readArray(n);
			char line[] = scan.next().toCharArray();
			ArrayList<Pair> pairs = new ArrayList<Pair>();
			for(int i = 0;i<n;i++) {
				pairs.add(new Pair(arr[i], line[i]));
			}
			Collections.sort(pairs);
			boolean possible = true;
			for(int i = 1;i<=n;i++) {
				if(pairs.get(i-1).a == i) {
					continue;
				}
				else if(pairs.get(i-1).a < i && pairs.get(i-1).b == 'R') {
					continue;
				}
				else if(pairs.get(i-1).a > i && pairs.get(i-1).b == 'B') {
					continue;
				}
				else {
					possible = false;
					break;
				}
			}
			output.println(possible == true ? ""YES"" : ""NO"");
		}
		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 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;
    }
	
	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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
49e94e7e,fcc7e8fa,"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.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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
a7063d01,ac4d0fc5,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.io.BufferedReader;
import java.io.InputStreamReader;
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);
        solve(in, out);
        out.close();
    }

    static String reverse(String s) {
        return (new StringBuilder(s)).reverse().toString();
    }

    static void sieveOfEratosthenes(int n, int factors[], ArrayList<Integer> ar) 
    { 
        factors[1]=1;
        int p;
        for(p = 2; p*p <=n; p++) 
        { 
            if(factors[p] == 0) 
            { 
                ar.add(p);
                factors[p]=p;
                for(int i = p*p; i <= n; i += p) 
                    if(factors[i]==0)
                        factors[i] = p; 
            } 
        } 
        for(;p<=n;p++){
            if(factors[p] == 0) 
            { 
                factors[p] = p;
                ar.add(p);
            } 
        }
    }

    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 void sort2(char ar[]) {
        int n = ar.length;
        ArrayList<Character> 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 class SegTree {
        
        long tree[];
        long lz[];
        long r;
        
        long combine(long a, long b){
            return Math.min(a,b);
        }
    
        void build(long a[], int v, int tl, int tr) {
            if (tl == tr) {
                tree[v] = a[tl];
            } 
            else {
                int tm = (tl + tr) / 2;
                build(a, v*2, tl, tm);
                build(a, v*2+1, tm+1, tr);
                tree[v] = combine(tree[2*v], tree[2*v+1]);
            }
        }
    
        void pointUpdate(int v, int tl, int tr, int pos, long val) {
            if(tl>pos||tr<pos)
                return;
            if(tl==pos&&tr==pos){
                tree[v] = val;
                return;
            }
            int tm = ((tl + tr) >> 1);
            pointUpdate(v*2, tl, tm, pos, val);
            pointUpdate(v*2+1, tm+1, tr, pos, val);
            tree[v] = combine(tree[2*v],tree[2*v+1]);
        }
    
        // void push(int v, int tl, int tr){
        //     if(tl==tr){
        //         lz[v] = 0;
        //         return;
        //     }
        //     tree[2*v] += lz[v];
        //     tree[2*v+1] += lz[v];
        //     lz[2*v] += lz[v];
        //     lz[2*v+1] += lz[v];
        //     lz[v] = 0;
        // }
    
        // void rangeUpdate(int v, int tl, int tr, int l, int r, long val) {
        //     if(tl>r||tr<l)
        //         return;
        //     push(v, tl, tr);
        //     if(tl>=l&&tr<=r){
        //         tree[v] += val;
        //         lz[v] += val;
        //         return;
        //     }
        //     int tm = ((tl + tr) >> 1);
        //     rangeUpdate(v*2, tl, tm, l, r, val);
        //     rangeUpdate(v*2+1, tm+1, tr, l, r, val);
        //     tree[v] = combine(tree[2*v],tree[2*v+1]);
        // }

        long get(int v, int tl, int tr, int l, int r, long val) {
            if(l>tr||r<tl||tree[v]>val){
                return 0;
            }
            if (tl == tr) {
                tree[v] = Integer.MAX_VALUE;
                return 1;
            }
            int tm = ((tl + tr) >> 1);
            long al = get(2*v, tl, tm, l, r, val);
            long ar = get(2*v+1, tm+1, tr, l, r, val);
            tree[v] = combine(tree[2*v],tree[2*v+1]);
            return al+ar;
        }

    }

    static class BIT{
        int n;
        long tree[];
        long operate(long el, long val){
            return el+val;
        }
        void update(int x, long val){
            for(;x<n;x+=(x&(-x))){
                tree[x] = operate(tree[x], val);
            }
        }
        long get(int x){
            long sum = 0;
            for(;x>0;x-=(x&(-x))){
                sum = operate(sum, tree[x]);
            }
            return sum;
        }
    }

    static int parent[];
    static int rank[];

    static long m = 0;

    static int find_set(int v) {
        if (v == parent[v])
            return v;
        return find_set(parent[v]);
    }
    
    static void make_set(int v) {
        parent[v] = v;
        rank[v] = 1;
    }
    
    static void union_sets(int a, int b) {
        a = find_set(a);
        b = find_set(b);
        if (a != b) {
            if (rank[a] < rank[b]){
                int tmp = a;
                a = b;
                b = tmp;
            }
            parent[b] = a;
            // if (rank[a] == rank[b])
            //     rank[a]++;
            rank[a] += rank[b];
            max1 = Math.max(max1,rank[a]);
        }
    }

    static int parent1[];
    static int rank1[];

    static int find_set1(int v) {
        if (v == parent1[v])
            return v;
        return find_set1(parent1[v]);
    }
    
    static void make_set1(int v) {
        parent1[v] = v;
        rank1[v] = 1;
    }
    
    static void union_sets1(int a, int b) {
        a = find_set1(a);
        b = find_set1(b);
        if (a != b) {
            if (rank1[a] < rank1[b]){
                int tmp = a;
                a = b;
                b = tmp;
            }
            parent1[b] = a;
            // if (rank1[a] == rank1[b])
            //     rank1[a]++;
            rank1[a] += rank1[b];
        }
    }

    static long max1 = 0;

    static int count = 0;
    static int count1 = 0;

    static boolean possible;

    public static void solve(InputReader sc, PrintWriter pw){
        int i, j = 0;
        // int t = 1; 
        long mod = 1000000007;
        // int factors[] = new int[1000001];
        // ArrayList<Integer> ar = new ArrayList<>();
        // sieveOfEratosthenes(1000000, factors, ar);
        // HashSet<Integer> set = new HashSet<>();
        // for(int x:ar){
        //     set.add(x);
        // }
        int t = sc.nextInt();
        u: while (t-- > 0) {
            int n = sc.nextInt();
            int e[][] = new int[n-1][2];
            int x[] = new int[n];
            int m = 0;
            for(i=0;i<n-1;i++){
                e[i][0] = sc.nextInt()-1;
                e[i][1] = sc.nextInt()-1;
                x[e[i][0]]++;
                x[e[i][1]]++;
                m = Math.max(x[e[i][0]],m);
                m = Math.max(x[e[i][1]],m);
            }
            if(m>2)
                pw.println(-1);
            else{
                if(n==2){
                    pw.println(2);
                }
                else if(n==3){
                    pw.println(2+"" ""+3);
                }
                else{
                    int d = 0;
                    int ans[] = new int[n-1];
                    ArrayList<Integer> ar[] = new ArrayList[n];
                    ArrayList<Integer> ar1[] = new ArrayList[n];
                    for(i=0;i<n;i++){
                        ar[i] = new ArrayList<>();
                        ar1[i] = new ArrayList<>();
                    }
                    for(i=0;i<n-1;i++){
                        int a = e[i][0];
                        int b = e[i][1];
                        ar[a].add(b);
                        ar1[a].add(i);
                        ar[b].add(a);
                        ar1[b].add(i);
                        if(x[a]==1)
                            d = a;
                        if(x[b]==1)
                            d = b;
                    }
                    visit(d,ar,ar1,ans,-1,2);
                    for(i=0;i<n-1;i++){
                        pw.print(ans[i]+"" "");
                    }
                    pw.println();
                }
            }
        }
    }

    static void visit(int d, ArrayList<Integer> ar[], ArrayList<Integer> ar1[], int ans[], int par, int v){
        if(ar[d].get(0)!=par){
            ans[ar1[d].get(0)] = v;
            visit(ar[d].get(0), ar, ar1, ans, d, 5-v);
            return;
        }
        if(ar[d].size()==1)
            return;
        ans[ar1[d].get(1)] = v;
        visit(ar[d].get(1), ar, ar1, ans, d, 5-v);
    }

    static void KMPSearch(char pat[], char txt[], int pres[]){
        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[j] == txt[i]) {
                j++;
                i++;
            }
            if (j == M) {
                pres[i-1] = 1;
                j = lps[j - 1];
            }
            else if (i < N && pat[j] != txt[i]) {
                if (j != 0)
                    j = lps[j - 1];
                else
                    i = i + 1;
            }
        }
    }
  
    static void computeLPSArray(char pat[], int M, int lps[])
    {
        int len = 0;
        int i = 1;
        lps[0] = 0; 
        while (i < M) {
            if (pat[i] == pat[len]) {
                len++;
                lps[i] = len;
                i++;
            }
            else 
            {
                if (len != 0) {
                    len = lps[len - 1];
                }
                else
                {
                    lps[i] = len;
                    i++;
                }
            }
        }
    }

    static long[][] matrixMult(long a[][], long b[][], long mod){
        int n = a.length;
        int m = a[0].length;
        int p = b[0].length;
        long c[][] = new long[n][p];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                for(int k=0;k<p;k++){
                    c[i][k] += a[i][j]*b[j][k];
                    c[i][k] %= mod;
                }
            }
        }
        return c;
    }

    static long[][] exp(long mat[][], long b, long mod){
        if(b==0){
            int n = mat.length;
            long res[][] = new long[n][n];
            for(int i=0;i<n;i++){
                res[i][i] = 1;
            }
            return res;
        }
        long half[][] = exp(mat, b/2, mod);
        long res[][] = matrixMult(half, half, mod);
        if(b%2==1){
            res = matrixMult(res, mat, mod);
        }
        return res;
    }

    static void countPrimeFactors(int num, int a[], HashMap<Integer,Integer> pos){
        for(int i=2;i*i<num;i++){
            if(num%i==0){
                int y = pos.get(i);
                while(num%i==0){
                    a[y]++;
                    num/=i;
                }
            }
        }
        if(num>1){
            int y = pos.get(num);
            a[y]++;
        }
    }

    static void assignAnc(ArrayList<Integer> ar[], int depth[], int sz[], int par[][] ,int curr, int parent, int d){
        depth[curr] = d;
        sz[curr] = 1;
        par[curr][0] = parent;
        for(int v:ar[curr]){
            if(parent==v)
                continue;
            assignAnc(ar, depth, sz, par, v, curr, d+1);
            sz[curr] += sz[v];
        }
    }

    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 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 long lcm(int a, int b){
        return a*b/gcd(a,b);
    }

    static class CustomPair {
        long a[];
        
        CustomPair(long a[]) {
            this.a = a;
        }
    }

    static class Pair1 implements Comparable<Pair1> {
        long a;
        long b;
        
        Pair1(long a, long b) {
            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair1 p) {
            if(a!=p.a)
                return (a<p.a?-1:1);
            return (b<p.b?-1:1);
        }
    }

    static class Pair implements Comparable<Pair> {
        int a;
        int b;
        int c;
        
        Pair(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
 
        public int compareTo(Pair p) {
            if(b!=p.b)
                return (b-p.b);
            return (a-p.a);
        }
    }

    static class Pair2 implements Comparable<Pair2> {
        int a;
        int b;
        int c;
        
        Pair2(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
 
        public int compareTo(Pair2 p) {
            return a-p.a;
        }
    }

    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 gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    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 InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 9992768);
            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 boolean[] ret;
    static boolean[] updated;
    static ArrayList<Integer>[] adjacencyList;
    static Edge[] edgeList;
    static class Edge {
        int start, end, number;
        public Edge (int _start, int _end, int _number) {
            start = _start;
            end = _end;
            number = _number;
        }
    }
    public static void dfs(int node) {
        updated[node] = true;
        for (int next : adjacencyList[edgeList[node].start]) {
            if (!updated[next]) {
                ret[next] = !ret[node];
                dfs(next);
            }
        }
        for (int next : adjacencyList[edgeList[node].end]) {
            if (!updated[next]) {
                ret[next] = !ret[node];
                dfs(next);
            }
        }
    }
    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 numCases = Integer.parseInt(br.readLine());
        for (int i = 0; i < numCases; i++) {
            int numVertices = Integer.parseInt(br.readLine());
            int[] numEdges = new int[numVertices];
            edgeList = new Edge[numVertices - 1];
            adjacencyList = new ArrayList[numVertices];
            for (int j = 0; j < numVertices; j++) {
                adjacencyList[j] = new ArrayList<>();
            }
            for (int j = 0; j < numVertices - 1; j++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                int a = Integer.parseInt(st.nextToken()) - 1;
                int b = Integer.parseInt(st.nextToken()) - 1;
                edgeList[j] = new Edge(a, b, j);
                numEdges[a]++;
                numEdges[b]++;
                adjacencyList[a].add(j);
                adjacencyList[b].add(j);
            }
            boolean good = true;
            for (int j = 0; j < numVertices; j++) {
                if (numEdges[j] > 2) {
                    good = false;
                    break;
                }
            }
            if (!good) {
                pw.println(-1);
            } else {
                ret = new boolean[numVertices - 1];
                updated = new boolean[numVertices - 1];
                dfs(0);
                for (boolean b : ret) {
                    if (b)
                        pw.print(5 + "" "");
                    else
                        pw.print(2 + "" "");
                }
                pw.println();
            }
        }
        br.close();
        pw.close();
    }
}",0,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
163d0dde,f87eb1b3,"// 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);
        }
    } 
} ","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.PrintStream;
import java.io.PrintWriter;
public class A {
 
	
	/* 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 aa, int bb)
		{
			first = aa; second = bb;
		}
		public int compareTo(Pair o)
		{
			if(this.second < o.second) return -1;
			if(this.second > o.second) return +1;
			return this.first - o.first;
		}
	}
	
	static class Tuple implements Comparable<Tuple>{
		long first, second,third;
		public Tuple(long first, long second, long 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 boolean isPrime(long n) 
	{
		if(n == 1)
		{
			return false;
		}
		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[n+1];
		Arrays.fill(prime, true);
		
		ArrayList<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 gcd(int a, int b)
	{
		if(b == 0)
		 return a;
		
		else
		return gcd(b,a%b);
	} 
 
		public static int lcm(int a, int b)
	    {
	        return (a / gcd(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(int n, int k) 
	    {
			long ans = 1;
			for(int i = 0;i<k;i++)
			{
				ans *= (n-i);
				ans /= (i+1);
			}
			return ans;
		}
 
		public static void Sort(int[] a) 
		{
			List<Integer> l = new ArrayList<>();
			for (int 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);
		}
		
		//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));
		   }
		   
		   /*
		    * 
		    * >=         <=
		   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(int a[], int 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 main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out);
		
		int t = sc.nextInt();
		while(t-- > 0)
		{
			long INF = 1000000000000000007L;
			int n = sc.nextInt();
			
			long[] c = new long[n+1];
			for(int i = 1;i<=n;i++) c[i] = sc.nextLong();
			
			long ans = INF;
			long mo = INF,  so = 0, co = 0;
			long me = INF,  se = 0, ce = 0;
			
			for(int i=1;i<=n;i++)
			{
				if(i%2 == 1)
				{
					mo = min(mo,c[i]);
					so += c[i];
					co++;
				}
				else
				{
					me = min(me,c[i]);
					se += c[i];
					ce++;
				}
				if(i>=2)
				{
					long x = so + (n - co) * mo + se + (n - ce) * me;
					ans=min(ans,x);
				}
			}
			fout.println(ans);
		}
			
		fout.close();
	}
}",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
8f6421f3,ea2fc2bc,"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;}
    }
}


  
","//package Practise;

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 AirConditioner {
	public static void main(String args[]) {
		FastScanner fs=new FastScanner();
		int t=fs.nextInt();
		for(int t1=0;t1<t;t1++) {
			int n=fs.nextInt();
			int k=fs.nextInt();
			int []arr1=new int[k];
			int []arr2=new int[k];
			arr1=fs.readArray(k);
			arr2=fs.readArray(k);
			int []dp=new int[n];
			//for(int i=0;i<k;i++)
				//dp[arr1[i]-1]=arr2[i];
			Arrays.fill(dp,Integer.MAX_VALUE/2);
			for(int i=0;i<k;i++) {
				dp[arr1[i]-1]=arr2[i];
			}
			for(int i=1;i<n;i++) {
				dp[i]=Math.min(dp[i],dp[i-1]+1);
			}
			//Print(dp);
			for(int i=n-2;i>=0;i--) {
				dp[i]=Math.min(dp[i], dp[i+1]+1);
			}
			//Print(dp);
			
			/*for(int i=0;i<n;i++) {
				int min=Integer.MAX_VALUE;
				for(int j=0;j<k;j++) {
					min=Math.min(min, arr2[j]+Math.abs(i-arr1[j]+1));
				}
				dp[i]=min;
			}*/
			for(int val:dp) {
				System.out.print(val+"" "");
			}
			System.out.println();
		}
		
	}
	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 Print(int []arr) {
		for(int val:arr)
			System.out.print(val+"" "");
		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());
		}
	}
}

",1,Plagiarised
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,Non-plagiarised
1162c08f,6bcc5afd,"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 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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
18e2441c,b728ba1d," 

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());
		}
	}
}

","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,Non-plagiarised
722e318f,b790ef12,"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.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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
8a041ef5,bdf7bfb2,"// package com.company;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.jar.JarEntry;

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 {


        void solve(InputReader in, int testNumber) {
           int n = in.nextInt();
           int a[][] = new int[n][5];
           for(int i=0;i<n;i++)
           {
               char[] s = in.next().toCharArray();
               for(int j=0;j<s.length;j++)
               {
                   a[i][s[j]-'a']++;
               }
           }
           int max=0;
           int x[] = new int[n];
           for(int j=0;j<=4;j++)
           {
               for(int i=0;i<n;i++)
               {
                   x[i]=2*a[i][j];
                   for(int k=0;k<5;k++)
                   {
                       x[i]-=a[i][k];
                   }
               }
               Arrays.sort(x);
               int c=0,sum=0;
               for(int i=n-1;i>=0;i--)
               {
                   sum+=x[i];
                   if(sum<=0)
                       break;
                   c++;
               }
               max=Math.max(max,c);
           }
            System.out.println(max);
















        }
    }


    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 < b)
                return gcd(b,a);
            if (b == 0)
                return a;
            else
                return gcd(b,a%b);
        }
        public static long lcm(long a, long b) {
            return (a * b) / gcd(a, b);
        }

    }
    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);
        }
    }
}


","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;
        }
 
    }
}
 		 		 							 	  						 		 	
",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
6f02c6d9,c9159d9c,"
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 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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
8d6f1bf5,e90a198b,"//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--;
        }
    }
}
","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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
2eb89317,5f0a176e,"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.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();
	String s1 = sc.next();
	String s2 = sc.next();
	if(s1.equals(s2)) {
		System.out.println(0);
		continue;
	}
	int f = 0;
	for(int i = 0 ; i<n;i++) {
		if(s1.charAt(i) == '1') {
			f = 1;
			break;
		}
	}
if(f == 0) {
	System.out.println(-1);
continue;
}
int c = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
int c4 = 0;
for(int i = 0; i<n;i++) {
	if(s1.charAt(i)!=s2.charAt(i)) {
		c++;
	if(s1.charAt(i) == '1') {
		c1++;
	}else {
		c2++;
	}
	}else {
		if(s1.charAt(i) == '1') {
			c3++;
		}else {
			c4++;
		}
	}
}

int g = 0;
int h = 0;

int v1 = Integer.MAX_VALUE;
int v2 = Integer.MAX_VALUE;
if(c%2==1) {
g = 1;
}

int e = n-c;
if(e%2==0) {
h = 1;
}
//System.out.println(Math.min(v1, v2));
if(c2!=c/2){
	g = 1;
}
if(c4!=e/2){
	h = 1;
}
if(g == 0){
	v1 = c;
}
if(h == 0){
	v2 = e;
}

int ans = Math.min(v1, v2);

if(ans == Integer.MAX_VALUE) {
	System.out.println(-1);
}else {
	System.out.println(ans);
}
}

//     }catch(Exception e) {
//    	 return;
//     }
    	
	
	
	
	}
     
     
//------------------------------------------------------------------------------------------------------------------------------------------------

	
	public static boolean check(int[][] arr , int m , int n , int val){
		HashSet<Integer>set = new HashSet<Integer>();
		int f = 0;
		int id = 0;
		ArrayList<Integer> al = new ArrayList<Integer>();
		for(int i = 0 ; i<m;i++) {
			for(int j = 0 ; j<n;j++) {
				if(arr[i][j]>=val) {
//					System.out.println(arr[i][j] + "" "" + i + "" "" + j);
					set.add(j);
					al.add(arr[i][j]);
				}
			}
			id = i;
		if(set.size()>=2) {
			f = 1;
			break;
		}else {
			set.clear();
		}
		}
		if(f == 0) {
			return false;
		}
//		System.out.println(set);
//		System.out.println(al);
//		int g = 1;
		for(int i = 0 ; i<n;i++) {
			if(set.contains(i)) {
				continue;
			}
			int h= 0;
			for(int j = 0 ; j<m;j++) {
				if(j == id) {
				continue;	
				}
				if(arr[j][i]>=val) {
					h = 1;
					break;
				}
			}
		if(h == 0) {
			return false;
		}
		}
	return true;
	}
	
	
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 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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
a4c98ae1,ee4f7b06,"import java.io.*;
import java.util.*;
public class Main {
    static ArrayList<Integer> one=new ArrayList<>();
    static ArrayList<Integer> zero=new ArrayList<>();
    static long dp[][]= new long[5001][5001];
    static long solve(int i,int j){
        if (i==one.size())return 0;
        if (j==zero.size())return Integer.MAX_VALUE;
        if (dp[i][j]!=-1){
           return dp[i][j];
        }
        return dp[i][j]=Math.min(solve(i+1,j+1)+Math.abs(one.get(i)-zero.get(j)),solve(i,j+1));
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
//        int t=sc.nextInt();
//        while (t-->=1){
            int n=sc.nextInt();
            int a[]=sc.readArray(n);
            for (long i[]:dp){
                Arrays.fill(i,-1);
            }
            for (int i=0;i<n;i++){
                if (a[i]==1)one.add(i);
                else zero.add(i);
            }
            Collections.sort(one);
            Collections.sort(zero);
        System.out.println(solve(0,0));




    }


//        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> {
        String a;
        int b;

        public Pair(String 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 long mod =(long)(1e9+7);
    static long mod(long x) {
        return ((x % mod + mod) % mod);
    }
    static long div(long a,long b){
        return ((a/b)%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.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 }


",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
23cb8587,48801d9e,"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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {
    private static FastReader fr = new FastReader();
    private static PrintWriter out=new PrintWriter(System.out);
    private static Random random = new Random();

    private static long[][] dp;

    private static long calculate(List<Integer>[] graph, int current, long[][] r, boolean[] stack, int use){
        if(dp[current][use] != -1) return dp[current][use];
        stack[current] = true;
        long max = 0;
        if(graph[current] != null){
            for(int next : graph[current]){
                if(!stack[next]){
                    stack[next] = true;
                    long r1 = Math.abs(r[current][use] - r[next][0]) + calculate(graph, next, r, stack, 0);
                    long r2 = Math.abs(r[current][use] - r[next][1]) + calculate(graph, next, r, stack, 1);
                    max += Math.max(r1, r2);
                }
            }
        }
        stack[current] = false;
        dp[current][use] = max;
        return max;
    }

    public static void main(String[] args) throws IOException {
        StringBuilder sb = new StringBuilder();
        // code goes here
        int t = fr.nextInt();
        while (t-- > 0){
            int n = fr.nextInt();
            long[][] r = new long[n][2];
            for(int i = 0; i < n; i++){
                r[i] = fr.nextLongArray(2);
            }
            List<Integer>[] graph = new ArrayList[n];
            for(int i = 0; i < n - 1; i++){
                int u = fr.nextInt();
                int v = fr.nextInt();
                if(graph[u - 1] == null) graph[u - 1] = new ArrayList<>();
                if(graph[v - 1] == null) graph[v - 1] = new ArrayList<>();
                graph[u - 1].add(v - 1);
                graph[v - 1].add(u - 1);
            }

            boolean[] stack = new boolean[n];
            dp = new long[n][2];
            for(int i = 0; i < dp.length; i++){
                Arrays.fill(dp[i], -1);
            }

            long r1 = calculate(graph, 0, r, stack, 0);
            long r2 = calculate(graph, 0, r, stack, 1);
            sb.append(Math.max(r1, r2)).append(""\n"");
        }
        System.out.print(sb.toString());
    }

    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 FastReader{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("""");

        public String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public int[] nextIntArray(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());
        }

        public long[] nextLongArray(int n) {
            long[] a=new long[n];
            for (int i=0; i<n; i++) a[i]=nextLong();
            return a;
        }
    }

    static class Pair<A, B>{
        A first;
        B second;
        public Pair(A first, B second){
            this.first = first;
            this.second = second;
        }
    }

    static long mod(String num, long a)
    {
        // Initialize result
        long res = 0;

        // One by one process all digits of 'num'
        for (int i = 0; i < num.length(); i++)
            res = (res*10 +  num.charAt(i) - '0') %a;

        return res;
    }

    static long binomialCoeff(long n, long k, long MOD)
    {
        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 (int i = 0; i < k; ++i) {
            res *= (n - i);
            res /= (i + 1);
            res %= MOD;
        }

        return res;
    }

    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(int n, int r,
                              long p)
    {

        // 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[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;
    }
}
",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
d12f26f0,df594a00,"import java.io.*;
import java.util.*;

public class AirConditioners {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) throws IOException {
		int q = readInt();
		
		while (q-- > 0) {
			int n = readInt(), k = readInt();
			int[] a = new int[k], t = new int[k], c = new int[n];
			for (int i = 0; i < k; i ++) a[i] = readInt();
			for (int i = 0; i < k; i ++) t[i] = readInt();
			Arrays.fill(c, Integer.MAX_VALUE);
			for (int i = 0; i < k; i ++) c[a[i] - 1] = t[i];
			
			int[] l = new int[n], r = new int[n];
			int prev = (int) 2e9;
			for (int i = 0; i < n; i ++) {
				l[i] = Math.min(prev + 1, c[i]);
				prev = l[i];
			}
			prev = (int) 2e9;
			for (int i = n - 1; i >= 0; i --) {
				r[i] = Math.min(prev + 1, c[i]);
				prev = r[i];
			}
			for (int i = 0; i < n; i ++) System.out.print(Math.min(l[i], r[i]) + "" "");
			System.out.println();
		}
	}

	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 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) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}",0,Non-plagiarised
4e87c35b,f1f600d9,"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();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int[] arr = new int[n];

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
            }
            long ans = Long.MAX_VALUE;
            // sum so far + min*(n-k)
            long[] evenSum = new long[n];
            long[] oddSum = new long[n];
            int[] evenMin = new int[n];
            int[] oddMin = new int[n];
            evenSum[0] = arr[0];
            oddSum[1] = arr[1];
            evenMin[0] = arr[0];
            oddMin[1] = arr[1];
            for (int i = 2; i < n; i++) {
                if (i % 2 == 0) {
                    evenSum[i] = evenSum[i - 2] + arr[i];
                    evenMin[i] = Math.min(evenMin[i - 2], arr[i]);
                } else {
                    oddSum[i] = oddSum[i - 2] + arr[i];
                    oddMin[i] = Math.min(oddMin[i - 2], arr[i]);
                }
            }
            for (int i = 1; i < n; i++) {
                ans = Math.min(ans, compute(arr, i, evenSum, oddSum, evenMin, oddMin));
            }
            out.println(ans);
        }

        private long compute(int[] arr, int i, long[] evenSum, long[] oddSum, int[] evenMin, int[] oddMin) {
            if (i % 2 == 0) {
                return evenSum[i] + (arr.length - (i / 2) - 1) * (long) evenMin[i] + oddSum[i - 1] + (arr.length - (i / 2)) * (long) oddMin[i - 1];
            } else {
                return evenSum[i - 1] + (arr.length - (i / 2) - 1) * (long) evenMin[i - 1] + oddSum[i] + (arr.length - (i / 2) - 1) * (long) oddMin[i];
            }
        }

    }
}

","
// 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,Non-plagiarised
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,Non-plagiarised
b08b1c3c,d92b4600,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {

    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) {}
            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();
            Node head = null;
            boolean notPossible = false;
            for (int i = 0; i < n; i++) {
                int x = sc.nextInt();
                if (head == null) {
                    head = new Node(x);
                } else {
                    if ((head.next != null && x > head.next.value) || (head.prev != null && x < head.prev.value)) {
                        notPossible = true;
                    } else if ((head.next == null || x <= head.next.value) && x > head.value) {
                        if (head.next != null && x == head.next.value) {
                            head = head.next;
                            continue;
                        }
                        Node temp = head.next;
                        Node next = new Node(x);
                        head.next = next;
                        next.prev = head;
                        next.next = temp;
                        if (temp != null) {
                            temp.prev = next;
                        }
                        head = next;
                    } else if ((head.prev == null || x >= head.prev.value) && x < head.value) {
                        if (head.prev != null && x == head.prev.value) {
                            head = head.prev;
                            continue;
                        }
                        Node temp = head.prev;
                        Node prev = new Node(x);
                        head.prev = prev;
                        prev.next = head;
                        prev.prev = temp;
                        if (temp != null) {
                            temp.next = prev;
                        }
                        head = prev;
                    }
                }
            }
            if (notPossible) {
                out.println(""NO"");
            } else {
                out.println(""YES"");

            }        }
        out.close();
    }

    static class Node {
        int value;
        Node prev;
        Node next;
        Node(int value) {
            this.value = value;
            this.prev = null;
            this.next = null;
        }
    }
}","import java.util.Scanner;

public class D_724 {

	@SuppressWarnings(""resource"")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int t = input.nextInt();
		for(int test = 0; test < t; test++){
			int n = input.nextInt();
			ListNode on = new ListNode(input.nextInt(), null, null);
			boolean good = true;
			for(int i = 1; i < n; i++){
				int num = input.nextInt();
				if(good){
					int at = on.data;
					if(num > at){
						if(on.next == null || num < on.next.data){
							on.next = new ListNode(num, on, on.next);
							on = on.next;
							if(on.next != null){
								on.next.prev = on;
							}
						}else if(num == on.next.data){
							on = on.next;
						}else{
							good = false;
						}
					}else if(num < at){
						if(on.prev == null || num > on.prev.data){
							on.prev = new ListNode(num, on.prev, on);
							on = on.prev;
							if(on.prev != null){
								on.prev.next = on;
							}
						}else if(num == on.prev.data){
							on = on.prev;
						}else{
							good = false;
						}
					}
				}
			}
			if(good){
				System.out.println(""YES"");
			}else{
				System.out.println(""NO"");
			}
		}
	}

	static class ListNode{

		int data;
		ListNode prev;
		ListNode next;

		ListNode(int data, ListNode prev, ListNode next){
			this.data = data;
			this.prev = prev;
			this.next = next;
		}

	}

}
",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
0588b869,69b2fd22,"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,Non-plagiarised
343cc8e7,7f69a9e8,"//make sure to make new file!
import java.io.*;
import java.util.*;

public class D669b{
   
   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(System.out);
      
      int n = Integer.parseInt(f.readLine());
      
      StringTokenizer st = new StringTokenizer(f.readLine());
      
      int[] array = new int[n];
      
      for(int k = 0; k < n; k++){
         array[k] = Integer.parseInt(st.nextToken());
      }
      
      ArrayList<HashSet<Integer>> adj = new ArrayList<HashSet<Integer>>(n);
      for(int k = 0; k < n; k++) adj.add(new HashSet<Integer>());
      
      for(int k = 0; k < n-1; k++){
         adj.get(k).add(k+1);
      }
      
      //closest number before that is <
      Stack<Num> stk = new Stack<Num>();
      stk.add(new Num(array[0],0));
      
      for(int k = 1; k < n; k++){
         while(!stk.isEmpty() && stk.peek().x > array[k]){
            stk.pop();
         }
         
         if(!stk.isEmpty()){
            adj.get(stk.peek().i).add(k);
         }
         
         stk.add(new Num(array[k],k));
      }
      
      //closest number after that is <
      stk = new Stack<Num>();
      stk.add(new Num(array[n-1],n-1));
      
      for(int k = n-2; k >= 0; k--){
         while(!stk.isEmpty() && stk.peek().x > array[k]){
            stk.pop();
         }
         
         if(!stk.isEmpty()){
            adj.get(k).add(stk.peek().i);
         }
         
         stk.add(new Num(array[k],k));
      }
      //closest number before that is >
      stk = new Stack<Num>();
      stk.add(new Num(array[0],0));
      
      for(int k = 1; k < n; k++){
         while(!stk.isEmpty() && stk.peek().x < array[k]){
            stk.pop();
         }
         
         if(!stk.isEmpty()){
            adj.get(stk.peek().i).add(k);
         }
         
         stk.add(new Num(array[k],k));
      }
      
      //closest number after that is >
      stk = new Stack<Num>();
      stk.add(new Num(array[n-1],n-1));
      
      for(int k = n-2; k >= 0; k--){
         while(!stk.isEmpty() && stk.peek().x < array[k]){
            stk.pop();
         }
         
         if(!stk.isEmpty()){
            adj.get(k).add(stk.peek().i);
         }
         
         stk.add(new Num(array[k],k));
      }
      
      
      int[] path = new int[n];
      Arrays.fill(path,Integer.MAX_VALUE);
      path[0] = 0;
      
      for(int k = 0; k < n; k++){
         for(int nei : adj.get(k)){
            path[nei] = Math.min(path[nei],path[k]+1);
         }
      }
      
      int answer = path[n-1];
      out.println(answer);
         
      
      
      
      out.close();
   }
   
   public static class Num{
      int x;
      int i;
      public Num(int a, int b){
         x = a;
         i = b;
      }
   }
      
}","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.ArrayList;
import java.util.Vector;
import java.util.StringTokenizer;
import java.io.BufferedReader;
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 in, PrintWriter out) {
            int n = in.nextInt();
            ArrayList<Integer> jumps[] = new ArrayList[n];
            int h[] = new int[n];
            for (int i = 0; i < n; i++) {
                h[i] = in.nextInt();
                jumps[i] = new ArrayList<>();
            }
            Stack<int[]> s = new Stack<>();
            for (int i = 0; i < n; i++) {
                while (s.size() > 0 && s.peek()[0] > h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[i].add(s.peek()[1]);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = 0; i < n; i++) {
                while (s.size() > 0 && s.peek()[0] < h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[i].add(s.peek()[1]);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = n - 1; i >= 0; i--) {
                while (s.size() > 0 && s.peek()[0] < h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[s.peek()[1]].add(i);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = n - 1; i >= 0; i--) {
                while (s.size() > 0 && s.peek()[0] > h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[s.peek()[1]].add(i);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            int dp[] = new int[n];
            dp[0] = 0;
            for (int i = 1; i < n; i++) {
                dp[i] = Integer.MAX_VALUE;
                for (int x : jumps[i]) {
                    dp[i] = Math.min(dp[i], dp[x] + 1);
                }
            }
            out.print(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());
        }

    }
}

",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
3c667d4f,a7894e0b,"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.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 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;
	        }
	    }
	
	   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();
				int k=sc.nextInt();
				
				int[] ac=new int[k];
				
				long[] ans=new long[n];
				Arrays.fill(ans, Integer.MAX_VALUE/2);
				
				for(int i=0;i<k;i++) {
					ac[i]=sc.nextInt()-1;
				}
				for(int i=0;i<k;i++) {
					long x = sc.nextLong();
					
					ans[ac[i]] = x;
				}
				
				
				
				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++) {
            	   res.append(ans[i]+"" "");
               }
               
               res.append(""\n"");
		   }
			System.out.println(res);
		   
	   }
}  




",1,Plagiarised
595f5d6c,6653a758,"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.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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
54d7c21e,a7e7f371,"
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 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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
0ca738ce,931faca2,"import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class G {

    public static void main(String[] args) {
        FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = 1;
        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
        out.close();
    }

    static class Task {
        static int max = (int) (4e5), MOD = 998244353;
        static long[] fact = new long[max+1], invFact = new long[max+1], naturalInverse = new long[max+1];

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            int n = scan.nextInt(), k = scan.nextInt();
            Item[] lanterns = new Item[2 * n];
            for(int i = 0; i < n; i++) {
                int l = scan.nextInt(), r = scan.nextInt();
                lanterns[i * 2] = new Item(l, 0);
                lanterns[i * 2 + 1] = new Item(r, 1);
            }
            Arrays.sort(lanterns);
            precomp();

            int have = 0;
            long ans = 0;

            for(Item x : lanterns) {
                if(x.start == 1) have--;
                else {
                    ans = (ans + binomial(have, k - 1)) % MOD;
                    have++;
                }
            }
            out.println(ans);

        }

        static class Item implements Comparable<Item> {
            int val;
            int start;

            public Item(int a, int b) {
                val = a;
                start = b;
            }

            @Override
            public int compareTo(Item item) {
                int ret = Integer.compare(val, item.val);
                if(ret == 0) ret = Integer.compare(start, item.start);
                return ret;
            }
        }


        static void precomp() {
            fact[0] = invFact[0] = invFact[1] = naturalInverse[0] = naturalInverse[1] = 1;
            for(int i = 1; i <= max; i++) {
                fact[i] = (fact[i-1]*i)%MOD;
                if(i == 1) continue;
                naturalInverse[i] = naturalInverse[MOD % i] * (MOD - MOD/i) % MOD;
                invFact[i] = (invFact[i-1]*naturalInverse[i])%MOD;
            }
        }

        static long binomial(int a, int b) {
            if(a < b) return 0;
            return ((fact[a]*invFact[b])%MOD*invFact[a-b])%MOD;
        }


    }

    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.io.*;
import java.math.*;


public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static int dp[][][][];
	 static int mod=1000000007;
	 static int mod1=998244353;
	 static int max;
	 static long bit[];
	 static long seg[];
	 static long fact[];
	 static long A[];
	 static long[] fac = new long[300001];
	   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();
		 
	      fac[0] = 1;

	      for (int i = 1; i <= 300000; i++)
	          fac[i] = fac[i - 1] * i % mod1;
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int k=i();
	        	Pair P[]=new Pair[2*n];
	        	int c=0;
	        	for(int i=0;i<n;i++) {
	        		P[c]=new Pair(i(),0);
	        		c++;
	        		P[c]=new Pair(i(),1);
	        		c++;
	        	}
	        	Arrays.sort(P);
	        	int cnt=0;
	        	long ans=0;
	        	for(int i=0;i<2*n;i++) {
	        		if(P[i].y==0)
	        			cnt++;
	        		else {
	        			ans+=nCrModPFermat(cnt-1, k-1, mod1);
	        			ans%=mod1;
	        			cnt--;
	        		}
	        	}

	        	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 long modInverse(long n, int p)
	    {
	        return power(n, p - 2, p);
	    }
	 
	    // Returns nCr % p using Fermat's
	    // little theorem.
	    static long nCrModPFermat(int n, int r,
	                             int p)
	    {
	 
	          if (n<r)
	              return 0;
	      // Base case
	        if (r == 0)
	            return 1;
	        
	 
	        return (fac[n] * modInverse(fac[r], p)
	                % p * modInverse(fac[n - r], p)
	                % p)
	            % p;
	    }


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;
			}
		}
//		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; 
        } 
    } 
} 



",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
80881cae,f8e7b886,"//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.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,Non-plagiarised
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,Non-plagiarised
9be0602e,c4ca2ff3,"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  int fun(int ch,int a[][],int tot[],int n){
        ArrayList<Integer>ar=new ArrayList<>();
        for(int i=0;i<n;i++){
            ar.add((a[i][ch]-(tot[i]-a[i][ch])));
        }
        Collections.sort(ar,Collections.reverseOrder());
        int cou=0;
        int ans=0;
        for(int i:ar){
            cou+=i;
            if(cou>0){
                ans++;
            }
            else
                break;
        }
return ans;
}
    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) {
               int n=Integer.parseInt(br.readLine());
               int a[][]=new int[n][5];
               int tot[]=new int[n];
               for(int i=0;i<n;i++){
                   String s=br.readLine();
                   tot[i]+=s.length();
                   for(int j=0;j<s.length();j++){
                       a[i][s.charAt(j)-'a']++;
                   }
               }
               int ans=0;
               for(int i=0;i<5;i++){
                   ans=Math.max(ans,fun(i,a,tot,n));
               }
               sb.append(ans+""\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 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,Non-plagiarised
11c2ab99,28c2d81a,"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.*;

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());
        }
    }
}
",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
5f3a196a,d76e3b9d,"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;
		}
	}
}
","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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
26e699de,f229aa7f,"//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.*;
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
28d8c381,417833c3,"import java.io.*;
import java.sql.SQLOutput;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int numCases = Integer.parseInt(br.readLine());
        for (int i = 0; i < numCases; i++) {
            int length = Integer.parseInt(br.readLine());
            int found = 0;
            int[] ret = new int[length + 1];
            for (int j = 1; j <= length; j++) {
                if (found == length - 1) {
                    break;
                }
                if (ret[j] == 0) {
                    System.out.println(""? "" + j);
                    System.out.flush();
                    int start = Integer.parseInt(br.readLine());
                    int lastNum = start;
                    boolean cont = true;
                    while (cont) {
                        System.out.println(""? "" + j);
                        System.out.flush();
                        int num = Integer.parseInt(br.readLine());
                        ret[lastNum] = num;
                        found++;
                        lastNum = num;
                        if (num == start)
                            cont = false;
                    }
                }
            }
            for (int j = 0; j <= length; j++)
                if (ret[j] == 0) ret[j] = j;
            System.out.print(""! "");
            for (int j = 1; j <= length; j++)
                System.out.print(ret[j] + "" "");
            System.out.println();
        }
        br.close();
    }
}","import java.io.*;
import java.util.*;


import java.math.*;
import java.math.BigInteger;


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)998244353,INF=Long.MAX_VALUE;
	//	static boolean set[]; 
	static int par[],partial[];
	static int Days[],P[][];
	static int sum=0,size[];
	static int seg[],col[];
	//	static ArrayList<Long> A;
	static char X[][];
	static boolean set[][];
	static int D[],min[],A[];
	static long dp[][];
	//	static HashSet<Integer> visited,imposters;
	//	static HashSet<Integer> set;
	//	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
	{	
		/*
		 * star,rope,TPST
		 * BS,LST,MS,MQ
		 */
		int T=i();
		outer:while(T-->0)
		{
			int N=i();
			int f[]=new int[N+5];
			int ask=ask(1);
			HashSet<Integer> set=new HashSet<>();
			int cnt=0;
			for(int i=1; i<=N; i++)
			{
				if(cnt+1==N)
				{
					set=new HashSet<>();
					for( i=0; i<=N; i++)set.add(i);
					for( i=1; i<=N; i++)set.remove(f[i]);
					int a=-1;
					for(int v:set)
					{
						a=v;
					}
					for(i=1; i<=N; i++)
					{
						if(f[i]==0)f[i]=a;
					}
					break;
				}
				if(f[i]==0)
				{
					int last=0;
					set=new HashSet<>();
					while(true)
					{
						int a=ask(i);
						f[last]=a;
						if(set.contains(a))
						{
							break;
						}
						last=a;
						set.add(a);
					}
					cnt+=set.size();
				}
				
			}
			for(int i=1; i<=N; i++)
			{
				ans.append(f[i]+"" "");
			}
			System.out.println(""! ""+ans);
			ans=new StringBuilder();
		}
		out.println(ans);
		out.close();
	}
	static int ask(int a)
	{
		System.out.println(""? ""+a);
		//		out.flush();
		return i();
	}
	static boolean f(String A,String B)
	{
		char X[]=A.toCharArray(),Y[]=B.toCharArray();
		if(X[X.length-1]=='0' && A.length()==B.length())
		{
			return A.equals(B);
		}
		else 
			if(X[X.length-1]=='0')
			{
				for(int i=0; i<Y.length-X.length; i++)
				{
					boolean f=true;
					for(int j=0; j<X.length; j++)
					{
						if(X[j]!=Y[i+j])
						{
							f=false;
						}
					}
					if(f)
					{
						for(int j=0; j<i; j++)
						{
							if(Y[j]=='0')f=false;
						}
						for(int j=i+X.length; j<Y.length; j++)
						{
							if(Y[j]=='0')f=false;
						}
						if(f) {
							//						System.out.println(B.substring(i+X.length));
							return true;
						}
					}
				}

				return false;
			}
			else
			{
				for(int i=0; i<=Y.length-X.length; i++)
				{
					boolean f=true;
					for(int j=0; j<X.length; j++)
					{
						if(X[j]!=Y[i+j])
						{
							f=false;
						}
					}
					if(f)
					{
						for(int j=0; j<i; j++)
						{
							if(Y[j]=='0')f=false;
						}
						for(int j=i+X.length; j<Y.length; j++)
						{
							if(Y[j]=='0')f=false;
						}
						if(f) {
							//						System.out.println(B.substring(i+X.length));
							return true;
						}
					}
				}

				return false;
			}
	}
	static String reverse (String X)
	{
		StringBuilder sb=new StringBuilder(X);
		return sb.reverse().toString();
	}
	static String binary(long x)
	{
		String str="""";
		long p=1L;
		while(p<=x)
		{
			if((p&x)!=0)str=""1""+str;
			else str=""0""+str;
			p<<=1;
		}
		return str;
	}

	static boolean can_loose(Trie root,boolean t)
	{
		if(root==null)return true; //never hits
		int cnt=0;
		for(Trie x:root.A)
		{
			if(x!=null)
			{
				cnt++;
				if(!can_loose(x,t^true)) 
				{
					//System.out.println(""TRUE FOR--> ""+x.ch+"" ""+t);
					return true;
				}
			}
		}
		if(cnt==0)return true;
		return false;
	}
	static boolean f(Trie root)
	{
		if(root==null)return false;		
		//		int cnt=0;
		for(Trie x:root.A)
		{
			if(x!=null)
			{
				//				cnt++;
				if(!f(x))
				{

					return true;
				}
			}
		}	
		return false;
	}
	static void insert(String X,Trie head)
	{
		Trie root=head;
		for(char x:X.toCharArray())
		{
			int a=x-'a';
			if(root.A[a]==null)root.A[a]=new Trie();
			root=root.A[a];
			root.ch=x;
		}
		root.ends=true;        
	}
	static boolean search(String X,Trie head)
	{
		Trie root=head;
		for(char x:X.toCharArray()) {
			int a=x-'a';
			if(root.A[a]==null)return false;
			root=root.A[a];
		}
		return root.ends;

	}
	static boolean starts_with(String X,Trie head)
	{
		Trie root=head;
		for(char x:X.toCharArray()) {
			int a=x-'a';
			if(root.A[a]==null)return false;
			root=root.A[a];
		}
		return true;
	}
	static int lower(ArrayList<Integer>A,int i)
	{
		int l=-1,r=A.size();
		while(r-l>1)
		{
			int m=(l+r)/2;
			if(A.get(m)>i)r=m;
			else l=m;
		}		
		return r;
	}
	static int upper(ArrayList<Integer>A,int i)
	{
		int l=-1,r=A.size();
		while(r-l>1)
		{
			int m=(l+r)/2;
			if(A.get(m)<i)l=m;
			else l=m;
		}		
		return l;
	}
	static String f()
	{
		StringBuilder X=new StringBuilder(i()+"""");int p=i();
		while(p-->0)X.append(""0"");
		return X.toString();
	}
	static long f(int i,int g,int x,int left)
	{
		if(x<=1)return left;
		if(i<0 || g==1)return left;
		//		System.out.println(i+"" ""+g);
		if(dp[i][g]==0)
		{
			int next=min[i];
			int new_gcd=(int)GCD(g,x);
			//System.out.println("" factor--> ""+x+"" gcd--> ""+g+"" new-->  ""+new_gcd);
			long s=0;
			int c=0;
			for(int j=next+1; j<=i; j++)
			{
				if(A[i]%new_gcd==0)
				{
					s+=new_gcd;
					c--;
				}
			}
			long a=0,b=0;
			a=f(i,g,x-1,left);
			b=s+f(next,new_gcd,x-1,left-c);
			dp[i][g]=Math.max(a, b);
		}
		return dp[i][g];
	}
	static boolean f(int A[],int B[],int x)
	{
		int c=0;
		int N=A.length;
		int l=0,r=x-1;
		for(int i=0; i<N; i++)
		{
			if(A[i]>=r && B[i]>=l)
			{
				r--;
				l++;
				c++;				
			}
			if(c>=x)return true;
		}
		return false;
	}
	static boolean isPalindrome(int A[])
	{
		int i=0,j=A.length-1;
		while(i<j)
		{
			if(A[i]!=A[j])return false;
			i++;
			j--;
		}
		return true;
	}
	static boolean isPalindrome(int A[],int x)
	{
		int i=0,j=A.length-1;
		while(i<j)
		{
			if(A[i]!=A[j])
			{
				if(A[i]==x)i++;
				else if(A[j]==x)j--;
				else return false;
			}
			else
			{
				i++;
				j--;
			}
		}
		return true;
	}
	static long fact[];
	static double nCr(int a,int b)
	{
		double x=fact[a], y=fact[b]*fact[a-b];
		return x/y;
	}
	static int f(ArrayList<Integer> A,int x)
	{
		int l=-1,r=A.size();
		while(r-l>1)
		{
			int m=(l+r)/2;
			if(A.get(m)<x)l=m;
			else r=m;
		}
		return r;
	}
	static boolean f(long a,long b,long x)
	{
		if(b==0)
		{
			return (x==a || x==b);
		}
		if(a<x)return false;
		else
		{
			if(a%b==x%b)return true;
			return f(b,a%b,x);
		}
	}

	static void dfs(int n,int p)
	{
		if(p!=-1)D[n]=D[p]+1;
		for(int c:g[n])
		{
			if(c!=p)
				dfs(c,n);
		}
	}
	static long f(long a,long A[])
	{
		int l=-1,r=A.length;
		while(r-l>1)
		{
			int m=(l+r)/2;
			if(A[m]<=a)l=m;
			else r=m;
		}
		return A[l];
	}
	static void build(int v,int tl,int tr,int A[])
	{
		if(tl==tr)
		{
			seg[v]=A[tl];
			return;
		}
		int tm=(tl+tr)/2;
		build(v*2,tl,tm,A);
		build(v*2+1,tm+1,tr,A);
		seg[v]=Math.min(seg[v*2], seg[v*2+1]);
	}
	static void update(int v,int tl,int tr,int index,int x)
	{
		if(tl==tr && tl==index)
		{
			seg[v]=x;
			return;
		}		
		int tm=(tl+tr)/2;
		if(index<=tm)update(v*2,tl,tm,index,x);
		else update(v*2+1,tm+1,tr,index,x);
		seg[v]=Math.min(seg[v*2], seg[v*2+1]);
	}
	static int ask(int v,int tl,int tr,int l,int r)
	{
		//		System.out.println(v);
		//		if(v>100)return 0;
		if(l>r)return Integer.MAX_VALUE;
		if(tl==l && tr==r)return seg[v];
		int tm=(tl+tr)/2;
		int a=ask(v*2,tl,tm,l,Math.min(tm, r));
		//		System.out.println(""for--> ""+(v)+"" tm--> ""+(tm+1)+"" tr--> ""+tr+"" l--> ""+Math.max(l, tm+1)+"" r--> ""+r);
		int b=ask(v*2+1,tm+1,tr,Math.max(l, tm+1),r);
		return Math.min(a, b);
	}
	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 int ask(int a,int b)
	{
		System.out.println(""? ""+a+"" ""+b);
		return i();
	}




	static long and(int i,int j)
	{
		System.out.println(""and ""+i+"" ""+j);
		return l();
	}
	static long or(int i,int j)
	{
		System.out.println(""or ""+i+"" ""+j);
		return l();
	}
	static boolean is_Sorted(int A[])
	{
		int N=A.length;
		for(int i=1; i<=N; i++)if(A[i-1]!=i)return false;
		return true;
	}
	static boolean f(StringBuilder sb,String Y,String order)
	{
		StringBuilder res=new StringBuilder(sb.toString());
		HashSet<Character> set=new HashSet<>();
		for(char ch:order.toCharArray())
		{
			set.add(ch);
			for(int i=0; i<sb.length(); i++)
			{
				char x=sb.charAt(i);
				if(set.contains(x))continue;
				res.append(x);
			}
		}

		String str=res.toString();
		return str.equals(Y);
	}
	static boolean all_Zero(int f[])
	{
		for(int a:f)if(a!=0)return false;
		return true;
	}
	static long form(int a,int l)
	{
		long x=0;
		while(l-->0)
		{
			x*=10;
			x+=a;
		}
		return x;
	}
	static int count(String X)
	{
		HashSet<Integer> set=new HashSet<>();
		for(char x:X.toCharArray())set.add(x-'0');
		return set.size();
	}


	//	static void build(int v,int tl,int tr,long A[])
	//	{
	//		if(tl==tr)
	//		{
	//			seg[v]=A[tl];
	//		}
	//		else
	//		{
	//			int tm=(tl+tr)/2;
	//			build(v*2,tl,tm,A);
	//			build(v*2+1,tm+1,tr,A);
	//			seg[v]=Math.min(seg[v*2], seg[v*2+1]);
	//		}
	//	}

	static int [] sub(int A[],int B[])
	{
		int N=A.length;
		int f[]=new int[N];
		for(int i=N-1; i>=0; i--)
		{
			if(B[i]<A[i])
			{
				B[i]+=26;
				B[i-1]-=1;
			}
			f[i]=B[i]-A[i];
		}
		for(int i=0; i<N; i++)
		{
			if(f[i]%2!=0)f[i+1]+=26;
			f[i]/=2;
		}
		return f;
	}





	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 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];
		Days=new int[N+1];
		P=new int[N+1][(int)(Math.log(N)+10)];
		//		set=new boolean[N+1];
		g=new ArrayList[N+1];
		D=new int[N+1];
		for(int i=0; i<=N; i++)
		{

			g[i]=new ArrayList<>();		
			Days[i]=-1;
			D[i]=Integer.MAX_VALUE;
			//D2[i]=INF;
		}
	}



	static  long pow(long a,long b)
	{
		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(boolean A[][])
	{
		for(boolean a[]:A)print(a);
	}
	static void print(long A[][])
	{
		for(long a[]:A)print(a);
	}
	static void print(int A[][])
	{
		for(int a[]:A)print(a);
	}
	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 Trie
{
	char ch;
	Trie A[];
	boolean ends;
	Trie()
	{
		ch='*';
		A=new Trie[26];
		ends=false;
	}
}


//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,Non-plagiarised
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,Plagiarised
a7e7f371,f8e7b886,"
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.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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
54488276,f4757480,"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()); }
	}
}","import java.util.*;
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]);
                Arrays.sort(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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
1c4d348d,565f77b7,"/* 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 Solution {
    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 class SortbyHeight implements Comparator<Struct>
        {
            public int compare(Struct a, Struct b)
            {
                return a.h - b.h;
            }
        }
    static class Struct{
        int h,ind;
        Struct(int h,int ind){
            this.h=h;
            this.ind=ind;
        }
    }

    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        FastReader scn = new FastReader();
        int t, k, i, j, l, f, max=0;
        t=scn.nextInt();
        while(t-->0){
            int n=scn.nextInt();
            int m=scn.nextInt();
            int x=scn.nextInt();
            Struct a[]=new Struct[n];
            for (i=0;i<n;i++){
                a[i]=new Struct(scn.nextInt(),i);
            }
            Arrays.sort(a,new SortbyHeight());
            int b[]=new int[n];
            int ms=1;
            for (i=0;i<n;i++){
                if (ms>m){
                    ms=1;
                }
                b[a[i].ind]=ms;
                ms++;
            }
            System.out.println(""YES"");
            for (i=0;i<n;i++){
                System.out.print(b[i]+"" "");
            }
            System.out.println();
        }   
    }
}
","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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
9069684f,bf85ab7b,"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.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,Non-plagiarised
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,Non-plagiarised
505f8562,ed37ba7d,"
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
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);
    }

    long MOD= 1000000007;
    void solve(){
        int n= in.nextInt();
        int k= in.nextInt();
        long[] a=longArr(k);
        long[] t=longArr(k);
        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[(int) (a[i]-1)]= t[i];
        }
        long[] left= new long[n];
        left[0]= ans[0];
        for(int i=1;i<n;i++) {
            left[i]= min(left[i-1]+1,ans[i]);
        }
        long[] right= new long[n];
        right[n-1]= ans[n-1];
        for(int i=n-2;i>=0;i--) {
            right[i]= min(right[i+1]+1,ans[i]);
        }
        for(int i=0;i<n;i++)
            sb.append(min(left[i], right[i])).append("" "");

        sb.append(""\n"");
    }

    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) (p1.first - p2.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;
        }
    }
}","import java.io.*;
import java.util.*;
import java.lang.*;

public class codeforces {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            long startTime = System.currentTimeMillis();
            try {
                sc = new InputReader(new FileInputStream(""input.txt""));
                out = new PrintWriter(new FileOutputStream(""output.txt""));
                pr = new PrintWriter(new FileOutputStream(""error.txt""));
            } catch (Exception ignored) {
            }
            int t = 1;
            int tt = t;
            t = sc.nextInt();
            while (t-- > 0) {
                solve();
            }
            long endTime = System.currentTimeMillis();
            System.out.println(""Time: "" + (endTime - startTime) / tt + "" ms"");
            out.flush();
            pr.flush();

        } else {
            sc = new InputReader(inputStream);
            out = new PrintWriter(outputStream);
            pr = new PrintWriter(outputStream);
            int t = 1;
            t = sc.nextInt();
            while (t-- > 0) {
                solve();
            }
            out.flush();
        }
    }

    public static void solve() {
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            dp[i] = inf;    
            ans[i] = inf;
        }
        m = sc.nextInt();
        for (int i = 0; i < m; i++)
            arr[i] = sc.nextInt() - 1;
        for (int i = 0; i < m; i++) {
            arr2[i] = sc.nextInt();
            dp[(int)arr[i]] = arr2[i];
        }
        temp = inf;
        for (int i = 0; i < n; i++) {
            temp = Math.min(temp, dp[i]);
            ans[i] = Math.min(ans[i], temp);
            temp++;
        }
        temp = inf;
        for (int i = (int)n - 1; i > -1; i--) {
            temp = Math.min(temp, dp[i]);
            ans[i] = Math.min(ans[i], temp);
            temp++;
        }
        for (int i = 0; i < n; i++)
            out.print(ans[i] + "" "");
        out.println("""");
    }
    /*
     * Set Iterator Iterator value = set.iterator(); Displaying the values after
     * iterating through the iterator
     * System.out.println(""The iterator values are: ""); while (value.hasNext()) {
     * System.out.println(value.next()); }
     */

    /*
     * Map Iterator: for (Map.Entry<Integer, Integer> entry : map.entrySet()){
     * System.out.println(""Key => "" + entry.getKey() + "", Value => "" +
     * entry.getValue());}
     */
    // Globals

    public static long n, m, temp;
    public static int template_array_size = (int) 1e6 + 16813;
    public static long[] arr = new long[template_array_size];
    public static long[] arr2 = new long[template_array_size];
    public static long[] dp = new long[template_array_size];
    public static long[] ans = new long[template_array_size];
    public static int inf = Integer.MAX_VALUE;
    public static int minf = Integer.MIN_VALUE;
    public static int mod = 1000000007;
    public static int ml = (int) 1e9;
    public static String s = """";
    public static InputReader sc;
    public static PrintWriter out;
    public static PrintWriter pr;

    // Pair

    static class Pair {
        int first, second;

        Pair(int x, int y) {
            this.first = x;
            this.second = y;
        }
    }

    // FastReader Class

    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());
        }
    }

    // Req Functions
    public static void fill(int[][] dp, int x) {
        for (int i = 0; i < dp.length; ++i) {
            for (int j = 0; j < dp[0].length; ++j) {
                dp[i][j] = x;
            }
        }
    }

    public static int gcd(int a, int b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    public static int lcm(int a, int b) {
        return (a / gcd(a, b)) * b;
    }

    public 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 / gcd(a, b)) * b;
    }

    public static long nCr(int n, int k) {
        long ans = 1L;
        k = k > n - k ? n - k : k;
        int j = 1;
        for (; j <= k; j++, n--) {
            if (n % j == 0) {
                ans *= n / j;
            } else if (ans % j == 0) {
                ans = ans / j * n;
            } else {
                ans = (ans * n) / j;
            }
        }
        return ans;
    }

    public static String reverseString(String input) {
        StringBuilder str = new StringBuilder("""");

        for (int i = input.length() - 1; i >= 0; i--) {
            str.append(input.charAt(i));
        }
        return str.toString();
    }

    public static int maxOf3(int x, int y, int z) {
        return Math.max(x, Math.max(y, z));
    }

    public static int minof3(int x, int y, int z) {
        return Math.min(x, Math.min(y, z));
    }

    public static long maxOf3(long x, long y, long z) {
        return Math.max(x, Math.max(y, z));
    }

    public static long minof3(long x, long y, long z) {
        return Math.min(x, Math.min(y, z));
    }

    public static void arrInput(int[] arr, int n) {
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextInt();
    }

    public static void arrInput(long[] arr, int n) {
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextLong();
    }

    public static void arrInput(Pair[] pair, int n) {
        for (int i = 0; i < n; i++)
            pair[i] = new Pair(sc.nextInt(), sc.nextInt());
    }

    public static int maxarrInput(int[] arr, int n) {
        int max = minf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
            max = Math.max(max, arr[i]);
        }
        return max;

    }

    public static long maxarrInput(long[] arr, int n) {
        long max = minf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
            max = Math.max(max, arr[i]);
        }
        return max;
    }

    public static int minarrInput(int[] arr, int n) {
        int min = inf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
            min = Math.max(min, arr[i]);
        }
        return min;
    }

    public static long minarrInput(long[] arr, int n) {
        long min = inf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
            min = Math.max(min, arr[i]);
        }
        return min;
    }

    public static int lowerBound(int[] arr, int x) {
        int l = -1, r = arr.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (arr[m] >= x)
                r = m;
            else
                l = m;
        }
        return r;
    }

    public static int upperBound(int[] arr, int x) {
        int l = -1, r = arr.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (arr[m] <= x)
                l = m;
            else
                r = m;
        }
        return l + 1;
    }

    public static void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int[n1];
        int R[] = new int[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++;
        }
    }

    public static void reversesort(int arr[], int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;
            reversesort(arr, l, m);
            reversesort(arr, m + 1, r);
            merge(arr, l, m, r);
        }
    }

    public 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++;
        }
    }

    public static void reversesort(long arr[], int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;
            reversesort(arr, l, m);
            reversesort(arr, m + 1, r);
            merge(arr, l, m, r);
        }
    }

    // debug

    public static boolean sysFlag = System.getProperty(""ONLINE_JUDGE"") == null;

    public static void debug(int[][] dp) {
        if (sysFlag) {
            for (int i = 0; i < dp.length; ++i) {
                pr.print(i + ""--> "");
                for (int j = 0; j < dp[0].length; ++j) {
                    pr.print(dp[i][j] + "" "");
                }
                pr.println("""");
            }
        }
    }

    public static void debug(long[][] dp) {
        if (sysFlag) {
            for (int i = 0; i < dp.length; ++i) {
                pr.print(i + ""--> "");
                for (int j = 0; j < dp[0].length; ++j) {
                    pr.print(dp[i][j] + "" "");
                }
                pr.println("""");
            }
        }
    }

    public static void debug(int x) {
        if (sysFlag)
            pr.println(""Int-Ele: "" + x);
    }

    public static void debug(String x) {
        if (sysFlag)
            pr.println(""String: "" + x);
    }

    public static void debug(char x) {
        if (sysFlag)
            pr.println(""Char: "" + x);
    }

    public static void debug(long x) {
        if (sysFlag)
            pr.println(""Long-Ele: "" + x);
    }

    public static void debug(int[] arr, int n) {
        if (sysFlag) {
            for (int i = 0; i < n; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(char[] arr) {
        if (sysFlag) {
            for (int i = 0; i < arr.length; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(long[] arr, int n) {
        if (sysFlag) {
            for (int i = 0; i < n; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(ArrayList<Integer> list) {
        if (sysFlag) {
            for (int i = 0; i < list.size(); ++i) {
                pr.println(i + "" -> "" + list.get(i));
            }
        }
    }

    public static void Ldebug(ArrayList<Long> list) {
        if (sysFlag) {
            for (int i = 0; i < list.size(); ++i) {
                pr.println(i + "" -> "" + list.get(i));
            }
        }
    }

    public static void debugmapII(HashMap<Integer, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Integer, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapLI(HashMap<Long, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Long, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapLL(HashMap<Long, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Long, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapIL(HashMap<Integer, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Integer, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapSL(HashMap<String, Long> map) {
        if (sysFlag) {
            for (Map.Entry<String, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapCL(HashMap<Character, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Character, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapSI(HashMap<String, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<String, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapCI(HashMap<Character, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Character, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debug(Set<Integer> set) {
        if (sysFlag) {
            Iterator value = set.iterator();
            int i = 1;
            while (value.hasNext()) {
                pr.println((i++) + ""-> "" + value.next());
            }
        }
    }
}
",0,Non-plagiarised
d3a96420,ff34fab2,"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();
  }
}
","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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
7f42483d,c9a316ca,"import java.io.*;
import java.util.*;

public class Main
{
	static final boolean INPUT_FROM_FILE = false;
	static final String INPUT_FILE = ""input/input.txt"";
	static final String OUTPUT_FILE = ""input/output.txt"";
	static final long M = (long) 1e9 + 7;
	static FastReader in;
	static FastWriter out;

	static
	{
		try
		{
			in = new FastReader();
			out = new FastWriter();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws IOException
	{
		int t = in.nextInt();
		while (t-- > 0) solve();
		out.close();
	}

	static long[][] dp;

	static long dfs(List<List<Integer>> tree, int parent, int current, int parentState, int[][] vRange) {
		if(dp[current][parentState] != -1) {
			return dp[current][parentState];
		}
		long left = Math.abs(vRange[current][0] - vRange[parent][parentState]);
		long right = Math.abs(vRange[current][1] - vRange[parent][parentState]);
		for(int child : tree.get(current)) {
			if(child != parent) {
				left += dfs(tree, current, child, 0, vRange);
				right += dfs(tree, current, child, 1, vRange);
			}
		}
		dp[current][parentState] = Math.max(left, right);
		return dp[current][parentState];
	}


	private static void solve()
	{
		int n = in.nextInt();
		int[][] vRange = new int[n+1][2];
		for(int i=1; i<=n; i++) {
			int l = in.nextInt(), r = in.nextInt();
			vRange[i][0] = l;
			vRange[i][1] = r;
		}
		List<List<Integer>> tree = new ArrayList<>();
		for(int i=0; i<=n; i++) tree.add(new LinkedList<>());
		for(int i=0; i<n-1; i++) {
			int u = in.nextInt();
			int v = in.nextInt();
			tree.get(u).add(v);
			tree.get(v).add(u);
		}

		dp = new long[n+1][2];
		for(int i=0; i<=n; i++) {
			Arrays.fill(dp[i], -1);
		}
		long left = 0, right = 0;

		for(int v : tree.get(1)) {
			left += dfs(tree, 1, v, 0, vRange);
			right += dfs(tree, 1, v, 1, vRange);
		}

		out.println(Math.max(left, right));

	}

	static class FastReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br;

		public FastReader() throws FileNotFoundException
		{
			if (INPUT_FROM_FILE)
			{
				this.stream = new FileInputStream(INPUT_FILE);
				br = new BufferedReader(new FileReader(INPUT_FILE));
			} else
			{
				this.stream = System.in;
				br = new BufferedReader(new InputStreamReader(System.in));
			}
		}

		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
		{
			boolean isSpaceChar(int ch);
		}
	}

	static class FastWriter
	{
		BufferedWriter writer;
		StringBuilder sb;

		public FastWriter() throws IOException
		{
			if (INPUT_FROM_FILE) writer = new BufferedWriter(new FileWriter(OUTPUT_FILE));
			else writer = new BufferedWriter(new PrintWriter(System.out));
			sb = new StringBuilder();
		}

		public void print(Object obj)
		{
			sb.append(obj);
		}

		public void println(Object obj)
		{
			sb.append(obj).append('\n');
		}

		public void close() throws IOException
		{
			writer.write(sb.toString());
			writer.close();
		}
	}
}

","
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
7d9b95c0,9d33ca79,"import java.util.*;
import java.math.*;
public class Main {
	
	public static class Edge{
		int u;
		int v;
//		int wt;
		Edge(int u, int v){
			this.u = u;
			this.v = v;
//			this.wt = wt;
		}
	}

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int t = scn.nextInt();
		StringBuilder sb = new StringBuilder("""");
		for(int A=0 ; A<t ; A++) {
			int n = scn.nextInt();
			List<Edge>[] graph = new ArrayList[n];
			for(int i=0 ; i<n ; i++) {
				graph[i] = new ArrayList<>();
			}
			String[] arr = new String[n-1];
			for(int i=0 ; i<n-1 ; i++) {
				int u = scn.nextInt();
				int v = scn.nextInt();
				arr[i] = (u-1) + "" "" + (v-1);
				graph[u-1].add(new Edge(u-1, v-1));
				graph[v-1].add(new Edge(v-1, u-1));
			}
			
			boolean flag = false;
			int src = 0;
			for(int i=0 ; i<n ; i++) {
				if(graph[i].size() > 2) {
					flag = true;
				}else if(graph[i].size() == 1)
					src = i;
			}
			if(flag) {
				sb.append(-1 + ""\n"");
			}else {
				Map<String, Integer> hm = new HashMap<>();
				int count = 0;
				int val = 2;
	//			System.out.println(src);
				
				while(count < n) {
					List<Edge> e = graph[src];
					int i=0;
					while(i < e.size() && hm.containsKey(src + "" "" + e.get(i).v))
						i++;
					if(i < e.size()) {
						int nbr = e.get(i).v;
		//				System.out.println(src + "" "" + nbr);
						hm.put(src + "" "" + nbr, val);
						hm.put(nbr + "" "" + src, val);
						val = 5 - val;
						src = nbr;
					}
						
					count++;
				}
				for(int i=0 ; i<arr.length ; i++) {
					int wt = hm.get(arr[i]);
					sb.append(wt + "" "");
				}
				sb.append(""\n"");
			}
		}
		System.out.println(sb);
	}

}
","import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class NotAssigning {
    static ArrayList<Integer>[]adj;
    static boolean vis [];
    static int edges[];
    // we need to check that every path of length 1 or 2 must be a prime number
    // Idea--> we will only use 2 , 3 for the weight assignment
    // no assignment will be valid if there exists a node connected to 3 others

    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();
            vis= new boolean [n];
            adj= new ArrayList[n];
            TreeMap<Integer,Pair> idx = new TreeMap<>();
            TreeMap<Pair,Integer> w= new TreeMap<>();
            boolean notValid = false;
            for(int i =0;i<n;i++){
                adj[i]= new ArrayList<>();
            }
            for(int i =1;i<n;i++){
                int u = sc.nextInt()-1;
                int v = sc.nextInt()-1;
                int max = Math.max(u,v);
                int min = Math.min(u,v);
                idx.put(i,new Pair(min , max));
                adj[u].add(v);
                adj[v].add(u);
                if(adj[u].size()>2||adj[v].size()>2)notValid=true;
            }
            if(notValid){
                pw.println(-1);
                continue;
            }
            dfs(0,2,w);
//            vis[0]=true;
//            dfs(adj[0].get(0),2,w);
//            if(adj[0].size()==2)dfs(adj[0].get(1),3,w);
            for(int i =1;i<n;i++){
                pw.print(w.get(idx.get(i))+"" "");
            }
            pw.println();

        }
        pw.close();
    }
    static void dfs(int node , int w , TreeMap<Pair , Integer>weight){
        vis[node]=true;
        int i =0;
        for(int x : adj[node]){
            if(!vis[x]) {
                int min = Math.min(x , node);
                int max = Math.max(x , node);
                if(i%2==0){
                    weight.put(new Pair(min , max),w);
                    dfs(x, 5-w,weight);
                }
                else{
                    weight.put(new Pair(min , max),5-w);
                    dfs(x, w, weight);
                }
                i++;
            }

            }
        }


    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 this.y-o.y;
            return this.x-o.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 {
            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,Non-plagiarised
354d060f,e1c4f3db,"import java.util.*;
import java.io.*;
public class CodeForces {
	// 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 in = new FastReader();
		OutputStream op = System.out;
		PrintWriter out = new PrintWriter(op);
		int t = in.nextInt();
		for (int i = 1; i <= t; i++) {
			int n=in.nextInt();
			int arr[]=new int[n];
			for(int j = 0; j < n; j++)
				arr[j]=in.nextInt();
			helper(n,arr,out);
			out.println();
		}
		out.close();

	}

public static void helper(int n,int arr[],PrintWriter o) 
	{
		int max=Integer.MIN_VALUE;
		for(int i=2;i<n;i++)
				max=Math.max(max,arr[i]);
		int ans=1,low=1,high=max;
		while(low<=high)
		{
			int mid=low+(high-low)/2;
			if(canFit(mid,arr))
				{
					ans=mid;
					low=mid+1;
				}
				else 
					high=mid-1;
		}
		o.print(ans);
	}
	static	boolean canFit(int mid,int arr[])
	{
		int copy[]=Arrays.copyOf(arr, arr.length);
		for(int i=arr.length-1;i>=0;i--)
		{
			if(copy[i]<mid)
				return false;
			int min=Math.min(copy[i]-mid,arr[i])/3;
			if(i>=2){
			copy[i-1]+=min;
			copy[i-2]+=2*min;
		}}
		return true;
	}
}","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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
085ddefc,1500a4fa,"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();
            String a = sc.next();
            String b = sc.next();

            int change = 0;
            int nochange = 0;
            for(int i=0; i<n; i++){

                if(a.charAt(i) == b.charAt(i)){
                    nochange++;
                }
                else{
                    change++;
                }

            }

            if(change%2 == 0 && nochange%2 == 0){
                
                int count1 = 0;
                for(int i=0; i<n; i++){
                    if(a.charAt(i) != b.charAt(i) && a.charAt(i) == '1'){
                        count1++;
                    }
                }

                if(count1 == change/2){
                    System.out.println(change);
                }
                else{
                    System.out.println(-1);
                }

            }
            else if(change%2 == 0 && nochange%2 == 1){

                // both ways possible

                int count1 = 0;
                int ans = Integer.MAX_VALUE;
                for(int i=0; i<n; i++){
                    if(a.charAt(i) == b.charAt(i) && a.charAt(i) == '1'){
                        count1++;
                    }
                }

                if(count1 == nochange/2 + 1){
                    ans = Math.min(ans, nochange);
                }

                count1 = 0;
                for(int i=0; i<n; i++){
                    if(a.charAt(i) != b.charAt(i) && a.charAt(i) == '1'){
                        count1++;
                    }
                }

                if(count1 == change/2){
                    ans = Math.min(ans, change);
                }

                if(ans == Integer.MAX_VALUE){
                    System.out.println(-1);
                }
                else{
                    System.out.println(ans);
                }

            }
            else if(change%2 == 1 && nochange%2 == 0){
                System.out.println(-1);
            }
            else{

                int count1 = 0;
                for(int i=0; i<n; i++){
                    if(a.charAt(i) == b.charAt(i) && a.charAt(i) == '1'){
                        count1++;
                    }
                }

                if(count1 == nochange/2 + 1){
                    System.out.println(nochange);
                }
                else{
                    System.out.println(-1);
                }

            }

        }

    }

}

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;
        }
    }
}

","       

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();
	    String a=sc.next();
	    String b=sc.next();
	   int i;
	   int zero=0,one=0;
	     int x=0,y=0,x1=0,y1=0;
	    for(i=0;i<n;i++){
	        if(a.charAt(i)=='0')
	        zero++;
	        else
	        one++;
	    }
	    if(one==0){
	        if(a.equals(b))
	        System.out.println(""0"");
	        else
	        System.out.println(""-1"");
	    }
	    else{
	        int same=0,diff=0;
	        for(i=0;i<n;i++){
	            if(a.charAt(i)==b.charAt(i)){
	                same++;
	                x++;
	                if(a.charAt(i)=='1'){
	                    x1++;
	                    
	                }
	            }
	            else{
	                diff++;
	                y++;
	                if(a.charAt(i)=='1'){
	                    y1++;
	                    
	                }
	            }
	            
	        }
	        int ans=Integer.MAX_VALUE;
    if(x%2!=0&&(x+1)/2==x1){
        ans=x;
        
    }
    if(y%2==0&&(y/2)==y1){
ans=Math.min(ans,y);
    }
    if(ans==Integer.MAX_VALUE){
        
        System.out.println(""-1"");
        
    }else{
        
        System.out.println(ans);
    }
	       
	    }
	    
	}
	    
	}
    
}
	",0,Non-plagiarised
11373c16,7011024d,"/* 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.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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
1386da0e,f87eb1b3,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
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.Iterator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;


public class Solution {

	public static int INF= Integer.MAX_VALUE;
	public static long MOD= 1000000000+7L;

	public static int WHITE= 0;
	public static int GRAY= 1;
	public static int BLACK= 2;


	class Pair{
		public int day;
		int count;

		Pair(int d, int c){
			day=d; count=c;
		}
	}

	static class Solver {

		public void solve(InputReader in, PrintWriter out) {
			int tt=in.nextInt();
			//int tt=1;
			for(int cases=1;cases<=tt;cases++){
				int n= in.nextInt();
				long odd_min= Long.MAX_VALUE;
				long even_min= Long.MAX_VALUE;
				long ans= Long.MAX_VALUE;
				int odd_length=0;
				int even_length=0;

				long total=0;
				for(int segment=1;segment<=n;segment++){
					int cost= in.nextInt();
					total+=cost;
					if(segment%2==1){
						odd_min = Math.min(odd_min, cost);
						odd_length++;
					}
					else{
						even_min = Math.min(even_min, cost);
						even_length++;
					}

					if(segment>1){

						{

							long value=total-(odd_min+even_min);
							value+= odd_min * (n-odd_length+1);
							value+= even_min * (n-even_length+1);
							ans= Math.min(value, ans);
						}
					}
				}

				System.out.println(ans);
			}
		}


	} 

	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.solve(in, out);
		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());
		}

	}
}","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.PrintStream;
import java.io.PrintWriter;
public class A {
 
	
	/* 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 aa, int bb)
		{
			first = aa; second = bb;
		}
		public int compareTo(Pair o)
		{
			if(this.second < o.second) return -1;
			if(this.second > o.second) return +1;
			return this.first - o.first;
		}
	}
	
	static class Tuple implements Comparable<Tuple>{
		long first, second,third;
		public Tuple(long first, long second, long 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 boolean isPrime(long n) 
	{
		if(n == 1)
		{
			return false;
		}
		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[n+1];
		Arrays.fill(prime, true);
		
		ArrayList<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 gcd(int a, int b)
	{
		if(b == 0)
		 return a;
		
		else
		return gcd(b,a%b);
	} 
 
		public static int lcm(int a, int b)
	    {
	        return (a / gcd(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(int n, int k) 
	    {
			long ans = 1;
			for(int i = 0;i<k;i++)
			{
				ans *= (n-i);
				ans /= (i+1);
			}
			return ans;
		}
 
		public static void Sort(int[] a) 
		{
			List<Integer> l = new ArrayList<>();
			for (int 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);
		}
		
		//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));
		   }
		   
		   /*
		    * 
		    * >=         <=
		   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(int a[], int 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 main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out);
		
		int t = sc.nextInt();
		while(t-- > 0)
		{
			long INF = 1000000000000000007L;
			int n = sc.nextInt();
			
			long[] c = new long[n+1];
			for(int i = 1;i<=n;i++) c[i] = sc.nextLong();
			
			long ans = INF;
			long mo = INF,  so = 0, co = 0;
			long me = INF,  se = 0, ce = 0;
			
			for(int i=1;i<=n;i++)
			{
				if(i%2 == 1)
				{
					mo = min(mo,c[i]);
					so += c[i];
					co++;
				}
				else
				{
					me = min(me,c[i]);
					se += c[i];
					ce++;
				}
				if(i>=2)
				{
					long x = so + (n - co) * mo + se + (n - ce) * me;
					ans=min(ans,x);
				}
			}
			fout.println(ans);
		}
			
		fout.close();
	}
}",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
2.921E+060,46e9aed4,"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.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();
    }
}

",0,Non-plagiarised
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,Non-plagiarised
90f01508,e00b1794,"// import java.io.DataInputStream; 
// import java.io.FileInputStream; 
// import java.io.IOException; 
import java.io.*; 
import java.util.*;

public class one
{
  static Scanner sc=new Scanner(System.in);
  boolean prime[];
  static int prev=-1;
  static int dp[][];

  public static int[] input(int size){
    int arr[]=new int[size];
    for(int i=0;i<size;i++)
    arr[i]=sc.nextInt();
    return arr;
  }

  public static void main(String[] args) {
    //int testcase=1;
    int testcase=sc.nextInt();
    //System.out.println(""HI"");
      while(testcase-->0){
        // int x=sc.nextInt();
        // int y=sc.nextInt();
       //String str[]=new String[size];
       solve();
       System.out.println();
    }    
  } 

  public static void solve(){
    HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
    int size=sc.nextInt();
    int arr[][]=new int[size-1][2];
    for(int i=0;i<size-1;i++){
      arr[i][0]=sc.nextInt();
      arr[i][1]=sc.nextInt();
    }
    for(int x[]:arr){
      map.put(x[0],map.getOrDefault(x[0], 0)+1);
      map.put(x[1],map.getOrDefault(x[1], 0)+1);
      if(map.get(x[0])>2||map.get(x[1])>2){
        System.out.println(-1);
        return;
      }
    }
    List<List<Integer>> adj=new ArrayList<>();
    for(int i=0;i<=size;i++)
    adj.add(new ArrayList<Integer>());
    for(int x[]:arr){
      adj.get(x[0]).add(x[1]);
      adj.get(x[1]).add(x[0]);
    }
    //System.out.println(adj);
    int vist[]=new int[size+1];
    HashMap<String,Integer> ans=new HashMap<String,Integer>();
    for(int i=1;i<=size;i++){
      if(vist[i]==0){
        dfs(i,vist,adj,ans,2);
      }
    }
    //System.out.println(ans);
    for(int x[]:arr){
      //System.out.print(map.get(x[0]));
      int a=Math.min(x[0],x[1]);
      int b=Math.max(x[0],x[1]);
      String s=a+"" ""+b;
      System.out.print(ans.get(s)+"" "");
    }
    // map=new HashMap<Integer,Integer>();
    // for(int x[]:arr){
    //   if(map.containsKey(x[0])){
    //     int val=13-map.get(x[0]);
    //     map.put(x[1],val);
    //     System.out.print(val+"" "");
    //   }else if(map.containsKey(x[1])){
    //     int val=13-map.get(x[1]);
    //     map.put(x[0],val);
    //     System.out.print(val+"" "");
    //   }else{
    //     System.out.print(2+"" "");
    //     map.put(x[0],2);
    //     map.put(x[1],2);
    //   }
    // }

  }
  public static void dfs(int node,int vist[],List<List<Integer>> adj,HashMap<String,Integer> ans,int val){
    vist[node]=1;
    for(int i:adj.get(node)){
      if(vist[i]==1)
      continue;
      int x=Math.min(i, node);
      int y=Math.max(i, node);
      ans.put(x+"" ""+y,val);
      dfs(i,vist,adj,ans,5-val);
      val=5-val;
    }
  }
}","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();
            //out.println(""hee"");
            //int testCases=1;
            while(testCases-- > 0){
                solve(in);
            }
            out.close();
        } catch (Exception e) {
            return;
        }
    }
    public static void solve( FastReader in){
        int n=in.nextInt();
                List<List<Pair>> graph=new ArrayList<>();
                for(int i=0;i<n;i++){
                    graph.add(new ArrayList<>());
                }
                //out.println(""hee"");
                for(int i=0;i<n-1;i++){
                    int u=in.nextInt();
                    int v=in.nextInt();
                    u--;v--;
                    graph.get(u).add(new Pair(v,i));
                    graph.get(v).add(new Pair(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[] ans=new int[n-1];
                int[] vis=new int[n+1];
                vis[start]=1;
                int w=2;
                Queue<Integer> q=new LinkedList<>();
                q.add(start);
                while(!q.isEmpty()){
                    int x=q.poll();
                    for(Pair p:graph.get(x)){
                        if(vis[p.node]==0){
                            vis[p.node]=1;
                            q.add(p.node);
                            int idx=p.eg_indx;
                            ans[idx]=w;
                            if(w==2)w=5;
                            else w=2;    
                        }
                    }
                }
                for(int i:ans){
                    System.out.print(i+"" "");
                }
                System.out.println("""");
    }
    static class Pair{
        int node;
        int eg_indx;
        Pair(int node,int eg_indx){
            this.node=node;
            this.eg_indx=eg_indx;
        }
    }
    static int gcd(int a,int b){
        if(b==0){
            return a;
        }
        return gcd(b,a%b);
    }
}",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
5766f176,e7a997b5,"import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        // write your code here
        boolean readFromLocal = true;
        //readFromLocal = false;
        String filepath = ""src/input.txt"";
        //FileInputStrviseam fileInputStream = new FileInputStream(filepath);
        InputReader inputReader = new InputReader(System.in);
        Solve s = new Solve();
        s.solve(inputReader);
    }
}

class Solve {

    public void solve(InputReader inputReader) {
        int t,n;
        t = inputReader.nextInt();
        while (t>0) {
            t--;
            n = inputReader.nextInt();
            Graph g = new Graph(n);
            g.res = new int[n-1];
            for(int i=1;i<n;i++){
                g.addEdge(inputReader.nextInt(), inputReader.nextInt(),i-1,true);
            }
            if (g.hasDegreeMoreThanTwo()){
                System.out.println(-1);
            }else {
                int minDegree = 2,node = 1;
                for(int i=1;i<=n;i++){
                    if (g.adj[i].size()<minDegree){
                        node = i;
                        minDegree = g.adj[i].size();
                    }
                }
                g.dfs(node,-1,2);
                for(int i=0;i<n-1;i++){
                    System.out.print(g.res[i] + "" "");
                }
                System.out.println();
            }
        }
    }
}
class PairComp implements Comparator<Pair> {

    @Override
    public int compare(Pair o1, Pair o2) {
        return (int) (o1.first - o2.first);
    }
}

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 {
        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;
    }
}

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 (int) (this.second - o.second);
    }
}

class Utils {
    static void swap(int[] res, int i, int j) {
        int temp = res[i];
        res[i] = res[j];
        res[j] = temp;
    }

    static long pow(long num, int n, long mod) {
        long res = num % mod;
        while (n > 0) {
            if ((n & 1) != 0) {
                res = (res * num) % mod;
            }
            num = (num * num) % mod;
            n >>= 1;
        }
        return res;
    }

}

class Graph {
    public ArrayList<int[]>[] adj;
    int size;
    boolean[] vis;
    public int [] res;
    Graph(int n){
        this.size = n;
        this.adj = new ArrayList[n+1];
        this.vis = new boolean[n+1];
        for (int i = 0; i <=n; i++) {
            adj[i] = new ArrayList<>();
        }
    }
    public void addEdge(int a, int b, int edge,boolean biDirectional){
        adj[a].add(new int[]{b, edge});
        if (biDirectional) {
            adj[b].add(new int[]{a, edge});
        }
    }

    public void dfs(int node,int parent,int prime){
        for (int[] nodePair: adj[node]) {
            if (nodePair[0]!=parent){
                res[nodePair[1]] = prime;
                dfs(nodePair[0],node,prime^1);
            }
        }
    }
    boolean hasDegreeMoreThanTwo() {
        for (int i = 0; i <= size; i++) {
            if (adj[i].size()>2){
                return true;
            }
        }
        return false;
    }

}
","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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
a5d5a95f,c4ca2ff3,"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);
  }
}

}
","/* 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,Non-plagiarised
4e9c4bf9,f9e08a46,"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.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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
1410e423,da5cf40b,"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();

	}

}
","/*****  --->         :)    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,Non-plagiarised
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,Non-plagiarised
5288afb7,df594a00,"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)
        {
            bu.readLine();
            String s[]=bu.readLine().split("" "");
            int n=Integer.parseInt(s[0]),k=Integer.parseInt(s[1]);
            int a[]=new int[n],i,x,ac[]=new int[n],b[]=new int[k];
            Arrays.fill(a,Integer.MAX_VALUE);

            s=bu.readLine().split("" "");
            for(i=0;i<k;i++) b[i]=Integer.parseInt(s[i])-1;
            s=bu.readLine().split("" "");
            for(i=0;i<k;i++)
            {
                x=Integer.parseInt(s[i]);
                ac[b[i]]=x;
            }

            PriorityQueue<Integer> pq=new PriorityQueue<>();
            for(i=0;i<n;i++)
            {
                if(ac[i]!=0) pq.add(ac[i]-i);
                if(!pq.isEmpty()) a[i]=Math.min(a[i],pq.peek()+i);
            }
            pq=new PriorityQueue<>();
            for(i=n-1;i>=0;i--)
            {
                if(ac[i]!=0) pq.add(ac[i]+i);
                if(!pq.isEmpty()) a[i]=Math.min(a[i],pq.peek()-i);
            }

            for(i=0;i<n;i++) sb.append(a[i]+"" "");
            sb.append(""\n"");
        }
        System.out.print(sb);
    }
}
","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) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
22b41936,9cea10af,"


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());
        }
    }


}







","//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; 
        } 
    } 
}
",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
1f6b81b1,51151974,"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 InterestingStory {

    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 {
        public void solve(InputReader sc, PrintWriter out) {
            int n = sc.nextInt();
            char[][] words = new char[n][];
            for(int i = 0; i < n; i++) words[i] = sc.next().toCharArray();
            int[][] arr = new int[n][];
            for(int i = 0; i < n; i++) {
                arr[i] = new int[words[i].length];
                for(int j = 0; j < arr[i].length; j++) arr[i][j] = words[i][j]-'a';
            }
            int max = 0;
            for(int now = 0; now < 5; now++) {
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
                for(int i = 0; i < n; i++) {
                    int nowcnt = 0;
                    int othercnt = 0;
                    for(int j = 0; j < arr[i].length; j++) {
                        if(arr[i][j]==now) nowcnt++;
                        else othercnt++;
                    }
                    pq.add(nowcnt-othercnt);
                }
                int canTake = 0;
                int sum = 0;
                while(!pq.isEmpty()) {
                    int nowAdd = pq.poll();
                    if(sum+nowAdd>0) {
                        sum += nowAdd;
                        canTake++;
                    } else {
                        break;
                    }
                }
                max = Math.max(max,canTake);
            }
            out.println(max);
        }

    }

    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) {
            arr[l] ^= arr[r];
            arr[r] ^= arr[l];
            arr[l] ^= arr[r];
            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) {
            arr[l] ^= arr[r];
            arr[r] ^= arr[l];
            arr[l] ^= arr[r];
            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.*;
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,Non-plagiarised
034030f3,bf992c91,"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.util.Arrays;
import java.util.Scanner;

public class P1525D {

    public static int[] ones, zeros;

    public static int[][] memo;

    public static void main(String[] args) {

        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int[] arr = new int[n];
        int oneCount = 0;
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextInt();
            oneCount += arr[i] % 2;
        }
        int o = 0, z = 0;
        ones = new int[oneCount];
        zeros = new int[n - oneCount];
        for (int i = 0; i < n; i++) {
            if (arr[i] % 2 == 1) {
                ones[o++] = i;
            } else {
                zeros[z++] = i;
            }
        }
        memo = new int[oneCount][n - oneCount];
        for (int[] row : memo) Arrays.fill(row, -1);
        System.out.println(dp(0, 0));

    }

    public static int dp(int oi, int zi) {

        if (oi == ones.length) {

            return 0;

        } else if (zi == zeros.length) {

            return 100000000;

        } else {

            if (memo[oi][zi] == -1) {
                memo[oi][zi] = Math.min(Math.abs(ones[oi] - zeros[zi]) + dp(oi + 1, zi + 1), dp(oi, zi + 1));
            }
            return memo[oi][zi];

        }

    }

}
",1,Plagiarised
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,Non-plagiarised
3e28571b,77b5c134,"import java.io.*;
import java.util.*;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class Ans implements Runnable {

	public static void main(String args[]) {
		Ans s = new Ans();
		s.run();
	}

	static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

	InputReader sc = null;
	PrintWriter pw = null;
	static ArrayList<Integer>[] G = new ArrayList[(int)(3e5+10)];
	static int[] dist = new int[(int)(3e5+10)];
	static int[] a = new int[(int)(3e5+10)];
	
	private static int[] nge(int n){		
		int[] edges = new int[n];
		Arrays.fill(edges,  -1);
		Stack<Integer> st = new Stack<>();
		st.push(0);
		for(int i = 1; i < n; i++){			
			while(!st.isEmpty() && a[i] >= a[st.peek()]){
				edges[st.pop()] = i;
			}
			st.push(i);			
		}		
		//debug(""nge"", edges);
		return edges;
	}
	
	private static int[] nle(int n){	
		int[] edges = new int[n];
		Arrays.fill(edges,  -1);
		Stack<Integer> st = new Stack<>();
		st.push(0);
		for(int i = 1; i < n; i++){
			while(!st.isEmpty() && a[i] <= a[st.peek()]){
				edges[st.pop()] = i;
			}
			st.push(i);
		}
		//debug(""nle"", edges);
		return edges;
	}
	
	private static int[] pge(int n){		
		int[] edges = new int[n];
		Arrays.fill(edges,  -1);
		Stack<Integer> st = new Stack<>();
		st.push(n-1);
		for(int i = n-2; i >= 0; i--){
			while(!st.isEmpty() && a[i] >= a[st.peek()]){
				edges[st.pop()] = i;
			}
			st.push(i);
		}
		//debug(""pge"", edges);
		return edges;
	}
	
	private static int[] ple(int n){	
		int[] edges = new int[n];
		Arrays.fill(edges,  -1);
		Stack<Integer> st = new Stack<>();
		st.push(n-1);
		for(int i = n-2; i >= 0; i--){
			while(!st.isEmpty() && a[i] <= a[st.peek()]){
				edges[st.pop()] = i;
			}
			st.push(i);
		}
		//debug(""ple"", edges);
		return edges;
	}
	
	private static void buildGraph(int[] edges){		
		for(int i = 0; i < edges.length; i++){
			if(edges[i] != -1){				
//				G[i].add(edges[i]);
//				G[edges[i]].add(i);
				G[min(i, edges[i])].add(max(i, edges[i]));
			}
		}
	}
	
	private static void bfs(int n){		
		dist[0] = 0;
		ArrayDeque<Integer> q = new ArrayDeque<>();
		q.add(0);
		
		while(!q.isEmpty()){
			int front = q.pollFirst();
			if(front == n-1){
				break;
			}
			for(int adj : G[front]){
				if(dist[adj] == (int)(1e9)){
					dist[adj] = 1 + dist[front];
					q.add(adj);
				}
			}
		}
	}
	
	public void run() {

		// InputStream is;
		// is = new FileInputStream(new File(""input.txt""));
		sc = new InputReader(System.in);
		pw = new PrintWriter(System.out);
		int n = sc.nextInt();
		a = new int[n];		
		for (int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
			G[i] = new ArrayList<Integer>();
		}		
		
		buildGraph(nge(n));
		buildGraph(nle(n));
		buildGraph(ple(n));
		buildGraph(pge(n));
		Arrays.fill(dist, (int)(1e9));
		
		bfs(n);
		
		pw.println(dist[n-1]);
		
		// is.close();
		pw.close();

	}
		
	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[5];
		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(stream));
			String stock = """";
			try {
				stock = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return stock;
		}

		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);
		}
	}
}","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

// https://codeforces.com/contest/1407/problem/D

public class Discrete_Centrifugal_Jumps {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] h = new int[n];
        for (int i = 0; i < n; i++) h[i] = scan.nextInt();
        System.out.println(getMinJump(h, n));
    }
    static int getMinJump(int[] h, int n) {
        int[] rightG = new int[n], leftG = new int[n];
        int[] rightS = new int[n], leftS = new int[n];
        Arrays.fill(rightG, -1); Arrays.fill(rightS, -1);
        Arrays.fill(leftG, -1); Arrays.fill(leftS, -1);
        Stack<Integer> stack = new Stack<>();

        // next greater in the right segment
        int i = 0;
        while (i < n) {
            if (!stack.empty() && h[i] >= h[stack.peek()]) rightG[stack.pop()] = i;
            else stack.push(i++);
        }
        stack = new Stack<>();
        // next smaller in the right segment
        i = 0;
        while (i < n) {
            if (!stack.empty() && h[i] <= h[stack.peek()]) rightS[stack.pop()] = i;
            else stack.push(i++);
        }
        stack = new Stack<>();
        // next greater in left segment
        i = n-1;
        while (i >= 0) {
            if (!stack.empty() && h[i] >= h[stack.peek()]) leftG[stack.pop()] = i;
            else stack.push(i--);
        }
        stack = new Stack<>();
        // next smaller in left segment
        i = n-1;
        while (i >= 0) {
            if (!stack.empty() && h[i] <= h[stack.peek()]) leftS[stack.pop()] = i;
            else stack.push(i--);
        }

        ArrayList<Integer>[] jump = new ArrayList[n];
        for (i = 0; i < n; i++) jump[i] = new ArrayList<>();
        for (i = 0; i < n; i++) {
            // max(h[i+1] ... h[j-1]) < min(h[i], h[j])
            if (rightG[i] != -1) jump[i].add(rightG[i]);
            if (leftG[i] != -1) jump[leftG[i]].add(i);

            // max(h[i], h[j]) < min(h[i+1] ... h[j])
            if (rightS[i] != -1) jump[i].add(rightS[i]);
            if (leftS[i] != -1) jump[leftS[i]].add(i);
        }
        int[] dp = new int[n]; Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int u = 0; u < n; u++) {
            for (int v: jump[u]) {
                dp[v] = Math.min(dp[v], dp[u] + 1);
            }
        }
        return dp[n-1];
    }
}
",0,Non-plagiarised
63a24497,6e5ab1d2,"import java.util.*;
import java.lang.*;
import java.io.*;


public class Main {
    void solve() {
        int n = in.nextInt();
        char[] a = in.nextLine().toCharArray();
        char[] b = in.nextLine().toCharArray();

        int ans = MAX;
        ans = Math.min(ans, operations(a, b));
        ans = Math.min(ans, change(a, b, '1'));
        ans = Math.min(ans, change(a, b, '0'));

        if (ans == MAX)ans = -1;
        out.append(ans + ""\n"");
    }

    int operations(char[] a, char[] b) {
        int count01 = 0 , count10 = 0;
        int n = a.length;
        for (int i = 0 ; i < n; i++) {
            if (a[i] != b[i]) {
                if (a[i] == '0')count01++;
                else count10++;
            }
        }
        if (count01 != count10)return MAX;
        return count01 + count10;
    }

    int change(char[] a, char[] b , char ch) {
        int n = a.length;
        char[] c = new char[n];
        for (int i = 0 ; i < n; i++)c[i] = a[i];
        int index = -1;
        for (int i = 0; i < n; i++) {
            if (c[i] == '1' && b[i] == ch) {
                index = i;
                break;
            }
        }
        if (index == -1)return MAX;
        for (int i = 0 ; i < n; i++) {
            if (i == index)continue;
            c[i] = (char)( '0' + ('1' - c[i]) );
        }
        int  local = operations(c, b);
        if (local == MAX)return MAX;
        return 1 + local;
    }

    public static void main (String[] args) {
        // It happens - 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) {
        if (err == null)return;
        err.println(Arrays.toString(s));
    }

    <T> void println(T s) {
        if (err == null)return;
        err.println(s);
    }

    void println(int s) {
        if (err == null)return;
        err.println(s);
    }

    void println(int[] a) {
        if (err == null)return;
        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;
    }

    int max(int[] a) {
        int max = a[0];
        for (int i = 0; i < a.length; i++)max = Math.max(max, a[i]);
        return max;
    }

    int min(int[] a) {
        int min = a[0];
        for (int i = 0; i < a.length; i++)min = Math.min(min, a[i]);
        return min;
    }

    int count(int[] a, int x) {
        int count = 0;
        for (int i = 0; i < a.length; i++)if (x == a[i])count++;
        return count;
    }

    void printArray(int[] a) {
        for (int ele : a)out.append(ele + "" "");
        out.append(""\n"");
    }

    static {
        try {
            System.setIn(new FileInputStream(""input.txt""));
            System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
            err = new PrintStream(new FileOutputStream(""error.txt""));
        } catch (Exception e) {}
    }

    static FastReader in;
    static StringBuilder out;
    static PrintStream err;
    final int MAX;
    final int MIN;
    int mod ;
    Main() {
        in = new FastReader();
        out = new StringBuilder();
        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 Pair implements Comparable<Pair> {
        int first , second;
        Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }

        public int compareTo(Pair b) {
            return this.first - b.first;
        }

        public String toString() {
            String s = ""{ "" + Integer.toString(first) + "" , "" + Integer.toString(second) + "" }"";
            return s;
        }
    }
}
","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;

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);
        CMenorah solver = new CMenorah();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class CMenorah {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            char[] a = in.next().toCharArray();
            char[] b = in.next().toCharArray();

            int ans = checkPairs(a, b, -1);
            ans = Math.min(ans, changePair(a, b, '1'));
            ans = Math.min(ans, changePair(a, b, '0'));

            if (ans == Integer.MAX_VALUE) ans = -1;
            out.println(ans);
        }

        int changePair(char[] a, char[] b, char t) {
            int index = -1;
            int n = a.length;

            for (int i = 0; i < n; ++i) {
                if (a[i] == '1' && b[i] == t) {
                    index = i;
                    break;
                }
            }

            return checkPairs(a, b, index);
        }

        int checkPairs(char[] a, char[] b, int changeStringIndex) {
            int n = a.length;
            int val = 0;

            char[] tmp = new char[n];
            System.arraycopy(a, 0, tmp, 0, n);

            if (changeStringIndex != -1) {
                val = 1;

                for (int i = 0; i < n; ++i) {
                    if (i == changeStringIndex) continue;
                    tmp[i] = a[i] == '0' ? '1' : '0';
                }
            }

            int _10 = 0, _01 = 0;
            for (int i = 0; i < n; ++i) {
                if (tmp[i] != b[i]) {
                    if (tmp[i] == '0') _01++;
                    else _10++;
                }
            }

            return _01 == _10 ? 2 * _01 + val : Integer.MAX_VALUE;
        }

    }

    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);

        }

    }
}

",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
1ea771ea,2f8c3bf3,"
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 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();
		  
		}
	}
}
",0,Non-plagiarised
9291ca83,d61f51c5,"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.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; }
 */
",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
2915ac5b,9b8c6bd7,"import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
    // static Scanner sc=new Scanner(System.in);
//    static ArrayList<Integer> al; 
	static long min;
// 	static long[] dp;
    static FastReader sc=new FastReader(); 
	public static void main (String[] args) throws java.lang.Exception
	{
        PrintWriter w=new PrintWriter(System.out);
        int t=sc.nextInt();
        while(t-->0){
            // dp=new long[n+1][n+1][n];
        	int n=sc.nextInt();
        	long[] c=new long[n];
        	for(int i=0;i<n;i++) {
        		c[i]=sc.nextLong();
        	}
        	min=c[0]*n+c[1]*n;
        // 	f(n,c,n,n,0,0);
        long x=Long.MAX_VALUE-1,y=Long.MAX_VALUE-1,sumx=0,sumy=0,cx=0,cy=0,min1=Long.MAX_VALUE-1,min2=Long.MAX_VALUE-1;
            for(int i=0;i<n;i++) {
        		if(i%2==0){
        		    x=Math.min(x,c[i]);sumx+=c[i];cx=i/2+1;
        		    min1=sumx+x*(n-cx);
        		}
        		else {y=Math.min(y,c[i]);sumy+=c[i];cy=(i+1)/2;
        		    min2=sumy+y*(n-cy);
        		}
        		if(i>=1)min=Math.min(min,min1+min2);
        	}
        	System.out.println(min);
        }
		w.flush();
		w.close();
	}
// 	public static long f(int n, long[] c, int x, int y, int i, long cost) {
// 	    long l=Long.MAX_VALUE;
// 		if(i>=n || x>n || y>n)return 0;
// 		if(dp[x][y][i]!=-1)return dp[x][y][i];
// 		if(x==0 && y==0) {min=Math.min(cost, min);return;}
// 		if(x==0) {
// 			if(i%2!=0)min=Math.min(cost+c[i]*y, min);
// 			return;
// 		}
// 		if(y==0) {
// 			if(i%2==0)min=Math.min(cost+c[i]*x, min);
// 			return;
// 		}
// 		if(i%2==0) {
// 			for(int j=1;j<=x;j++) {
// 				l=Math.min(l,f(n,c,x-j,y,i+1,cost+j*c[i]));
// 			}
// 		}
// 		else {
// 			for(int j=1;j<=y;j++) {
// 				l=Math.min(l,f(n,c,x,y-j,i+1,cost+j*c[i]));
// 			}
// 		}
// 	}
}

class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return 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 final class Main{
	public static void main(String[] args) throws IOException{
//		Scanner sc=new Scanner(System.in);
		FastReader sc=new FastReader();
		PrintWriter writer=new PrintWriter(System.out);
		
		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.nextInt();   
	          long ans=c[0]*n+c[1]*n;
	          long x=Long.MAX_VALUE-1,y=Long.MAX_VALUE-1,sumx=0,sumy=0,cx=0,cy=0,min1=Long.MAX_VALUE-1,min2=Long.MAX_VALUE-1;
	          for(int i=0;i<n;i++) {
	          if(i%2==0){
	              x=Math.min(x,c[i]);
	              sumx+=c[i];
	              cx=i/2+1;
	              min1=sumx+x*(n-cx);
	          }
	          else {
	        	  y=Math.min(y,c[i]);
	        	  sumy+=c[i];cy=(i+1)/2;
	              min2=sumy+y*(n-cy);
	          }
	          if(i>=1) ans=Math.min(ans,min1+min2);
	         }
	          
	         System.out.println(ans);
		}
		writer.flush();
		writer.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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
489930000000,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,Plagiarised
0b5cff5a,4fb09c5f,"import java.io.*;
import java.text.DecimalFormat;
import java.util.*;

public class E {
    static long mod=(long)1e9+7;
    static long mod1=998244353;

    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();
            int k = in.nextInt();
            int[] a= in.readArray(k);
            int[] temp = in.readArray(k);
            int[] pre = new int[n];
            Arrays.fill(pre,Integer.MAX_VALUE);
            int[] suf = new int[n];
            Arrays.fill(suf,Integer.MAX_VALUE);
            for(int i = 0;i<k;i++){
                pre[a[i]-1]=temp[i];
                suf[a[i]-1]=temp[i];
            }
            int min = Integer.MAX_VALUE;
            E.ruffleSort(a);
            for(int i=a[0]-1;i<n;i++){
                min = Math.min(min,pre[i]);
                pre[i] = min;
                min++;

            }
            min = Integer.MAX_VALUE;
            for(int i = a[k-1]-1;i>=0;i--){
                min = Math.min(min,suf[i]);
                suf[i] = min;
                min++;
            }

            for(int i=0;i<n;i++)
                out.print(Math.min(pre[i],suf[i])+"" "");
            out.println();
        }
        out.close();
    }




    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;
        }
    }
}","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);
        }
    }
}
",0,Non-plagiarised
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,Plagiarised
8c591975,b6724dd9,"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, k;
        n = in.nextInt();
        k = in.nextInt();
        int[] a = new int[n];
        long[] t = new long[k];

        for (int i = 0; i < n; i++) {
            a[i] = -1;
        }
        for (int i = 0; i < k; i++) {
            a[in.nextInt() - 1] = i;
        }
        for (int i = 0; i < k; i++) {
            t[i] = in.nextLong();
        }

        long[] dp = new long[n];

        long now;
        now = 2000000000;
        for (int i = 0; i < n; i++) {
            now++;
            if (a[i] != -1) {
                now = Math.min(now, t[a[i]]);
            }

            dp[i] = now;
        }
        now = 2000000000;
        for (int i = n - 1; i >= 0; i--) {
            now++;
            if (a[i] != -1) {
                now = Math.min(now, t[a[i]]);
            }

            dp[i] = Math.min(dp[i], now);
        }
        for (int i = 0; i < n; i++) {
            out.printf(""%d "", dp[i]);
        }
        out.println();
    }

    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.*;
import java.util.*;

public class AirConditioners {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		// System.in and System.out are input and output streams, respectively.
		InputStream inputStream = System.in;

		InputReader in = new InputReader(inputStream);
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
		int t = in.nextInt();
		while (t-- != 0) {
			int n = in.nextInt();
			int k = in.nextInt();
			HashMap<Integer, Integer> hm = new HashMap<>();
			int[] ac = in.readArray(k);
			for (int idx = 0; idx < ac.length; idx++) {
				hm.put(ac[idx], in.nextInt());
			}
			Arrays.sort(ac);
			long[] lmin = new long[n];
			long val = (long) Integer.MAX_VALUE;
			int acdx = 0;
			for (int idx = 0; idx < lmin.length; idx++) {
				if (acdx < ac.length && ac[acdx] - 1 == idx) {
					val = (long) Math.min(val, hm.get(ac[acdx]));
					acdx++;
				}
				lmin[idx] = val;
				val++;
			}
			acdx = ac.length - 1;
			val = Integer.MAX_VALUE;
			for (int idx = lmin.length-1; idx >= 0; idx--) {
				if (acdx >= 0 && ac[acdx] - 1 == idx) {
					val = (long) Math.min(val, hm.get(ac[acdx]));
					acdx--;
				}
				lmin[idx] = Math.min(lmin[idx], val);
				val++;
			}
			for (long x : lmin) {
				out.write(x + "" "");
			}
			out.newLine();
		}
		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 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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
6b83b22e,c59194c7,"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.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer;
import java.util.*;
public class codeforcesB{
 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[]){
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int ar[]=new int[n];
      int sum=0;
      for(int i=0;i<n;i++){ar[i]=sc.nextInt();}
      if(n%2==0){
          for(int i=0;i<n;i++){
              if(i%2==0){sb.append(-1*ar[i+1]+"" "");}
              else{sb.append(ar[i-1]+"" "");}
            }
           
        }
      else{
          if(ar[1]+ar[0]!=0){
          sb.append(ar[2]+"" ""+ar[2]+"" ""+-1*(ar[1]+ar[0])+"" "");}
          else{
              if(ar[2]+ar[1]!=0){
                  sb.append(-1*(ar[2]+ar[1])+"" ""+ar[0]+"" ""+ar[0]+"" "");
              }
              else{
                  sb.append(ar[1]+"" ""+-1*(ar[2]+ar[0])+"" ""+ar[1]+"" "");
              }
          }
          for(int i=3;i<n;i++){
              if(i%2==1){sb.append(-1*ar[i+1]+"" "");}
              else{sb.append(ar[i-1]+"" "");}
            }
        }
      sb.append(""\n"");
    }
    System.out.print(sb.toString());
   }
}",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
35bb6075,ed728769,"/*
    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.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 dp[][];
  static long f(int n , int m)
  {
      if(m == 0)
      return 1;
      
      if(dp[n][m] != -1)
      return dp[n][m];
      
      if(n < 9)
      dp[n][m] = f(n+1,m-1);
      
      else
      dp[n][m] = f(0,m-1)+f(1,m-1);
      
      dp[n][m] %= 1000000007;
      
      return dp[n][m];
  }
  
 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);
}
    public static void main(String []args) throws IOException
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
       // sc.nextLine();
        while(t-- > 0)
        {
            int n = sc.nextInt();
            sc.nextLine();
            //String s = sc.nextLine();
            int arr[][] = new int[26][n];
            for(int i = 0 ; i < n ; i++)
            {
                String s = sc.nextLine();
                
                for(int j = 0 ; j < 26 ; j++)
                {
                    int cnt = 0;
                    for(int k = 0 ; k < s.length() ; k++)
                    {
                        if(s.charAt(k)-'a' == j)
                        cnt++;
                    }
                    arr[j][i] = 2*cnt-s.length();
                }
            }
            
            int ans = 0;
            for(int i = 0 ; i < 26 ; i++)
            {
             Arrays.sort(arr[i]);   
             int tot = 0;
             for(int j = n-1 ; j >= 0 ;j--)
             {
                 tot += arr[i][j];
                 if(tot <= 0)
                 break;
                 
                 ans = Math.max(ans,n-j);
             }
            }
            System.out.println(ans);
        }
    }
}",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
5af25bd7,77ec956f,"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.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]));
        }
    }
}
",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
1adac634,ee0bc145,"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.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        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();
            Stack<Pair> stk = new Stack<>();
            stk.push(new Pair(0, 0));

            for (int i = 0; i < n; ++i) {
                int cur_pos = k[i];
                int cur_inc = h[i];
                while (!stk.isEmpty() && !(cur_pos - cur_inc + 1 > stk.peek().pos)) {
                    cur_inc = Math.max(cur_inc, stk.peek().inc + cur_pos - stk.peek().pos);
                    stk.pop();
                }
                stk.add(new Pair(cur_pos, cur_inc));
            }
            long answer = 0;
            while (!stk.isEmpty()) {
                answer += (1L * stk.peek().inc * (stk.peek().inc + 1) / 2);
                stk.pop();
            }
            out.println(answer);
        }
        out.flush();
    }

    static class Pair {
        int pos, inc;
        public Pair (int pos, int inc) {
            this.pos = pos;
            this.inc = inc;
        }
    }


    static class Scanner {
        BufferedReader in;
        StringTokenizer st;

        public Scanner() {
            this.in = new BufferedReader(new InputStreamReader(System.in));
        }

        public Scanner(FileReader f) {
            this.in = new BufferedReader(f);
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            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 void close() throws IOException {
            in.close();
        }
    }
}
",0,Non-plagiarised
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,Plagiarised
4552d8a0,ec4c7e8e,"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 D_Blue_Red_Permutation{
    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 array[]= new long[n];
        for(int i=0;i<n;i++){
            array[i]=s.nextLong();
        }
        String str=s.nextToken();
        ArrayList<Long> red = new  ArrayList<Long>();
        ArrayList<Long> blue = new  ArrayList<Long>();
        for(int i=0;i<n;i++){
            if(str.charAt(i)=='R'){
                red.add(array[i]);
            }
            else{
                blue.add(array[i]);
            }
        }
        Collections.sort(blue);
        int check1=0;
        for(int i=0;i<blue.size();i++){
            int yo=i+1;
            if(blue.get(i)<yo){
                check1=1;
                break;
            }
        }
        Collections.sort(red,Collections.reverseOrder());
        int number=n;
        int check2=0;
        for(int i=0;i<red.size();i++){
             if(red.get(i)>number){
                 check2=1;
                 break;
             }
             number--;
        }
        if(check1==0 && check2==0){
            res.append(""YES\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.*;
public class the_child_and_set
{
	public static void main(String args[])
	{
		Scanner in=new Scanner(System.in);
		int t=in.nextInt();
		in.nextLine();
		while(t--!=0)
		{
			int n=in.nextInt();
			int arr[]=new int[n];
			for(int i=0;i<n;i++)
			{
				arr[i]=in.nextInt();
			}
			in.nextLine();
			String s=in.nextLine();
			int rc=0;
			int bc=0;
			for(int i=0;i<n;i++)
			{
				if(s.charAt(i)=='B')
					bc++;
				else
					rc++;
			}
			int r[]=new int[rc];
			int b[]=new int[bc];
			int bi=0;
			int ri=0;
			for(int i=0;i<n;i++)
			{
				if(s.charAt(i)=='B')
				{
					b[bi]=arr[i];
					bi++;
				}
				else
				{
					r[ri]=arr[i];
					ri++;
				}
			}
			Arrays.sort(b);
			Arrays.sort(r);
			boolean flag=true;
			for(int i=0;i<bi;i++)
			{
				if(b[i]<(i+1))
				{
					flag=false;
					break;
				}
			}
			if(flag)
			{
				for(int i=0;i<ri;i++)
				{
					if(r[i]>bi+(i+1))
					{
						flag=false;
						break;
					}
				}
			}
			if(flag)
				System.out.println(""YES"");
			else
				System.out.println(""NO"");
		}
	}
}",0,Non-plagiarised
0c0af0ff,d6a8d884,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("""");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }
    
    long mod=1000000007;
    
    void solve() throws IOException {
        for (int tc=ni();tc>0;tc--) {
            int n=ni();
            int[]A=new int[n];
            long[]T=new long[n];
            A[0]=ni();
            T[0]=A[0];
            long total=0;
            for (int i=1;i<n;i++) { A[i]=ni(); T[i]=T[i-1]+A[i]; } 
            
            long[]B=new long[n];
            long lefteven=n-1;
            long leftodd=n;
            int mineven=A[0];
            int minodd=A[1];
            long ans=Long.MAX_VALUE;
            
            for (int i=1;i<n;i++) {
                if (i%2==1) {
                    leftodd--;
                    minodd=Math.min(minodd,A[i]);
                    B[i]=T[i]+lefteven*mineven+leftodd*minodd;
                }
                else {
                    lefteven--;
                    mineven=Math.min(mineven,A[i]);
                    B[i]=T[i]+lefteven*mineven+leftodd*minodd;
                }
                ans=Math.min(ans,B[i]);
            }
            
            out.println(ans);
        }
        out.flush();
    }
    
    int gcd(int a,int b) { return(b==0?a:gcd(b,a%b)); }
    long gcd(long a,long b) { return(b==0?a:gcd(b,a%b)); }
    long mp(long a,long p) { long r=1; while(p>0) { if ((p&1)==1) r=(r*a)%mod; p>>=1; a=(a*a)%mod; } return r; }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}","//Praise our lord and saviour qlf9
//DecimalFormat f = new DecimalFormat(""##.00"");

import java.util.*;
import java.io.*;
import java.math.*;
import java.text.*;
public class C{
public static void main(String[] omkar) throws Exception
{
   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
   StringTokenizer st = new StringTokenizer(in.readLine());
   StringBuilder sb = new StringBuilder();
   int cases = Integer.parseInt(st.nextToken());
   for(int i = 0; i < cases; i++)
   {
      solve(in, st, sb);
   }  
   System.out.println(sb);
        }
 public static void solve(BufferedReader in, StringTokenizer st, StringBuilder sb) throws Exception
 {
      st = new StringTokenizer(in.readLine());
      int n = Integer.parseInt(st.nextToken());
      int[] arr = readArr(n, in, st);
      int[] mins = new int[n];
      mins[0] = arr[0];
      mins[1] = arr[1]; 
      for(int i = 2; i < n; i++)
      {
         mins[i] = Math.min(arr[i], mins[i-2]);
      }
      long[] sums = new long[n];
      sums[0] = (long)(arr[0]);
      for(int i = 1; i < n; i++)
      {
         sums[i] = sums[i-1]+(long)(arr[i]);
      }
      long minc = Long.MAX_VALUE;
      long temp;
      for(int i = 1; i < n; i++)
      {
         temp = sums[i];
         temp += (long)(mins[i])*(long)(n-(i+2)/2);
         temp += (long)(mins[i-1])*(long)(n-(i+1)/2);
         minc = Math.min(minc, temp);
      }
      sb.append(minc+""\n"");
 }
 public static int[] readArr(int N, BufferedReader in, StringTokenizer st) throws Exception
      {
         int[] arr = new int[N];
         st = new StringTokenizer(in.readLine());
         for(int i=0; i < N; i++)
            arr[i] = Integer.parseInt(st.nextToken());
         return arr;
      }


}",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
701c3f35,d56bcb0c,"import java.util.*;
import java.io.*;

public class Menorah {

	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) {
			int n=Integer.parseInt(f.readLine());
			String s=f.readLine();
			String s2=f.readLine();
			int[] arr=new int[4];
			//0 00 1 01 2 10 3 11
			for(int i=0;i<n;i++) {
				if(s.charAt(i)=='0') {
					if(s2.charAt(i)=='0') {
						arr[0]++;
					}
					else {
						arr[1]++;
					}
				}
				else {
					if(s2.charAt(i)=='0') {
						arr[2]++;
					}
					else {
						arr[3]++;
					}
				}
			}
			int min=Integer.MAX_VALUE;
			if(arr[1]==arr[2]) {
				min=arr[1]*2;
			}
			int temp=arr[1];
			arr[1]=arr[3];
			arr[3]=temp;
			temp=arr[0];
			arr[0]=arr[2];
			arr[2]=temp;
			arr[3]++;
			arr[1]--;
			if(arr[1]==arr[2]) {
				min=Math.min(min, arr[1]*2+1);
			}
			System.out.println(min!=Integer.MAX_VALUE?min:-1);
		}
	}

}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
    static int func(char a[],char b[]){
        int n=a.length;
        int a1=0,b1=0;
        for(int i=0;i<n;i++){
            if(a[i]=='1')a1++;
            if(b[i]=='1')b1++;
        }
        if(a1!=b1)return 100000000;
        int cnt=0;
        for(int i=0;i<n;i++){
            if(a[i]=='1'&&b[i]!='1')cnt++;
        }
        return cnt*2;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    //int t=1;
	   int t=Integer.parseInt(br.readLine());
	    while(--t>=0){
	           int n=Integer.parseInt(br.readLine());
	           char a[]=br.readLine().toCharArray();
	          char b[]=br.readLine().toCharArray();
	         int x=func(a,b);
	         int ind=-1;
	         for(int i=0;i<n;i++){
	             if(a[i]==b[i]&&a[i]=='1'){
	                 ind=i;
	                 break;
	             }
	         }
	         int y=100000000;
	         if(ind>=0){
	             for(int i=0;i<n;i++){
	                 if(i==ind)continue;
	                 if(a[i]=='1')a[i]='0';
	                 else a[i]='1';
	             }
	             y=func(a,b)+1;
	         }
	         if(x>=1000000&&y>=1000000){
	             System.out.println(-1);
	         }
	         else
	        System.out.println(Math.min(x,y));
	     
	        
	    }
	    
	}
}
",0,Non-plagiarised
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,Plagiarised
0d11fb94,8c79c384,"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);
        }
    }


}","/*
    JAI MATA DI
 */

import java.util.*;

import javax.print.attribute.HashAttributeSet;


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 class Pair implements Comparable<Pair>{
	 		int ind;
	 		int val;
	 		Pair(int key , int value){
	 			this.ind = key;
	 			this.val = value;
	 		}
			@Override
			public int compareTo(Pair o) {
				return this.val - o.val;
			}
//			@Override
//			public int hashCode(){
//				return first + second;
//			}
	 	}
	 	
	 
	 

/* ***************************************************************************************************************************************************/	 
	 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();
			int[] arr = new int[n];
			for(int i = 0 ; i< n ;i++) {
				arr[i] = sc.nextInt();
			}
			
			ArrayList<Integer> ao = new ArrayList<Integer>();
			ArrayList<Integer> az = new ArrayList<Integer>();
			for(int i = 0 ; i< n ;i++) {
				if(arr[i] == 1) ao.add(i);
				else az.add(i);
			}
			long[][] dp = new long[n+1][n+1];
			for(int i = 0 ; i<n ; i++) Arrays.fill(dp[i], -1);
			
			sb.append(fnc(dp, ao, az, 0, 0));
			
		}
		static long fnc(long[][] dp ,ArrayList<Integer> ao , ArrayList<Integer> az ,int i , int j) {
			if(i == ao.size()) return 0;
			if(j == az.size()) return Long.parseLong(""1000000000000"");
			if(dp[i][j] != -1) return dp[i][j];
			long a = Math.abs(ao.get(i) - az.get(j)) + fnc(dp, ao, az, i+1, j+1);
			long b = fnc(dp, ao, az, i, j+1);
			dp[i][j] = Math.min(a, b);
			return dp[i][j];
			
		}
		
}",0,Non-plagiarised
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,Non-plagiarised
132281000000000,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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
4.4428E+067,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,Non-plagiarised
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,Non-plagiarised
317a209c,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,Plagiarised
ec607ca1,ed37ba7d,"		/*
		TO LEARN
		1-segment trees
		2-euler tour
		3-fenwick tree and interval tree
		*/
		/*
		TO SOLVE 
		uva 1103
		program codeforces edu 102 D
		*/
		/*
		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.concurrent.ThreadLocalRandom;
				    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 boolean vis[]=new boolean[26];
	 static LinkedList<Integer>edges[];
	 static int cnt=0;
	 static ArrayList<Integer>arr=new ArrayList();
	 static void dfs(int c,boolean vis2[])
	 {
	 	vis[c]=true;
	 //	vis2[c]=true;
	 	arr.add(c);
	 	for(int v:edges[c])
	 	{
	 		

	 		if(!vis[v])
	 		{
	 			
	 			dfs(v,vis2);
	 		}
	 	}
	 }

			public static void main(String[] args)  throws Exception 
		      {
			
				//	scan=new FastScanner(""lifeguards.in"");
				//out = new PrintWriter(""lifeguards.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 
				 */


				    int tt=1;
				 
		

				     


	//System.out.println(2&0);
	/*for(int i=0;i<=70;i++)
		for(int j=0;j<=70;j++){
			if((i&j)==i)
			System.out.println(i+"" ""+j+"" ""+(i&j));
		}*/
		//System.out.println(1^14);
		//System.out.println(15&6);

	tt=scan.nextInt();
			 	    
			 outer:while(tt-->0)
				    {
				    	int l=scan.nextInt(),n=scan.nextInt();
				    	int arr[]=new int[n];
				    	long t[]=new long[n];
				    	int pos[]=new int[l+1];
				    	Arrays.fill(pos,-1);
				    	TreeSet<Integer>tree=new TreeSet<Integer>();
				    	for(int i=0;i<n;i++){
				    		arr[i]=scan.nextInt();
				    		tree.add(arr[i]);
				    		pos[arr[i]]=i;
				    	}
				    	
				    		for(int i=0;i<n;i++)
				    		t[i]=scan.nextLong();
				    	long L[]=new long[l+5];
				    	long R[]=new long[l+5];
				    	Arrays.fill(L,Integer.MAX_VALUE);
				    	Arrays.fill(R,Integer.MAX_VALUE);
				    	for(int i=1;i<=l;i++)
				    	{
				    		if(pos[i]!=-1)
				    		{
				    			L[i]=t[pos[i]];
				    		}
				    		L[i]=Math.min(L[i],L[i-1]+1);
				    	}
				    		for(int i=l;i>=1;i--)
				    	{
				    		if(pos[i]!=-1)
				    		{
				    			R[i]=t[pos[i]];
				    		}
				    		R[i]=Math.min(R[i],R[i+1]+1);
				    	}
				    	for(int i=1;i<=l;i++)
				    		out.print(Math.min(L[i],R[i])+"" "");

out.println();
				    
				    
		           

		            }

				  	    out.close();
		 		  
				   
				}
				static class special{
					long x1,y1,x2,y2;
					//int id;
					special(long x1,long y1,long x2,long y2)
					{
						this.x1=x1;
						this.y1=y1;
						this.x2=x2;
						this.y2=y2;
						//this.id=id;
					}
					@Override
					    public int hashCode() {
				                int hash = 7;
	    hash = 31 * hash + (int) x1;
	    hash = 31 * hash + (int)x2;
	    hash = 31 * hash + (int)y1;
	    hash = 31 * hash + (int)y2;
	    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.x1 == x1 && t.y1 == y1&&t.x2==x2&&t.y2==y2;
				            }
				}

				   
				     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)(x-o.x);
				     
				        }
				     
				    }
				    
				    }

				     
","import java.io.*;
import java.util.*;
import java.lang.*;

public class codeforces {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            long startTime = System.currentTimeMillis();
            try {
                sc = new InputReader(new FileInputStream(""input.txt""));
                out = new PrintWriter(new FileOutputStream(""output.txt""));
                pr = new PrintWriter(new FileOutputStream(""error.txt""));
            } catch (Exception ignored) {
            }
            int t = 1;
            int tt = t;
            t = sc.nextInt();
            while (t-- > 0) {
                solve();
            }
            long endTime = System.currentTimeMillis();
            System.out.println(""Time: "" + (endTime - startTime) / tt + "" ms"");
            out.flush();
            pr.flush();

        } else {
            sc = new InputReader(inputStream);
            out = new PrintWriter(outputStream);
            pr = new PrintWriter(outputStream);
            int t = 1;
            t = sc.nextInt();
            while (t-- > 0) {
                solve();
            }
            out.flush();
        }
    }

    public static void solve() {
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            dp[i] = inf;    
            ans[i] = inf;
        }
        m = sc.nextInt();
        for (int i = 0; i < m; i++)
            arr[i] = sc.nextInt() - 1;
        for (int i = 0; i < m; i++) {
            arr2[i] = sc.nextInt();
            dp[(int)arr[i]] = arr2[i];
        }
        temp = inf;
        for (int i = 0; i < n; i++) {
            temp = Math.min(temp, dp[i]);
            ans[i] = Math.min(ans[i], temp);
            temp++;
        }
        temp = inf;
        for (int i = (int)n - 1; i > -1; i--) {
            temp = Math.min(temp, dp[i]);
            ans[i] = Math.min(ans[i], temp);
            temp++;
        }
        for (int i = 0; i < n; i++)
            out.print(ans[i] + "" "");
        out.println("""");
    }
    /*
     * Set Iterator Iterator value = set.iterator(); Displaying the values after
     * iterating through the iterator
     * System.out.println(""The iterator values are: ""); while (value.hasNext()) {
     * System.out.println(value.next()); }
     */

    /*
     * Map Iterator: for (Map.Entry<Integer, Integer> entry : map.entrySet()){
     * System.out.println(""Key => "" + entry.getKey() + "", Value => "" +
     * entry.getValue());}
     */
    // Globals

    public static long n, m, temp;
    public static int template_array_size = (int) 1e6 + 16813;
    public static long[] arr = new long[template_array_size];
    public static long[] arr2 = new long[template_array_size];
    public static long[] dp = new long[template_array_size];
    public static long[] ans = new long[template_array_size];
    public static int inf = Integer.MAX_VALUE;
    public static int minf = Integer.MIN_VALUE;
    public static int mod = 1000000007;
    public static int ml = (int) 1e9;
    public static String s = """";
    public static InputReader sc;
    public static PrintWriter out;
    public static PrintWriter pr;

    // Pair

    static class Pair {
        int first, second;

        Pair(int x, int y) {
            this.first = x;
            this.second = y;
        }
    }

    // FastReader Class

    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());
        }
    }

    // Req Functions
    public static void fill(int[][] dp, int x) {
        for (int i = 0; i < dp.length; ++i) {
            for (int j = 0; j < dp[0].length; ++j) {
                dp[i][j] = x;
            }
        }
    }

    public static int gcd(int a, int b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    public static int lcm(int a, int b) {
        return (a / gcd(a, b)) * b;
    }

    public 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 / gcd(a, b)) * b;
    }

    public static long nCr(int n, int k) {
        long ans = 1L;
        k = k > n - k ? n - k : k;
        int j = 1;
        for (; j <= k; j++, n--) {
            if (n % j == 0) {
                ans *= n / j;
            } else if (ans % j == 0) {
                ans = ans / j * n;
            } else {
                ans = (ans * n) / j;
            }
        }
        return ans;
    }

    public static String reverseString(String input) {
        StringBuilder str = new StringBuilder("""");

        for (int i = input.length() - 1; i >= 0; i--) {
            str.append(input.charAt(i));
        }
        return str.toString();
    }

    public static int maxOf3(int x, int y, int z) {
        return Math.max(x, Math.max(y, z));
    }

    public static int minof3(int x, int y, int z) {
        return Math.min(x, Math.min(y, z));
    }

    public static long maxOf3(long x, long y, long z) {
        return Math.max(x, Math.max(y, z));
    }

    public static long minof3(long x, long y, long z) {
        return Math.min(x, Math.min(y, z));
    }

    public static void arrInput(int[] arr, int n) {
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextInt();
    }

    public static void arrInput(long[] arr, int n) {
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextLong();
    }

    public static void arrInput(Pair[] pair, int n) {
        for (int i = 0; i < n; i++)
            pair[i] = new Pair(sc.nextInt(), sc.nextInt());
    }

    public static int maxarrInput(int[] arr, int n) {
        int max = minf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
            max = Math.max(max, arr[i]);
        }
        return max;

    }

    public static long maxarrInput(long[] arr, int n) {
        long max = minf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
            max = Math.max(max, arr[i]);
        }
        return max;
    }

    public static int minarrInput(int[] arr, int n) {
        int min = inf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
            min = Math.max(min, arr[i]);
        }
        return min;
    }

    public static long minarrInput(long[] arr, int n) {
        long min = inf;
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
            min = Math.max(min, arr[i]);
        }
        return min;
    }

    public static int lowerBound(int[] arr, int x) {
        int l = -1, r = arr.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (arr[m] >= x)
                r = m;
            else
                l = m;
        }
        return r;
    }

    public static int upperBound(int[] arr, int x) {
        int l = -1, r = arr.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (arr[m] <= x)
                l = m;
            else
                r = m;
        }
        return l + 1;
    }

    public static void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int[n1];
        int R[] = new int[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++;
        }
    }

    public static void reversesort(int arr[], int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;
            reversesort(arr, l, m);
            reversesort(arr, m + 1, r);
            merge(arr, l, m, r);
        }
    }

    public 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++;
        }
    }

    public static void reversesort(long arr[], int l, int r) {
        if (l < r) {
            int m = l + (r - l) / 2;
            reversesort(arr, l, m);
            reversesort(arr, m + 1, r);
            merge(arr, l, m, r);
        }
    }

    // debug

    public static boolean sysFlag = System.getProperty(""ONLINE_JUDGE"") == null;

    public static void debug(int[][] dp) {
        if (sysFlag) {
            for (int i = 0; i < dp.length; ++i) {
                pr.print(i + ""--> "");
                for (int j = 0; j < dp[0].length; ++j) {
                    pr.print(dp[i][j] + "" "");
                }
                pr.println("""");
            }
        }
    }

    public static void debug(long[][] dp) {
        if (sysFlag) {
            for (int i = 0; i < dp.length; ++i) {
                pr.print(i + ""--> "");
                for (int j = 0; j < dp[0].length; ++j) {
                    pr.print(dp[i][j] + "" "");
                }
                pr.println("""");
            }
        }
    }

    public static void debug(int x) {
        if (sysFlag)
            pr.println(""Int-Ele: "" + x);
    }

    public static void debug(String x) {
        if (sysFlag)
            pr.println(""String: "" + x);
    }

    public static void debug(char x) {
        if (sysFlag)
            pr.println(""Char: "" + x);
    }

    public static void debug(long x) {
        if (sysFlag)
            pr.println(""Long-Ele: "" + x);
    }

    public static void debug(int[] arr, int n) {
        if (sysFlag) {
            for (int i = 0; i < n; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(char[] arr) {
        if (sysFlag) {
            for (int i = 0; i < arr.length; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(long[] arr, int n) {
        if (sysFlag) {
            for (int i = 0; i < n; ++i) {
                pr.println(i + "" -> "" + arr[i]);
            }
        }
    }

    public static void debug(ArrayList<Integer> list) {
        if (sysFlag) {
            for (int i = 0; i < list.size(); ++i) {
                pr.println(i + "" -> "" + list.get(i));
            }
        }
    }

    public static void Ldebug(ArrayList<Long> list) {
        if (sysFlag) {
            for (int i = 0; i < list.size(); ++i) {
                pr.println(i + "" -> "" + list.get(i));
            }
        }
    }

    public static void debugmapII(HashMap<Integer, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Integer, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapLI(HashMap<Long, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Long, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapLL(HashMap<Long, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Long, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapIL(HashMap<Integer, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Integer, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapSL(HashMap<String, Long> map) {
        if (sysFlag) {
            for (Map.Entry<String, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapCL(HashMap<Character, Long> map) {
        if (sysFlag) {
            for (Map.Entry<Character, Long> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapSI(HashMap<String, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<String, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debugmapCI(HashMap<Character, Integer> map) {
        if (sysFlag) {
            for (Map.Entry<Character, Integer> entry : map.entrySet())
                pr.println(""Key => "" + entry.getKey() + "", Value => "" + entry.getValue());
        }
    }

    public static void debug(Set<Integer> set) {
        if (sysFlag) {
            Iterator value = set.iterator();
            int i = 1;
            while (value.hasNext()) {
                pr.println((i++) + ""-> "" + value.next());
            }
        }
    }
}
",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
1ea771ea,3c667d4f,"
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 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,Non-plagiarised
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,Non-plagiarised
9028caf7,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,Non-plagiarised
2470b521,f6ca6fc8,"// 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.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()]);
	}
}
",0,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
b7de5c19,c022c315,"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 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();
			int[][] a = new int[n - 1][2];
			ArrayList<ArrayList<Data>> g = new ArrayList<>();
			for (int i = 0; i < n - 1; i++) {
				g.add(new ArrayList<>());
				a[i][0] = in.nextInt() - 1;
				a[i][1] = in.nextInt() - 1;
			}
			g.add(new ArrayList<>());
			for (int i = 0; i < n - 1; i++) {
				g.get(a[i][0]).add(new Data(a[i][1], i));
				g.get(a[i][1]).add(new Data(a[i][0], i));
			}
			if (!check(g)) {
				System.out.println(-1);
				continue;
			}
			int[] ans = new int[n - 1];

			ans[0] = 2;
			for(int node: a[0]) {
				for(Data d: g.get(node)) {
					solve(g, d.a, d.ind, false, ans);
				}
			}

			for (int i : ans)
				System.out.print(i + "" "");
			System.out.println();
		}

		out.flush();
	}

	private static void solve(ArrayList<ArrayList<Data>> g, int node, int edge, boolean b, int[] ans) {
		if (ans[edge] != 0)
			return;

		ans[edge] = b ? 2 : 3;
		for (Data d : g.get(node)) {
			solve(g, d.a, d.ind, !b, ans);
		}

	}

	private static boolean check(ArrayList<ArrayList<Data>> g) {
		for (ArrayList<Data> a : g)
			if (a.size() > 2)
				return false;
		return true;
	}

	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 a;
	int ind;

	Data(int val, int ind) {
		this.a = Math.abs(val);
		this.ind = ind;
	}
}

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.a - o2.a);
	}

}

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;
	}

}",0,Non-plagiarised
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,Plagiarised
29d865c3,5cfa2861,"import java.io.*;
import java.util.*;

public class C {
    public static void main(String[] args) {
        while (N-- > 0) {
            solve();
        }
        out.close();
    }

    public static void solve() {
        int M = sc.nextInt();
        String a = sc.nextLine();
        String b = sc.nextLine();
        int d = 0;
        int al = 0;
        int bl = 0;
        for (int i = 0; i < M; i++) {
            if (a.charAt(i) != b.charAt(i)) {
                d++;
            }
            if (a.charAt(i) == '1') {
                al++;
            }
            if (b.charAt(i) == '1') {
                bl++;
            }
        }

        if ((al == bl && d % 2 == 0) || (M - al + 1 == bl && (M - d) % 2 == 1)) {
            if ((al == bl && d % 2 == 0) && (M - al + 1 == bl && (M - d) % 2 == 1)) {
                out.println(Math.min(d, M - d));
            } else if (al == bl && d % 2 == 0) {
                out.println(d);
            } else {
                out.println(M - d);
            }
        } else {
            out.println(-1);
            return;
        }
    }

    private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    private static MyScanner sc = new MyScanner();

    private static int N = sc.nextInt();

    @SuppressWarnings(""unused"")
    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());
        }

        int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

        String nextLine() {
            String str = """";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}","/**
 * check out my youtube channel sh0rkyboy
 * https://tinyurl.com/zdxe2y4z
 * I do screencasts, solutions, and other fun stuff in the future
 */

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();
 			char[] a = sc.next().toCharArray();
 			char[] b = sc.next().toCharArray();
 			int counta = 0;
 			int countb = 0;
 			for (char j : a) {
 				if (j == '1')
 					counta++;
 			}
 			for (char j : b) {
 				if (j == '1')
 					countb++;
 			}
 			long ans = 0;
 			if (counta == countb && n-counta+1 == countb){
 				for (int j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 				long tempans = 0;
 				int j=0;
 				for(j = 0;j<n;j++){
 					if (a[j] == '1' && b[j] == '1')
 						break;
 				}
 				for(int i = 0;i<n;i++){
 					if (i == j)
 						continue;
 					if (a[i] == '1')
 						a[i] = '0';
 					else
 						a[i] = '1';
 				}
 				tempans += 1;
 				for (j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						tempans += 2;
 					}
 				}
 				ans = min(ans, tempans);
 			} else if (counta == countb) {
 				for (int j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 			} else if (n-counta+1 == countb) {
 				int j=0;
 				for(j = 0;j<n;j++){
 					if (a[j] == '1' && b[j] == '1')
 						break;
 				}
 				for(int i = 0;i<n;i++){
 					if (i == j)
 						continue;
 					if (a[i] == '1')
 						a[i] = '0';
 					else
 						a[i] = '1';
 				}
 				ans += 1;
 				for (j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 			} else {
 				ans = -1;
 			}
 			out.println(ans);
  		}
 		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;
	}
	public static int power(long x, long y, long mod){
		long ans = 1;
		while(y>0){
			if (y%2==1)
				ans = (ans*x)%mod;
			x = (x*x)%mod;
			y/=2;
		}
		return (int)(ans);
	}
	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",0,Non-plagiarised
6f02c6d9,c2242c42,"
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;
        }
    }

}
","// package codechef;

import java.io.*;
import java.util.*;



     

public class cp_2 {
	static int mod=998244353;
	
//	static  Reader sc=new Reader();
	static FastReader sc=new FastReader(System.in);
	static int[] sp;
	static int size=(int)1e6;
	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)1e5);
			while(tc-->0)
			{
				int n=sc.nextInt();
				int arr[]=new int[n];
				for (int i = 0; i < arr.length; i++) {
					arr[i]=sc.nextInt();
				}
				
				String s=sc.next();
				ArrayList<Integer> blue=new ArrayList<>();
				ArrayList<Integer> red=new ArrayList<>();
				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,Collections.reverseOrder());
				boolean flag=true;
				for(int i=0;i<blue.size();i++)
				{
					if(blue.get(i)<i+1)
						flag=false;
				}
				
				for(int i=0;i<red.size();i++)
				{
					if(red.get(i)>n-i)
						flag=false;
				}
				
				printYesNo(flag);
				
			}
				
				
			
			
			out.flush();
			out.close();
			System.gc();
	
	}
	
	
	


	/*
	   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
 */

	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 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<Integer,Integer> findFactors(int n)
	{
		HashMap<Integer,Integer> ans=new HashMap<>();
		if(n%2==0)
		{
			ans.put(2, 0);
			while((n&1)==0)
			{
				n=n>>1;
				ans.put(2, ans.get(2)+1);
			}
				
		}
		for(int i=3;i*i<=n;i+=2)
		{
			if(n%i==0)
			{
				ans.put(i, 0);
				while(n%i==0)
				{
					n=n/i;
					ans.put(i, ans.get(i)+1);
				}
			}
		}
		if(n!=1)
			ans.put(n, ans.getOrDefault(n, 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();
		   }
	}

	
	
	
	
	
	//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])
	            {
	            	cnt=cnt*2;
	            	DFS(g, visited, v);
	            
	            }
	            
	        }
	       

	  } 
	
	
	  
	 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) {
			// 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 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,Plagiarised
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,Non-plagiarised
624b8db5,eacc407e,"//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.*;
import java.util.*;

public class A {
	static ArrayList<int[]>[] adj;
	static int[] vals = { 2, 11 };
	static int[] res;

	static void dfs(int u, int p, int par) {

		for (int[] nxt : adj[u]) {
			int v = nxt[0];
			int idx = nxt[1];
			if (v != p) {
				res[idx] = vals[par];
				dfs(v, u, 1 ^ par);
			}
		}

	}

	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();
			res = new int[n - 1];
			adj = new ArrayList[n];
			for (int i = 0; i < n; i++) {
				adj[i] = new ArrayList<int[]>();
			}
			for (int i = 0; i < n - 1; i++) {
				int u = sc.nextInt() - 1;
				int v = sc.nextInt() - 1;
				adj[u].add(new int[] { v, i });
				adj[v].add(new int[] { u, i });
			}

			boolean valid = true;
			int start = 0;
			for (int i = 0; i < n; i++) {
				if (adj[i].size() == 1)
					start = i;
				valid &= adj[i].size() <= 2;
			}

			dfs(start, -1, 0);
			if (valid) {
				for (int x : res)
					pw.print(x + "" "");
			} else {
				pw.print(-1);
			}
			pw.println();
		}
		pw.flush();
	}

	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,Non-plagiarised
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,Non-plagiarised
2bd5c798,317baeaf,"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 A {

	public static void process() throws IOException {

		int n = sc.nextInt();
		String s = sc.next(),t = sc.next();
		int zs = 0, zt = 0;
		for(int i = 0; i<n; i++) {
			if(s.charAt(i) == '0')zs++;
			if(t.charAt(i) == '0')zt++;
		}
		
		int ans = n+1;
		if(zs == zt) {
			int min = 0;
			for(int i = 0; i<n; i++)if(s.charAt(i) != t.charAt(i))min++;
			ans = min(ans, min);
		}
		if(n-zs-1 == zt) {
			int min = 0;
			for(int i = 0; i<n; i++)if(s.charAt(i) == t.charAt(i))min++;
			ans = min(ans, min);
		}
		if(ans == n+1)ans = -1;
		System.out.println(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 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> {
		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 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 java.util.*;
import java.io.*;

public class Main {
  public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		StringTokenizer st;

		int t = Integer.parseInt(br.readLine());
		while (t --> 0) {
			int n = Integer.parseInt(br.readLine());
			String a = br.readLine();
			String b = br.readLine();
			int alit = 0;
			int blit = 0;

			int ans = Integer.MAX_VALUE;

			for (int i = 0; i < n; i++) {
				if (a.charAt(i) == '1') alit++;
				if (b.charAt(i) == '1') blit++;
			}

			if (alit == blit) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) != b.charAt(i)) count++;
				ans = Math.min(count, ans);
			}
			
			if (alit == n - blit + 1) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) == b.charAt(i)) count++;
				ans = Math.min(ans, count);
			}

			if (ans == Integer.MAX_VALUE) {
				pw.println(""-1"");
			} else {
				pw.println(ans);
			}
		}

		pw.close();
  }
}",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
29cb9b0e,c77654b8,"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.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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
3412b353,528a6162,"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());
            int k[]=new int[n+1],h[]=new int[n+1],i;
            String s[]=bu.readLine().split("" "");
            for(i=1;i<=n;i++) k[i]=Integer.parseInt(s[i-1]);
            s=bu.readLine().split("" "");
            for(i=1;i<=n;i++) h[i]=Integer.parseInt(s[i-1]);

            long max[]=new long[n+1];
            for(i=1;i<=n;i++)
            {
                int j;
                long here=h[i];
                for(j=i-1;j>=0;j--)
                {
                    long diff=here-(k[i]-k[j]);
                    if(diff<=0) {max[i]=max[j]+here*(here+1)/2; break;}
                    if(diff<h[j]) here+=h[j]-diff;
                }
            }
            sb.append(max[n]+""\n"");
        }
        System.out.print(sb);
    }
}","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());
            int k[]=new int[n+1],h[]=new int[n+1],i;
            String s[]=bu.readLine().split("" "");
            for(i=1;i<=n;i++) k[i]=Integer.parseInt(s[i-1]);
            s=bu.readLine().split("" "");
            for(i=1;i<=n;i++) h[i]=Integer.parseInt(s[i-1]);

            long max[]=new long[n+1];
            for(i=1;i<=n;i++)
            {
                int j;
                long here=h[i];
                for(j=i-1;j>=0;j--)
                {
                    long diff=here-(k[i]-k[j]);
                    if(diff<=0) {max[i]=max[j]+here*(here+1)/2; break;}
                    if(diff<h[j]) here+=h[j]-diff;
                }
            }
            sb.append(max[n]+""\n"");
        }
        System.out.print(sb);
    }
}",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
baa8e497,cc9230d3,"import java.util.*;
import java.io.*;

public class Solution {
    public static void main(String str[]) throws IOException{
        Reader sc = new Reader();
        int t = sc.nextInt();
        while(t-->0) {
            int n = sc.nextInt();
            ArrayList<Tree> tt = new ArrayList<>();
            for(int i=0;i<n;i++){
                Tree temp = new Tree(sc.nextInt(), sc.nextInt(), i);
                tt.add(temp);
            }
            for(int i=0;i<n-1;i++){
                int x = sc.nextInt()-1;
                int y = sc.nextInt()-1;
                tt.get(x).al.add(tt.get(y));
                tt.get(y).al.add(tt.get(x));
            }
            Pair p = traversal(tt.get(0), null);
            System.out.println(Math.max(p.av, p.bv));
        }
    }
    static Pair traversal(Tree node, Tree Parent){
        if(node.al.size()==1 && Parent!=null){
            Pair p = new Pair(0,0);
            return p;
        }
        long lt = 0;
        long rt = 0;
        for(Tree t: node.al){
            if(t!=Parent){
                Pair p = traversal(t, node);
                long ll = Math.abs(node.l- t.l) + p.av;
                ll = Math.max(ll, Math.abs(node.l-t.r)+p.bv);
                long rr = Math.abs(node.r- t.l) + p.av;
                rr = Math.max(rr, Math.abs(node.r-t.r)+p.bv);
                lt+=ll;
                rt+=rr;
            }
        }
        Pair p = new Pair(lt, rt);
        return p;
    }
    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();
        }
    }

}
class Pair{
    long av;
    long bv;
    Pair(long av, long bv){
        this.av = av;
        this.bv = bv;
    }

}
class Tree{
    int l;
    int r;
    int i;
    ArrayList<Tree> al = new ArrayList<>();
    Tree(int l, int r, int i){
        this.l = l;
        this.r = r;
        this.i = i;
    }

}


","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;
        }
    }
}
",0,Non-plagiarised
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,Non-plagiarised
25151980,3b5cec19,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class C {
	
	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		for (int tt=1; tt<=T; tt++) {
			int n=fs.nextInt();
			int m=fs.nextInt();
			int x=fs.nextInt();
			int arr[]=fs.readArray(n);
			if(m>n) {
				System.out.println(""NO"");
				continue;
			}
			int copy[]=new int [n];
			for(int i=0;i<n;i++) {
				copy[i]=arr[i];
			}
			Arrays.sort(copy);
			ArrayList<Integer> container[]= new ArrayList[x+1];
			for(int i=1;i<=x;i++) {
				container[i]=new ArrayList<Integer>();
			}
			for(int i=0;i<m;i++) {
				for(int j=i;j<n;j+=m) {
					container[copy[j]].add(i+1);
				}
			}
			int counter[]=new int [n];
			for(int i=0;i<n;i++) {
				counter[i]=container[arr[i]].get(0);
				container[arr[i]].remove(0);
			}
			System.out.println(""YES"");
			for(int i=0;i<n;i++) {
				System.out.print(counter[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();
		}
		String nextLine() {
			String str = """";
			try {
				str = br.readLine();
			}
			catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
		
		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;
		}
		
		int[][] readArray(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;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	
}","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;
            }
        }
}

",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
8f6421f3,bdfe8110,"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;}
    }
}


  
","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());
		}
	}

	
}

",1,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
7de69858,b76bce8a,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.*;
import java.util.*;
 
public class 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;
		}
	}
 
 
	public static void main(String args[]) {
		if (System.getProperty(""ONLINE_JUDGE"") == null) {
  			// Input is a file
  			try {
				System.setIn(new FileInputStream(""input.txt""));
				System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
			} catch (Exception e) {
				System.err.println(""Error"");
			}
		} else {
  			// Input is System.in
		}

		FastReader sc = new FastReader();
		// Scanner sc = new Scanner(System.in);
		//System.out.println(java.time.LocalTime.now());

		StringBuilder sb = new StringBuilder();
		int t = sc.nextInt();
		while(t>0) {
			
			int n = sc.nextInt(); 
			long[] arr = new long[n];
			long[] pow = new long[n];
			for(int i = 0; i<n; i++)arr[i] = sc.nextLong();
			for(int i = 0; i<n ;i++)pow[i] = sc.nextLong();

			Pair[] p= new Pair[n];

			for(int i = 0; i<n; i++){
				Pair pp = new Pair(arr[i]-pow[i], arr[i]);
				p[i] = pp;
			}
			long ans = 0;
			Arrays.sort(p);
			//System.out.println(Arrays.toString(p));
			long prevEnd = -1;
			long prevN = 0;
			for(int i = 0; i<n; i++){

				if(p[i].x >= prevEnd){
					long nn = p[i].y-p[i].x;
			
					ans+= ((nn)*(nn+1))/2;
					prevEnd = p[i].y;
					prevN = nn;
				}else{

					if(prevEnd < p[i].y){
						long a = prevN+1;
						long nn = p[i].y-prevEnd;
						long sum = ((nn)*(2*a+(nn-1)))/2;
						ans +=sum;
						prevN = a+(nn-1);
						prevEnd = p[i].y;
					}

				}
				
			}




			sb.append(ans+""\n"");

			
			
			t--;
		}
		
		System.out.println(sb);
		
 
		
    }

}

class Pair implements Comparable<Pair>{
  	long x;
  	long y;

  	Pair(long x, long y){
  		this.x = x;
  		this.y = y;
  	}

  	 // @Override
    //  public boolean equals(Object o) {
    //  	if(this == o)return true;
    //  	if(o == null || this.getClass() != o.getClass())return false;
    //  	Pair p = (Pair)o;
        
    //     return x == p.x && y == p.y;
    // }

    // @Override
    // public int hashCode(){
    // 	return Objects.hash(x , y);
    // }
  	@Override
    public String toString() {
        return ""("" + x + "", "" + y + "")"";
    }
    @Override
    public int compareTo(Pair o) {
    	return (int)this.x-(int)o.x;
    }
}","import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class MonstersAndSpells {

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return 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 input = new FastReader();
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        int t = input.nextInt();
        while (t-- > 0) {
            int n = input.nextInt();
            long k[] = new long[n];
            long h[] = new long[n];
            long ans = 0;
            for (int i = 0; i < n; i++) {
                k[i] = input.nextInt();
            }
            for (int i = 0; i < n; i++) {
                h[i] = input.nextInt();
            }
            for (int i = n-1; i >0; i--) {
                long d = k[i]-k[i-1];
                if(h[i-1]+d<h[i]){
                    h[i-1]+=(h[i]-(h[i-1]+d));
                }
            }
            ans += (h[0]) * (h[0] + 1) / 2;
            long last = h[0];
            for (int i = 1; i < n; i++) {
                if (k[i] - k[i - 1] >= h[i]) {
                    ans += (h[i]) * (h[i] + 1) / 2;
                    last = h[i];
                } else {
                    long x = (k[i] - k[i - 1]);
                    long y = last + x;
                    long sum1 = (last) * (last + 1) / 2;
                    long sum2 = (y) * (y + 1) / 2;
                    ans += (sum2 - sum1);
                    last = y;
                }
            }
            log.write(ans + ""\n"");
        }
        log.flush();
    }

}
",0,Non-plagiarised
565f77b7,856a8eda,"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);
		}
	}
}","/*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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
10bbe9de,489930000000,"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,Non-plagiarised
161b4a40,da5cf40b,"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();
    }
}","/*****  --->         :)    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,Non-plagiarised
0b27be88,3f4a5b64,"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];
        }
    }
    
    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++) {
            int n=input.scanInt();
            int m=input.scanInt();
            int x=input.scanInt();
            ans.append(""YES\n"");
            TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
            for(int i=1;i<=m;i++) {
                ans.append(i+"" "");
                int tmp=input.scanInt();
                if(!tm.containsKey(tmp)) {
                    Stack<Integer> stck=new Stack<>();
                    stck.add(i);
                    tm.put(tmp, stck);
                }
                else {
                    Stack<Integer> stck=tm.get(tmp);
                    stck.add(i);
                }
            }
            for(int i=m;i<n;i++) {
                int tmp=input.scanInt();
                int min=tm.firstKey();
                Stack<Integer> stck=tm.get(min);
                int indx=stck.pop();
                ans.append(indx+"" "");
                if(stck.isEmpty()) {
                    tm.remove(min);
                }
                tmp+=min;
                
                if(!tm.containsKey(tmp)) {
                    stck=new Stack<>();
                    stck.add(indx);
                    tm.put(tmp, stck);
                }
                else {
                    stck=tm.get(tmp);
                    stck.add(indx);
                }
            }
            ans.append(""\n"");
        }
        System.out.println(ans);
    }
}


","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];
        }
    }
    
    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++) {
            int n=input.scanInt();
            int m=input.scanInt();
            int x=input.scanInt();
            ans.append(""YES\n"");
            TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
            for(int i=1;i<=m;i++) {
                ans.append(i+"" "");
                int tmp=input.scanInt();
                if(!tm.containsKey(tmp)) {
                    Stack<Integer> stck=new Stack<>();
                    stck.add(i);
                    tm.put(tmp, stck);
                }
                else {
                    Stack<Integer> stck=tm.get(tmp);
                    stck.add(i);
                }
            }
            for(int i=m;i<n;i++) {
                int tmp=input.scanInt();
                int min=tm.firstKey();
                Stack<Integer> stck=tm.get(min);
                int indx=stck.pop();
                ans.append(indx+"" "");
                if(stck.isEmpty()) {
                    tm.remove(min);
                }
                tmp+=min;
                
                if(!tm.containsKey(tmp)) {
                    stck=new Stack<>();
                    stck.add(indx);
                    tm.put(tmp, stck);
                }
                else {
                    stck=tm.get(tmp);
                    stck.add(indx);
                }
            }
            ans.append(""\n"");
        }
        System.out.println(ans);
    }
}


",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
464a03b8,cf27732e,"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.*;



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,Non-plagiarised
45561f1f,cc9230d3,"/**
 * Created by Himanshu
 **/

import java.util.*;
import java.io.*;
import java.math.*;

public class C1529 {
    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();
            pairLong [] arr = new pairLong[n];
            for (int i=0;i<n;i++) {
                long x = s.l() , y = s.l();
                arr[i] = new pairLong(x,y);
            }
            ArrayList<Integer>[] 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 = s.i() , y = s.i();
                tree[x].add(y);
                tree[y].add(x);
            }
            pairLong[] dp = new pairLong[n+1];
            boolean [] vis = new boolean[n+1];
            pairLong x = value(tree,arr,dp,1,vis);
            out.println(Math.max(x.first,x.second));
        }
        out.flush();
    }
    private static pairLong value(ArrayList<Integer>[] tree , pairLong [] arr , pairLong [] dp , int in , boolean [] vis) {
        if (dp[in] != null) return dp[in];
        vis[in] = true;
        long a = 0L , b = 0L;
        for (int x : tree[in]) {
            if (!vis[x]) {
                pairLong y = value(tree,arr,dp,x,vis);
                a += Math.max(Math.abs(arr[in-1].first-arr[x-1].first) + y.first,Math.abs(arr[in-1].first-arr[x-1].second) + y.second);
                b += Math.max(Math.abs(arr[in-1].second-arr[x-1].first) + y.first,Math.abs(arr[in-1].second-arr[x-1].second) + y.second);
            }
        }
        dp[in] = new pairLong(a,b);
        return dp[in];
    }
    private static void bfs(ArrayList<Integer>[] tree , ArrayList<Integer> even ,
                            ArrayList<Integer> odd , int n) {
        Queue<Integer> q = new LinkedList<>();
        q.add(1);
        int in = 0;
        boolean [] vis = new boolean[n+1];
        vis[1] = true;
        while (!q.isEmpty()) {
            Integer a = q.poll();
            if (a == null) {
                q.add(null);
                in++;
            } else {
                if (in%2 == 0) even.add(a);
                else odd.add(a);
                for (int x : tree[a]) {
                    if (!vis[x]) {
                        q.add(x);
                        vis[x] = true;
                    }
                }
            }
            if (q.size() == 0) break;
        }
    }
    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;
//        }
//    }
}

","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;
        }
    }
}
",0,Non-plagiarised
169e34bf,c9159d9c,"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.*;

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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
5e8d1aaa,c4d04ce7,"import java.io.*;
import java.util.*;

/*

*/


public class E {
	static FastReader sc=null;
	static long max=(long)1e15+7;
	
	public static void main(String[] args) {
		sc=new FastReader();
		PrintWriter out=new PrintWriter(System.out);
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt(),k=sc.nextInt();
			int a[]=sc.readArray(k),te[]=sc.readArray(k);
			int curr[]=new int[n];
			Arrays.fill(curr, -1);
			for(int i=0;i<k;i++) {
				a[i]--;
				curr[a[i]]=te[i];
			}
			long min=max;
			long ts[]=new long[n];
			Arrays.fill(ts, max);
			for(int i=n-1;i>=0;i--) {
				if(curr[i]!=-1) {
					min=Math.min(min, curr[i]+i);
				}
				ts[i]=Math.min(ts[i], min-i);
			}
			min=max;
			for(int i=0;i<n;i++) {
				if(curr[i]!=-1) {
					min=Math.min(min, curr[i]-i);
				}
				ts[i]=Math.min(ts[i], min+i);
			}
			for(long e:ts)out.print(e+"" "");
			out.println();
			
		}
		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; 
        }
        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.*;
import java.util.*;

/*

*/


public class E {
	static FastReader sc=null;
	static long nax=(long)1e15+7;
	
	public static void main(String[] args) {
		sc=new FastReader();
		PrintWriter out=new PrintWriter(System.out);
		int test=sc.nextInt();
		while(test-->0) {
			int n=sc.nextInt(),k=sc.nextInt();
			int a[]=sc.readArray(k),t[]=sc.readArray(k);
			int present[]=new int[n];
			Arrays.fill(present, -1);
			for(int i=0;i<k;i++) {
				a[i]--;
				present[a[i]]=t[i];
			}
			long min=nax;
			long temps[]=new long[n];
			Arrays.fill(temps, nax);
			for(int i=n-1;i>=0;i--) {
				if(present[i]!=-1) {
					min=Math.min(min, present[i]+i);
				}
				temps[i]=Math.min(temps[i], min-i);
			}
			min=nax;
			for(int i=0;i<n;i++) {
				if(present[i]!=-1) {
					min=Math.min(min, present[i]-i);
				}
				temps[i]=Math.min(temps[i], min+i);
			}
			for(long e:temps)out.print(e+"" "");
			out.println();
			
		}
		out.close();
		
	
	}
	static class Pair implements Comparable<Pair>{
		int id,t;
		Pair(int id,int t){
			this.id=id;
			this.t=t;
		}
		@Override
		public int compareTo(Pair o) {
			return this.id-o.id;
		}
	}
	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{
		
		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());
		}
		
		int[] readArray(int n) {
			int a[]=new int[n];
			for(int i=0;i<n;i++)a[i]=sc.nextInt();
			return a;
		}
	}
}






",1,Plagiarised
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,Plagiarised
22b41936,2.921E+060,"


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,Non-plagiarised
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,Non-plagiarised
49b94994,558df7d4,"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 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;
	    }
	}
}
",0,Non-plagiarised
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,Plagiarised
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,Plagiarised
1dab88fb,b7de5c19,"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 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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
40cc90ae,9399204d,"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.*;



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,Non-plagiarised
1162c08f,f6ca6fc8,"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.*;
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
764484c3,9028caf7,"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();}
}
","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,Non-plagiarised
14b0fb8e,d221162a,"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.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);
	}
}
",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
51d857bc,c392efe7,"
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.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

/**
 * Main , Solution , Remove Public
 */
public class D {

	static int visited[];
	static int distance[];
	private static ArrayList<Integer>[] adj;
	 
	
	private static void BFS(int node) {
		
		visited[node] = 1;
		Queue<Integer> q = new LinkedList<Integer>();
		q.offer(node);
		distance[node] = 0;
		
		while(!q.isEmpty()) {
			int curr = q.poll();
			for(int child : adj[curr]) {
				if(visited[child] == 0) {
					q.offer(child);
					distance[child] = distance[curr] + 1;
					visited[child] = 1;
				}
			}
		}
		
	}
	

	public static void process() throws IOException {

		int n = sc.nextInt(),a = sc.nextInt(),b = sc.nextInt(),
				da = sc.nextInt(),db = sc.nextInt();
		adj = new ArrayList[n+1];
		distance = new int[n+1];
		visited = new int[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);
		}
		BFS(a);
		if(distance[b] <= da || db-da<=da) {
			System.out.println(""Alice"");
			return;
		}
		ArrayList<Pair> lis = new ArrayList<D.Pair>();
		for(int i = 1; i<=n; i++)lis.add(new Pair(distance[i], i));
		Collections.sort(lis);
		Pair e = lis.get(n-1);
		distance = new int[n+1];
		visited = new int[n+1];
		BFS(e.y);
		int max = 0;
		for(int i = 1; i<=n; i++)max = max(max,distance[i]);
		if(max-da<=da) {
			System.out.println(""Alice"");
			return;
		}
		System.out.println(""Bob"");
	}

	//=============================================================================
	//--------------------------The End---------------------------------
	//=============================================================================
	

	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 debug(Object o) {
		System.out.println(o);
	}

	static void debug(Object x, Object y) {
		System.out.println(""("" + x + "" , "" + y + "")"");
	}

	static void println(Object o) {
		out.println(o);
	}

	static void println(int[] o) {
		for (int e : o)
			print(e + "" "");
		println();
	}

	static void println(long[] o) {
		for (long e : o)
			print(e + "" "");
		println();
	}

	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);
	}

	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];
	}

}
",0,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
976fe834,da54dec3,"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!
-> Feynman Rule 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 yo = sc.nextInt();
        while (yo-- > 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[][] arr = new int[n][m];
            for(int i = 0; i < n; i++){
                String s = sc.next();
                for(int j = 0; j < m; j++){
                    arr[i][j] = s.charAt(j)-'0';
                }
            }
            
            List<String> list = new ArrayList<>();
            for(int i = 0; i < n-1; i++){
                for(int j = 0; j < m-1; j++){
                    check(list,i,j,n,m,arr);
                }
            }
            
            // for(int i = 0; i < n; i++){
            //     for(int j = 0; j < m; j++){
            //         out.print(arr[i][j] + "" "");
            //     }
            //     out.println();
            // }
            
            out.println(list.size()/3);
            for(int i = 0; i < list.size(); i+=3){
                out.println(list.get(i) + "" "" + list.get(i+1) + "" "" + list.get(i+2));
            }
            // out.println(list.size());
            // for(int i = 0; i < list.size(); i++){
            //     out.println(list.get(i));
            // }
        }
        out.close();    
	}
    
    static void check(List<String> list, int i, int j, int n, int m, int[][] arr){
        int[][] a = new int[2][2];
        a[0][0] = arr[i][j];
        a[0][1] = arr[i][j+1];
        a[1][0] = arr[i+1][j];
        a[1][1] = arr[i+1][j+1];
        
        int ones = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) ones++;
            }
        }
        
        if(ones == 0) return;
        
        if(ones == 1){
            ones(i,j,list,a);
            twos(i,j,list,a);
            threes(i,j,list,a);
        }
        else if(ones == 2){
            twos(i,j,list,a);
            threes(i,j,list,a);
        }
        else if(ones == 3){
            threes(i,j,list,a);
        }
        else if(ones == 4){
            fours(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            ones(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            twos(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            threes(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
        }
        
        arr[i][j] = a[0][0];
        arr[i+1][j] = a[1][0];
        arr[i][j+1] = a[0][1];
        arr[i+1][j+1] = a[1][1];
    }
    
    public static void twos(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1 && count < 1) {
                    count++;
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
                else if(a[x][y] == 0){
                    list.add(get(x,y,i,j));
                    a[x][y] = 1;
                }
            }
        }
    }
    
    public static void threes(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) {
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static void fours(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1 && count < 3) {
                    count++;
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static void ones(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) {
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
                else if(a[x][y] == 0 && count < 2){
                    a[x][y] = 1;
                    count++;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static String get(int x, int y, int i, int j){
        if(x == 0 && y == 0) {
            return (i+1) + "" "" + (j+1);
        }
        else if(x == 0 && y == 1){
            return (i+1) + "" "" + (j+2);
        }
        else if(x == 1 && y == 0){
            return (i+2) + "" "" + (j+1);
        }
        else {
            return (i+2) + "" "" + (j+2);
        }
    }
    
   
    
    
    /*
         Random stuff to try when stuck:
            -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) {
		//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.util.*;
import java.math.*;
public class Solution {
	final static int MOD = 1000000007;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int t = Integer.parseInt(in.next());
		for(int tt = 0; tt < t; tt++) {
			int n = Integer.parseInt(in.next());
			int m = Integer.parseInt(in.next());
			char[][] grid = new char[n][m];
			List<Integer> ans = new ArrayList<>();
			for(int i = 0; i < n; i++) {
				grid[i] = in.next().toCharArray();
			}
			int iii = 0;
			int jjj = 0;
			if(n % 2 != 0) {
				iii = 1;
				for(int j = 0; j + 1 < m; j++) {
					if(grid[0][j] == '1') {
						grid[0][j] = '0';
						grid[1][j] = (grid[1][j] == '1') ? '0' : '1';
						grid[1][j + 1] = (grid[1][j + 1] == '1') ? '0' : '1';
						ans.add(1); ans.add(j + 1);
						ans.add(2); ans.add(j + 1);
						ans.add(2); ans.add(j + 2);
					}
					if(grid[0][j + 1] == '1') {
						grid[0][j + 1] = '0';
						grid[1][j] = (grid[1][j] == '1') ? '0' : '1';
						grid[1][j + 1] = (grid[1][j + 1] == '1') ? '0' : '1';
						ans.add(1); ans.add(j + 2);
						ans.add(2); ans.add(j + 1);
						ans.add(2); ans.add(j + 2);
					}
				}
			}
			if(m % 2 != 0) {
				jjj = 1;
				for(int i = (n % 2 == 0) ? 0 : 1; i + 1 < n; i++) {
					if(grid[i][0] == '1') {
						grid[i][0] = '0';
						grid[i][1] = (grid[i][1] == '1') ? '0' : '1';
						grid[i + 1][1] = (grid[i + 1][1] == '1') ? '0' : '1';
						ans.add(i + 1); ans.add(1);
						ans.add(i + 1); ans.add(2);
						ans.add(i + 2); ans.add(2);
					}
					if(grid[i + 1][0] == '1') {
						grid[i + 1][0] = '0';
						grid[i][1] = (grid[i][1] == '1') ? '0' : '1';
						grid[i + 1][1] = (grid[i + 1][1] == '1') ? '0' : '1';
						ans.add(i + 2); ans.add(1);
						ans.add(i + 1); ans.add(2);
						ans.add(i + 2); ans.add(2);
					}
				}
			}
			for(int i = iii; i < n; i += 2) {
				for(int j = jjj; j < m; j += 2) {
					int cnt = count(grid, i, j);
					while(cnt > 0) {
						List<G> g = new ArrayList<>();
						for(int k = i; k < i + 2; k++) {
							for(int l = j; l < j + 2; l++) {
								g.add(new G(grid[k][l], k, l));
							}
						}
						Collections.sort(g);
						int l = 0;
						int r = 0;
						if(cnt == 1 || cnt == 3) {
							l = 1; r = 3;
						}else {
							l = 0; r = 2;
						}
						for(int k = l; k <= r; k++) {
							int ii = g.get(k).i;
							int jj = g.get(k).j;
							grid[ii][jj] = (grid[ii][jj] == '1') ? '0' : '1';
							ans.add(ii + 1);
							ans.add(jj + 1);
						}
						cnt = count(grid, i, j);
					}
				}
			}
			System.out.println(ans.size() / 6);
			for(int i = 0; i < ans.size(); i += 6) {
				for(int j = i; j < i + 6; j++) {
					System.out.print(ans.get(j) + "" "" );
				}
				System.out.println();
			}
		}
	}
	public static int count(char[][] grid, int i, int j) {
		int cnt = 0;
		for(int k = i; k < i + 2; k++) {
			for(int l = j; l < j + 2; l++) {
				if(grid[k][l] == '1') cnt += 1;
			}
		}
		return cnt;
	}
}
class G implements Comparable <G> {
	Character val;
	int i;
	int j;
	public G(char val, int i, int j) {
		this.val = val;
		this.i = i;
		this.j = j;
	}
	@Override
	public int compareTo(G obj) {
		return this.val.compareTo(obj.val);
	}
}",0,Non-plagiarised
e6a6e318,fadc1365,"//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;
    	}
    }
}
","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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
49b94994,d8654140,"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.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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
0fd5b95a,41e72d4f,"//package codeforces;
import java.io.PrintWriter;
import java.util.*;
public class codeforces {
	static int dp[][]=new int[5001][5001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);  
		PrintWriter out=new PrintWriter(System.out);
        int t=1;
        for(int tt=0;tt<t;tt++) {
        	int n=s.nextInt();
        	int a[]=new int[n];
        	ArrayList<Integer> z=new ArrayList<>();
        	ArrayList<Integer> o=new ArrayList<>();
        	for(int i=0;i<n;i++) {
        		a[i]=s.nextInt();
        		if(a[i]==1) {
        			o.add(i);
        		}else {
        			z.add(i);
        		}
        	}
        	for(int i=0;i<5001;i++) {
        		Arrays.fill(dp[i], -1);
        	}
        	System.out.println(sol(0,0,z,o));
        }
        out.close();
	    s.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 sortcol(int a[][],int c) {
		Arrays.sort(a, (x, y) -> {
			if (x[c] != y[c]) return(int)( x[c] - y[c]);
			return (int)-(x[1]+x[2] - y[1]-y[2]);
		});
	}
	static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
	public static int sol(int i,int j,ArrayList<Integer> z,ArrayList<Integer> o) {
		if(j==o.size()) {
			return 0;
		}
		int h=z.size()-i;
		int l=o.size()-j;
		if(i==z.size()) {
			return 10000000;
		}
		if(dp[i][j]!=-1) {
			//System.out.println(i+"" ""+j);
			return dp[i][j];
		}
		int ans1=sol(i+1,j,z,o);
		int ans2=sol(i+1,j+1,z,o)+Math.abs(z.get(i)-o.get(j));
		dp[i][j]=Math.min(ans1, ans2);
		return dp[i][j];
	}
}

","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.StringTokenizer;

public class ProblemD {
	
	public static void main(String[] args) throws IOException {
		final int INF = 20000000;
		InputStream in = System.in;
		InputReader scan = new InputReader(in);
		int n = scan.nextInt();
		int occ = 0;
		List<Integer> occPos = new ArrayList<>();
		HashSet<Integer> occPosSet = new HashSet<>();
		for(int i=1;i<=n;i++) {
			int num = scan.nextInt();
			if(num==1) {
				occ++;
				occPos.add(i);
				occPosSet.add(i);
			}
		}
		int[][] dp = new int[n+1][occ+1];
		for(int i=0;i<=n;i++) {
			for(int j=0;j<=occ;j++) {
				dp[i][j] = 20000000;
			}
		}
		for(int i=1;i<=n;i++) {
			int k=1;
			for(int pos: occPos) {
				if(occPosSet.contains(i)) {
					dp[i][k] = dp[i-1][k];
				} else {
					dp[i][k] = Math.min(dp[i-1][k], dp[i-1][k-1]+Math.abs(pos-i));
					if(k==1) dp[i][k]=Math.min(dp[i][k],Math.abs(pos-i));
				}
				k++;
			}
		}
		if(dp[n][occ]==INF) {
			System.out.println(0);
		} else {
			System.out.println(dp[n][occ]);
		}
	}
	
	static class InputReader {
		BufferedReader br;
		StringTokenizer st;
		
		InputReader(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}
		
		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException ioe) {
					ioe.printStackTrace();
				}
			}
			return st.nextToken();
		}
		
		int nextInt() {
			return Integer.parseInt(next());
		}
		
		public long nextLong() {
			return Long.parseLong(next());
		}
	}
}
",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
67996c4c,7bc92b7f,"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.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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
0588b869,11373c16,"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();
    }
}","/* 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();
	}
   
}
",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
fc7dfa16,fe94ee2f,"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;
    static long arr[];
    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();
            arr=new long[n];
            for(int i=0;i<n;i++) {
                arr[i]=input.scanInt();
            }
            ans.append(solve()+""\n"");
        }
        System.out.println(ans);
    }
    
    public static long solve() {
        long ans=Long.MAX_VALUE;
        long r_min=Long.MAX_VALUE,u_min=Long.MAX_VALUE;
        long r_rem=n,u_rem=n,sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==0) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        r_min=Long.MAX_VALUE;
        u_min=Long.MAX_VALUE;
        r_rem=n;
        u_rem=n;
        sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==1) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        return ans;
    }
}


","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;
    static long arr[];
    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();
            arr=new long[n];
            for(int i=0;i<n;i++) {
                arr[i]=input.scanInt();
            }
            ans.append(solve()+""\n"");
        }
        System.out.println(ans);
    }
    
    public static long solve() {
        long ans=Long.MAX_VALUE;
        long r_min=Long.MAX_VALUE,u_min=Long.MAX_VALUE;
        long r_rem=n,u_rem=n,sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==0) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        r_min=Long.MAX_VALUE;
        u_min=Long.MAX_VALUE;
        r_rem=n;
        u_rem=n;
        sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==1) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        return ans;
    }
}

",1,Plagiarised
548ffb07,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,Plagiarised
11373c16,d8e4eb5e,"/* 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 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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
1c8bb204,7d7cf9a7,"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.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);
  }
}",0,Non-plagiarised
3a12e509,e812ee0b,"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.*;
import java.util.concurrent.Exchanger;

public class Codeforces {

    static int[] mass = new int[200_001];


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder stringBuilder = new StringBuilder();
        int t = scanner.nextInt();
        for (int z =0 ; z < t ; ++z) {
            solve(scanner, stringBuilder);
        }
        System.out.print(stringBuilder);
    }

    private static void solve(Scanner scanner, StringBuilder stringBuilder) {
        int n = scanner.nextInt();
        for (int i = 0 ; i < n ; ++i) {
            mass[i] = scanner.nextInt();
        }
        String colors = scanner.next();
        List<Integer> red = new ArrayList<>(n);
        List<Integer> blue = new ArrayList<>(n);
        for (int i = 0 ; i < n ; ++i) {
            if(colors.charAt(i) == 'R') red.add(mass[i]);
            else blue.add(mass[i]);
        }
        red.sort(Comparator.reverseOrder());
        blue.sort(Comparator.naturalOrder());
        int creatd = 0;
        int upper = n;
        int down = 1;
        for (Integer integer : red) {
            if (integer > upper) {
                stringBuilder.append(""NO\n"");
                return;
            } else {
                creatd++;
                upper--;
            }
        }
        for (Integer integer : blue) {
            if (integer < down) {
                stringBuilder.append(""NO\n"");
                return;
            } else {
                creatd++;
                down++;
            }
        }
        if (creatd == n) stringBuilder.append(""YES\n"");
        else stringBuilder.append(""NO\n"");
    }
}",0,Non-plagiarised
94b3b86d,efe594c3,"import java.io.*; 
import java.util.*; 

public class D  
{
   public static ArrayList<Integer> adj[];
   public static int node;
   public static int dist = 0;
   public static void main(String[] args) throws IOException
   {
      FastScanner sc = new FastScanner();
      int T = sc.nextInt();
      PrintWriter out = new PrintWriter(System.out);
      for(int t = 0; t < T; t++){
         int N = sc.nextInt();
         int a = sc.nextInt(); int b = sc.nextInt();
         int da = sc.nextInt(); int db = sc.nextInt();
         adj = new ArrayList[N+1];
         for(int i = 0; i <= N; i++){
            adj[i] = new ArrayList<Integer>();
         }
         for(int i = 0; i < N-1; i++){
            int v = sc.nextInt();
            int u = sc.nextInt();
            adj[v].add(u);
            adj[u].add(v);
         }
         if(db > 2*da){
            dfs1(a, 0, b, 0);
            if(dist <= da){
               out.println(""Alice"");
            }
            else{
               node = 0;
               dist = 0;
               dfs(1, 0, 0);
               dfs(node, 0, 0);
               if(dist > 2*da){
                  out.println(""Bob"");
               }
               else{
                  out.println(""Alice"");
               }
            }
         }
         else{
            out.println(""Alice"");
         }
      }
      out.close();
   }  
   public static void dfs1(int a, int p, int b, int d){
      if(a == b){
         dist = d;
      }
      for(int next : adj[a]){
         if(next != p){
            dfs1(next, a, b, d+1);
         }  
      }
   }
   public static void dfs(int i, int p, int d){
      if(d > dist){
         node = i;
         dist = d;
      }
      for(int next : adj[i]){
         if(next != p){
            dfs(next, i, d+1);
         }  
      }
   }


   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 void ASSERT(boolean assertion, String message) {
      if (!assertion) throw new AssertionError(message);
   }
}
","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.LinkedList;
import java.util.StringTokenizer;

public class problemD {
    static ArrayList<Integer>[] adj;
    static boolean found = false;
    static int[] D = new int[212345];
    private static void solve() throws Exception {
        int n = fs.nextInt();
        int a = fs.nextInt();
        int b = fs.nextInt();
        int da = fs.nextInt();
        int db = fs.nextInt();
        adj = new ArrayList[n+1];
        for (int i = 0 ; i <= n ; i ++ ) adj[i] = new ArrayList<Integer>();
        for (int i = 0 ; i < n-1; i ++ ) {
            int u = fs.nextInt();
            int v = fs.nextInt();
            adj[u].add(v);
            adj[v].add(u);
        }


        found = false;
        dfs(a, 0, 0, da, b);
        if (found) {
            out.println(""Alice"");
            return;
        }

        dfs(b,0,0);
        int maxD = -1;
        int node = -1;
        for (int i = 1; i <= n; i ++ ) {
            if (D[i] > maxD) {
                maxD = D[i];
                node = i;
            }
        }

        dfs(node, 0, 0);
        maxD = -1;
        for (int i = 1; i <= n; i ++ ) {
            if (D[i] > maxD) {
                maxD = D[i];
            }
        }


        boolean bob = db > da * 2 && maxD > da * 2;
        out.println(bob ? ""Bob"" : ""Alice"");
    }

    private static void dfs(int node, int parent, int dist) {
        D[node] = dist;
        for (int x: adj[node]) {
            if (x != parent) {
                dfs(x, node, dist+1);
            }
        }
    }

    private  static void dfs(int node, int parent, int dist, int da, int b) {

        if (node == b) { found = true; return; }
        for (int x: adj[node]) {
            if (x != parent) {
                if (dist+1 <= da) {
                    dfs(x, node, dist + 1, da, b);
                }
            }
        }
    }

    private static FastScanner fs = new FastScanner();
    private static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws Exception {
        int T = 1;
        T = fs.nextInt();
        for (int t = 0; t < T; t++) {
            solve();
        }
        out.close();
    }

    static void debug(Object... O) {
        System.err.print(""DEBUG "");
        System.err.println(Arrays.deepToString(O));
    }

    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());
        }

        String nextString() {
            return next();
        }
    }
}
",0,Non-plagiarised
624b8db5,90f01508,"//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.DataInputStream; 
// import java.io.FileInputStream; 
// import java.io.IOException; 
import java.io.*; 
import java.util.*;

public class one
{
  static Scanner sc=new Scanner(System.in);
  boolean prime[];
  static int prev=-1;
  static int dp[][];

  public static int[] input(int size){
    int arr[]=new int[size];
    for(int i=0;i<size;i++)
    arr[i]=sc.nextInt();
    return arr;
  }

  public static void main(String[] args) {
    //int testcase=1;
    int testcase=sc.nextInt();
    //System.out.println(""HI"");
      while(testcase-->0){
        // int x=sc.nextInt();
        // int y=sc.nextInt();
       //String str[]=new String[size];
       solve();
       System.out.println();
    }    
  } 

  public static void solve(){
    HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
    int size=sc.nextInt();
    int arr[][]=new int[size-1][2];
    for(int i=0;i<size-1;i++){
      arr[i][0]=sc.nextInt();
      arr[i][1]=sc.nextInt();
    }
    for(int x[]:arr){
      map.put(x[0],map.getOrDefault(x[0], 0)+1);
      map.put(x[1],map.getOrDefault(x[1], 0)+1);
      if(map.get(x[0])>2||map.get(x[1])>2){
        System.out.println(-1);
        return;
      }
    }
    List<List<Integer>> adj=new ArrayList<>();
    for(int i=0;i<=size;i++)
    adj.add(new ArrayList<Integer>());
    for(int x[]:arr){
      adj.get(x[0]).add(x[1]);
      adj.get(x[1]).add(x[0]);
    }
    //System.out.println(adj);
    int vist[]=new int[size+1];
    HashMap<String,Integer> ans=new HashMap<String,Integer>();
    for(int i=1;i<=size;i++){
      if(vist[i]==0){
        dfs(i,vist,adj,ans,2);
      }
    }
    //System.out.println(ans);
    for(int x[]:arr){
      //System.out.print(map.get(x[0]));
      int a=Math.min(x[0],x[1]);
      int b=Math.max(x[0],x[1]);
      String s=a+"" ""+b;
      System.out.print(ans.get(s)+"" "");
    }
    // map=new HashMap<Integer,Integer>();
    // for(int x[]:arr){
    //   if(map.containsKey(x[0])){
    //     int val=13-map.get(x[0]);
    //     map.put(x[1],val);
    //     System.out.print(val+"" "");
    //   }else if(map.containsKey(x[1])){
    //     int val=13-map.get(x[1]);
    //     map.put(x[0],val);
    //     System.out.print(val+"" "");
    //   }else{
    //     System.out.print(2+"" "");
    //     map.put(x[0],2);
    //     map.put(x[1],2);
    //   }
    // }

  }
  public static void dfs(int node,int vist[],List<List<Integer>> adj,HashMap<String,Integer> ans,int val){
    vist[node]=1;
    for(int i:adj.get(node)){
      if(vist[i]==1)
      continue;
      int x=Math.min(i, node);
      int y=Math.max(i, node);
      ans.put(x+"" ""+y,val);
      dfs(i,vist,adj,ans,5-val);
      val=5-val;
    }
  }
}",0,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
2b2d3b84,aaccc000,"
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.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,Plagiarised
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,Non-plagiarised
0b04b41e,4da08761,"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.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;
        }

    }
}",0,Non-plagiarised
28820c82,8637bb90,"import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;

public class MinimumGridPath {
    
    static int mod = 1000000007;

    public 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 static void main(String[] args) throws Exception {
        Reader scn = new Reader();
        PrintWriter pw = new PrintWriter(System.out);
        int t = scn.nextInt();
        outer : while(t-->0){
            int n = scn.nextInt();
            long[] arr = new long[n];
            for(int i=0; i<n; i++){
            	arr[i] = scn.nextInt();
            }
            long ans = Long.MAX_VALUE;
           	int k = 2;
           	long oddSum = arr[0];
           	long evenSum = 0;
           	long oddMin = arr[0];
           	long evenMin = Long.MAX_VALUE;
           	long oddCount = 1;
           	long evenCount = 0;
           	while(k <= n){
           		if(k % 2 == 1){
           			oddSum += arr[k-1];
           			oddCount++;
           			oddMin = Math.min(oddMin, arr[k-1]);
           		}else{
           			evenSum += arr[k-1];
           			evenCount++;
           			evenMin = Math.min(evenMin, arr[k-1]);
           		}
           		long sum = oddSum - oddMin + oddMin*(n - oddCount + 1) + evenSum - evenMin + evenMin*(n - evenCount + 1);
           		ans = Math.min(ans, sum);
           		k++;
           	}
           	pw.println(ans);
        }
        pw.close();
    }

    public static class Pair{
        long x;
        long y;

        Pair(long x, long 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 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--);
        }
    }

    // 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;
    } 
}","       import java.util.*;


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
public class Solutions {

		static int MAX=Integer.MAX_VALUE;
		static int MIN=Integer.MIN_VALUE;
//static ArrayList<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
	static FastScanner scr=new FastScanner();
	static PrintStream out=new PrintStream(System.out);
	public static void main(String []args) {
		int T=scr.nextInt();
		t:for(int tt=0;tt<T;tt++) {
			int n=scr.nextInt();
			int []a=scr.readArray(n);
			long min[]=new long[2];  
  			long sum[]=new long[2]; 
			sum  [0]=a[0];
			sum  [1]=0;
			min[0]=a[0];
			min[1]=MAX;
			long ans=Long.MAX_VALUE;
			for(int i=1;i<n;i++) {
				min[i%2]=Math.min(min[i%2],a[i]);
				sum[i%2]+=a[i];
				
				int odd=(i+2)/2;
				int even=(i+1)/2;
				ans=Math.min(ans,sum[0]+((n-odd)*min[0])+sum[1]+((n-even)*min[1]));
			}
			out.println(ans);
		}
	}
	static long modPow(long base,long exp,long mod) {
		if(exp==0) {
			return 1;
		}
		if(exp%2==0) {
			long res=(modPow(base,exp/2,mod));
			return (res*res)%mod;
		}
		return (base*modPow(base,exp-1,mod))%mod;
	}
	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[] sort(int a[]) {
			Arrays.sort(a);
			return a;
		}
		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());
		}
	}

}
class triplet{
	int x;
	int y;
	int z;
	triplet(int fisrt,int second,int third){
		this.x=fisrt;
		this.y=second;
		this.z=third;
	}
}
class pair{
	int x=0;
	int y=0;
	pair(int first,int second){
		this.x=first;
		this.y=second;
	}
}
",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
4241f473,4685c420,"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 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;
    }
}",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
1500a4fa,d7a8434f,"       

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();
	    String a=sc.next();
	    String b=sc.next();
	   int i;
	   int zero=0,one=0;
	     int x=0,y=0,x1=0,y1=0;
	    for(i=0;i<n;i++){
	        if(a.charAt(i)=='0')
	        zero++;
	        else
	        one++;
	    }
	    if(one==0){
	        if(a.equals(b))
	        System.out.println(""0"");
	        else
	        System.out.println(""-1"");
	    }
	    else{
	        int same=0,diff=0;
	        for(i=0;i<n;i++){
	            if(a.charAt(i)==b.charAt(i)){
	                same++;
	                x++;
	                if(a.charAt(i)=='1'){
	                    x1++;
	                    
	                }
	            }
	            else{
	                diff++;
	                y++;
	                if(a.charAt(i)=='1'){
	                    y1++;
	                    
	                }
	            }
	            
	        }
	        int ans=Integer.MAX_VALUE;
    if(x%2!=0&&(x+1)/2==x1){
        ans=x;
        
    }
    if(y%2==0&&(y/2)==y1){
ans=Math.min(ans,y);
    }
    if(ans==Integer.MAX_VALUE){
        
        System.out.println(""-1"");
        
    }else{
        
        System.out.println(ans);
    }
	       
	    }
	    
	}
	    
	}
    
}
	","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,Non-plagiarised
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,Non-plagiarised
c48673a6,ebed1250,"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());
        }
    }
}
","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();
        long[] c = new long[n];
        for (int i = 0; i < n; i++) {
            c[i] = in.nextInt();
        }

        long ans = (c[0] + c[1]) * n;
        long sum = c[0] + c[1];
        long[] min = {c[0], c[1]};
        for (int i = 2; i < n; i++) {
            sum += c[i];
            int index = i % 2;
            min[index] = Math.min(min[index], c[i]);

            int[] times = new int[2];
            times[index] = n - (i / 2 + 1);
            times[index ^ 1] = n - ((i - 1) / 2 + 1);
            ans = Math.min(ans, sum + min[0] * times[0] + min[1] * times[1]);
        }
        out.println(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 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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
d55c238c,ebce9e39,"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, m, x;
            n = in.nextInt();
            m = in.nextInt();
            x = in.nextInt();

            int[] arr = new int[n];
            answer[] array = new answer[n];
            int[] ar = new int[n];

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
                array[i] = new answer(arr[i],i);
            }

            long[] ans = new long[m];
            Arrays.sort(array);


            int a = 0 , b = 0;
            while(true){
                for (int i = 0; i < m; i++) {
                    ar[b] = i+1;
                    b++;
                    if(b==n){
                        break;
                    }
                }
                if(b==n){
                    break;
                }
                for (int i = m-1; i >= 0; i--) {
                    ar[b] = i+1;
                    b++;
                    if(b==n){
                        break;
                    }
                }

                if(b==n){
                    break;
                }
            }

            for (int i = 0; i < n; i++) {
                ans[ar[i]-1] += array[i].a;
            }

            for (int i = 0; i < m-1; i++) {
                if(Math.abs(ans[i]- ans[i+1])>x){
                    out.println(""NO"");
                    return;
                }
            }
            out.println(""YES"");

            int[] answer = new int[n];

            for (int i = 0; i < n; i++) {
                answer[array[i].b] = ar[i];
            }

            for (int i = 0; i < n; i++) {
                out.print(answer[i]+"" "");
            }
            out.println();

        }
    }

    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;
        }

        @Override
        public boolean equals(Object o){
            if(o instanceof answer){
                answer c = (answer)o;
                return a == c.a && b == c.b;
            }
            return false;
        }
    }

    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);
        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());
        }

    }
}
","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, m, x;
            n = in.nextInt();
            m = in.nextInt();
            x = in.nextInt();

            int[] arr = new int[n];
            answer[] array = new answer[n];
            int[] ar = new int[n];

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
                array[i] = new answer(arr[i],i);
            }

            long[] ans = new long[m];
            Arrays.sort(array);


            int a = 0 , b = 0;
            while(true){
                for (int i = 0; i < m; i++) {
                    ar[b] = i+1;
                    b++;
                    if(b==n){
                        break;
                    }
                }
                if(b==n){
                    break;
                }
                for (int i = m-1; i >= 0; i--) {
                    ar[b] = i+1;
                    b++;
                    if(b==n){
                        break;
                    }
                }

                if(b==n){
                    break;
                }
            }

            for (int i = 0; i < n; i++) {
                ans[ar[i]-1] += array[i].a;
            }

            for (int i = 0; i < m-1; i++) {
                if(Math.abs(ans[i]- ans[i+1])>x){
                    out.println(""NO"");
                    return;
                }
            }
            out.println(""YES"");

            int[] answer = new int[n];

            for (int i = 0; i < n; i++) {
                answer[array[i].b] = ar[i];
            }

            for (int i = 0; i < n; i++) {
                out.print(answer[i]+"" "");
            }
            out.println();

        }
    }

    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;
        }

        @Override
        public boolean equals(Object o){
            if(o instanceof answer){
                answer c = (answer)o;
                return a == c.a && b == c.b;
            }
            return false;
        }
    }

    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);
        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());
        }

    }
}
",1,Plagiarised
b2590225,fdcbdf85,"//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();

        }
    }
}
","import java.io.*;
import java.util.*;
import java.lang.*;

public class B{
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    static long MOD = (long) (1e9 + 7);
    //    static long MOD = 998244353;
    static long MOD2 = MOD * MOD;
    static FastReader sc = new FastReader();
    static int pInf = Integer.MAX_VALUE;
    static int nInf = Integer.MIN_VALUE;
    static long ded = (long)(1e17)+9;
    public static void main(String[] args) throws Exception {
        int test = 1;
        test = sc.nextInt();
        for (int i = 1; i <= test; i++){
//            out.print(""Case #""+i+"": "");
            solve();
        }
        out.flush();
        out.close();
    }
    static void solve(){
        int n = sc.nextInt();
        int m = sc.nextInt();
        int diff = sc.nextInt();
        ArrayList<Pair> A = new ArrayList<>();
        for(int i=  0; i < n; i++){
            int x = sc.nextInt();
            A.add(new Pair(x,i));
        }
        int[] sum = new int[m];
        int[] ans = new int[n];
        Collections.sort(A);
        for(int i=  0; i < n; i++){
            int idx = i%m;
            sum[idx] += A.get(i).x;
            ans[A.get(i).y] = idx+1;
        }
        ruffleSort(sum);
        if(Math.abs(sum[0]-sum[sum.length-1])>diff){
            out.println(""NO"");
            return;
        }
        out.println(""YES"");
        for(int i = 0; i < n; i++){
            out.print(ans[i]+"" "");
        }
        out.println();
    }
    static class Pair implements Comparable<Pair> {
        int x;
        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*(o.y-this.y);
            }
            return this.x-o.x;
        }

        @Override
        public String toString() {
            return ""Pair{"" + ""x="" + x + "", y="" + y + '}';
        }

        public boolean equals(Pair o){
            return this.x==o.x&&this.y==o.y;
        }
    }
    public static long mul(long a, long b) {
        return ((a % MOD) * (b % MOD)) % MOD;
    }
    public static long add(long a, long b) {
        return ((a % MOD) + (b % MOD)) % MOD;
    }
    public static long c2(long n) {
        if ((n & 1) == 0) {
            return mul(n / 2, n - 1);
        } else {
            return mul(n, (n - 1) / 2);
        }
    }
    //Shuffle Sort
    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); int temp= a[oi];
            a[oi] = a[i];
            a[i] = temp;
        }
        Arrays.sort(a);
    }
    //Brian Kernighans Algorithm
    static long countSetBits(long n) {
        if (n == 0) return 0;
        return 1 + countSetBits(n & (n - 1));
    }
    //Euclidean Algorithm
    static long gcd(long A, long B) {
        if (B == 0) return A;
        return gcd(B, A % B);
    }
    //Modular Exponentiation
    static long fastExpo(long x, long n) {
        if (n == 0) return 1;
        if ((n & 1) == 0) return fastExpo((x * x) % MOD, n / 2) % MOD;
        return ((x % MOD) * fastExpo((x * x) % MOD, (n - 1) / 2)) % MOD;
    }
    //AKS Algorithm
    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 <= Math.sqrt(n); i += 6)
            if (n % i == 0 || n % (i + 2) == 0) return false;
        return true;
    }
    public static long modinv(long x) {
        return modpow(x, MOD - 2);
    }
    public static long modpow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        long x = modpow(a, b / 2);
        x = (x * x) % MOD;
        if (b % 2 == 1) {
            return (x * a) % MOD;
        }
        return 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;
        }
    }
}",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
04df7bb8,1ea771ea,"										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 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;
    }
}
",1,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
77d22fc3,d3528b2a,"import java.io.*;
import java.util.*;

public class A {
    //--------------------------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;
        }
    }
    //-----------------------------------------------------------------------//
    static int t = 0;
    //---------------------------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);
    static long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
    static long ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
    static long mod = 1000000007;
    //-----------------------------------------------------------------------//

    //--------------------------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""));
        }
    }
    //-----------------------------------------------------------------------//
    static int tt = 0;
    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        t = sc.ni();while(t-->0) {
            tt++;
            solve();
        }


        w.close();
    }

    static void solve() throws IOException {
        int n = sc.ni();
        String s1 = sc.ns();
        String s2 = sc.ns();
        char[] strr = s1.toCharArray();
        char[] strr2 = s2.toCharArray();
        HashSet<Integer> lia = new HashSet<>(), lib = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr[i]=='1') lia.add(i);
            else lib.add(i);
        }
        HashSet<Integer> liaa = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr2[i]=='1') liaa.add(i);
        }
        if(!(lia.size() == liaa.size() || lib.size()+1 == liaa.size())) {
            w.p(-1);
            return;
        }
        int ac = 0, bc = 0;
        for(int i: lia) {
            if(liaa.contains(i)) ac++;
        }
        bc = liaa.size()-ac;
        if(lia.size() == liaa.size() && lia.size() == ac) {
            w.p(0);
            return;
        }

        int nac = lia.size()-ac;
        int nbc = lib.size()-bc;

        long ansa = ac != 0 && (ac-1 == nbc)? Math.abs(ac-1+nbc): ima;
        long ansb = nac != 0 && (nac-1 == bc-1)? Math.abs(nac-1+bc): ima;


        if(ansa == ima && ansb == ima) {
            w.p(-1);
            return;
        }

        w.p(Math.min(ansa, ansb)+1);
    }

}","import java.io.*;
import java.util.*;

public class A {
    //--------------------------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;
        }
    }
    //-----------------------------------------------------------------------//
    static int t = 0;
    //---------------------------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);
    static long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
    static long ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
    static long mod = 1000000007;
    //-----------------------------------------------------------------------//

    //--------------------------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""));
        }
    }
    //-----------------------------------------------------------------------//
    static int tt = 0;
    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        t = sc.ni();while(t-->0) {
            tt++;
            solve();
        }


        w.close();
    }

    static void solve() throws IOException {
        int n = sc.ni();
        String s1 = sc.ns();
        String s2 = sc.ns();
        char[] strr = s1.toCharArray();
        char[] strr2 = s2.toCharArray();
        HashSet<Integer> lia = new HashSet<>(), lib = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr[i]=='1') lia.add(i);
            else lib.add(i);
        }
        HashSet<Integer> liaa = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr2[i]=='1') liaa.add(i);
        }
        if(!(lia.size() == liaa.size() || lib.size()+1 == liaa.size())) {
            w.p(-1);
            return;
        }
        int ac = 0, bc = 0;
        for(int i: lia) {
            if(liaa.contains(i)) ac++;
        }
        bc = liaa.size()-ac;
        if(lia.size() == liaa.size() && lia.size() == ac) {
            w.p(0);
            return;
        }

        int nac = lia.size()-ac;
        int nbc = lib.size()-bc;

        long ansa = ac != 0 && (ac-1 == nbc)? Math.abs(ac-1+nbc): ima;
        long ansb = nac != 0 && (nac-1 == bc-1)? Math.abs(nac-1+bc): ima;


        if(ansa == ima && ansb == ima) {
            w.p(-1);
            return;
        }

        w.p(Math.min(ansa, ansb)+1);
    }

}",1,Plagiarised
8f31b279,d2f74dfc,"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.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 m=sc.nextInt();
            int x=sc.nextInt();
            int[] a=new int[n];
            int[] c=new int[n];
            Map<Integer,Stack<Integer>> mp=new HashMap<>();
            for(int i=0;i<n;i++){
                a[i]=sc.nextInt();
                //c[i]=a[i];
                if(mp.containsKey(a[i])){
                    Stack<Integer> l=mp.get(a[i]);
                    l.push(i);
                    mp.put(a[i],l);
                }
                else{
                    Stack<Integer> l=new Stack<>();
                    l.push(i);
                    mp.put(a[i],l);
                }
            }
            Arrays.sort(a);
            int[] b=new int[n];
           
            int cn=1;
            for(int i=0;i<n;i++){
                cn=cn%m;
                Stack<Integer> li=mp.get(a[i]);
                if(!li.isEmpty()){
                    int val=li.peek();
                    b[val]=cn+1;
                    c[i]+=a[i];
                    li.pop();
                    mp.put(a[i],li);
                }
                cn++;
            }
            int mv=c[0]-c[n-1];
            if(Math.abs(mv)>x) System.out.println(""NO"");
            else {
                System.out.println(""YES"");
                for(int i=0;i<n;i++){
                    System.out.print(b[i]+"" "");
                }
                System.out.println();
            }
        }
    }
    
}",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
8a729537,abd16ff0,"
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.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,Plagiarised
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,Plagiarised
0fd5b95a,6490bbe8,"//package codeforces;
import java.io.PrintWriter;
import java.util.*;
public class codeforces {
	static int dp[][]=new int[5001][5001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);  
		PrintWriter out=new PrintWriter(System.out);
        int t=1;
        for(int tt=0;tt<t;tt++) {
        	int n=s.nextInt();
        	int a[]=new int[n];
        	ArrayList<Integer> z=new ArrayList<>();
        	ArrayList<Integer> o=new ArrayList<>();
        	for(int i=0;i<n;i++) {
        		a[i]=s.nextInt();
        		if(a[i]==1) {
        			o.add(i);
        		}else {
        			z.add(i);
        		}
        	}
        	for(int i=0;i<5001;i++) {
        		Arrays.fill(dp[i], -1);
        	}
        	System.out.println(sol(0,0,z,o));
        }
        out.close();
	    s.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 sortcol(int a[][],int c) {
		Arrays.sort(a, (x, y) -> {
			if (x[c] != y[c]) return(int)( x[c] - y[c]);
			return (int)-(x[1]+x[2] - y[1]-y[2]);
		});
	}
	static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
	public static int sol(int i,int j,ArrayList<Integer> z,ArrayList<Integer> o) {
		if(j==o.size()) {
			return 0;
		}
		int h=z.size()-i;
		int l=o.size()-j;
		if(i==z.size()) {
			return 10000000;
		}
		if(dp[i][j]!=-1) {
			//System.out.println(i+"" ""+j);
			return dp[i][j];
		}
		int ans1=sol(i+1,j,z,o);
		int ans2=sol(i+1,j+1,z,o)+Math.abs(z.get(i)-o.get(j));
		dp[i][j]=Math.min(ans1, ans2);
		return dp[i][j];
	}
}

","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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
0b91922c,71a4f6d2,"
import java.util.*;
import java.lang.*;
import java.io.*;   
import java.math.*;
public class Prac{     
    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 ni() {
            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 nl() {
            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[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        } 
        public int[] nia1(int n) {
            int a[] = new int[n+1];
            for (int i = 1; i <=n; i++) {
                a[i] = ni();
            }
            return a;
        } 
        public long[] nla(int n) {
            long a[] = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nl();
            }
            return a;
        } 
        public long[] nla1(int n) {
            long a[] = new long[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = nl();
            }
            return a;
        } 
        public Long[] nLa(int n) {
            Long a[] = new Long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nl();
            }
            return a;
        } 
        public Long[] nLa1(int n) {
            Long a[] = new Long[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = nl();
            }
            return a;
        } 
        public Integer[] nIa(int n) {
            Integer a[] = new Integer[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        } 
        public Integer[] nIa1(int n) {
            Integer a[] = new Integer[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = ni();
            }
            return a;
        } 
        public String rs() {
            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;
        } 
    }
    public static class Key {
        private final int x, y;
        public Key(int x, int y) {
            this.x = x; this.y = y;
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }
        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }
    }
    static class Pair{
            int x,y;
            Pair(int a,int b){
                    x=a;y=b;
            }
//            @Override
//            public int compareTo(Pair p) {
//                    if(x==p.x) return y-p.y;
//                    return x-p.x;
//            }
    }
    static void shuffleArray(long temp[]){
        int n = temp.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            long tmp = temp[i];
            int randomPos = i + rnd.nextInt(n-i);
            temp[i] = temp[randomPos];
            temp[randomPos] = tmp;
        }   
    }
    static int gcd(int a,int b){ return b==0?a:gcd(b,a%b);}
    //static long lcm(long a,long b){return (a/gcd(a,b))*b;}
    static PrintWriter w = new PrintWriter(System.out);
    static long mod1=998244353L,mod=1000000007;
    //static int r[]={0,1,0,-1}, c[]={1,0,-1,0};
    static int[] nextG(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ng[] = new int[n];
        for(int i = 0 ; i < n ; i++){
            while(!s.isEmpty() && arr[s.peek()] <= arr[i]){
                ng[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ng[s.pop()] = n;
        }
        return ng;
    }
    static int[] nextS(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ns[] = new int[n];
        for(int i = 0 ; i < n ; i++){
            while(!s.isEmpty() && arr[s.peek()] >= arr[i]){
                ns[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ns[s.pop()] = n;
        }
        return ns;
    }
    static int[] prevG(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int pg[] = new int[n];
        for(int i = n-1 ; i >= 0 ; i--){
            while(!s.isEmpty() && arr[s.peek()] <= arr[i]){
                pg[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            pg[s.pop()] = -1;
        }
        return pg;
    }
    static int[] prevS(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ps[] = new int[n];
        for(int i = n-1 ; i >= 0 ; i--){
            while(!s.isEmpty() && arr[s.peek()] >= arr[i]){
                ps[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ps[s.pop()] = -1;
        }
        return ps;
    }
    public static void main(String [] args){
        InputReader sc=new InputReader(System.in); 
        
        int n = sc.ni();
        int arr [] = sc.nia(n);
        int ng[] = nextG(arr);
        int ns [] = nextS(arr);
        int pg[] = prevG(arr);
        int ps[] = prevS(arr);
        int ans[]=new int[n];
        
        Arrays.fill(ans,10000000);
        ans[n-1] = 0;
        for(int i = n -1 ; i >= 0 ; i --){
            if(ns[i] != n){
                ans[i] = Math.min(ans[i] , ans[ns[i]]+1);
            }
            if(ng[i] != n){
                ans[i] = Math.min(ans[i] , ans[ng[i]]+1);
            }
            if(pg[i] != -1){
                ans[pg[i]] = Math.min(ans[pg[i]] , ans[i]+1);
            }
            if(ps[i] != -1){
                ans[ps[i]] = Math.min(ans[ps[i]] , ans[i]+1);
            }
        }
        
        w.println(ans[0]);
        w.close();
    }
}","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);

        }

    }
}

",0,Non-plagiarised
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,Non-plagiarised
00c0b82a,1ea771ea,"import java.util.*;
public class E1547 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        for(int i = 0; i < q; i++){
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[][] t = new int[k][2];
            for(int j = 0; j < k; j++){
                t[j][0] = sc.nextInt();//room
            }
            for(int j = 0; j < k; j++){
                t[j][1] = sc.nextInt();//air
            }
            long[] left = new long[n];
            long[] right = new long[n];
            long tmp = Integer.MAX_VALUE;
            long[] max =new long[n];
            for(int j = 0; j < n; j++){
                max[j] = Integer.MAX_VALUE;
            }
            for (int j = 0; j < k; j++) {
                max[t[j][0]-1] = t[j][1];
            }
            for (int j = 1; j <= n; j++) {
                tmp = Math.min(tmp+1, max[j-1]);
                left[j-1] = tmp;
            }
            for(int j = n; j >= 1; j--){
                tmp = Math.min(tmp+1, max[j-1]);
                right[j-1] = tmp;
            }
            for(int j = 0; j < n; j++){
                System.out.print(Math.min(left[j], right[j]) + "" "");
            }
            System.out.println();
        }
    }
}
","
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;
    }
}
",0,Non-plagiarised
73f57af1,9a20c823,"/*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.util.*;
import java.io.*;

public class Parsas_Humongous_Tree {

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return 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 shuffle(int[] a) {
		Random r = new Random();

		for (int i = 0; i <= a.length - 2; i++) {
			int j = i + r.nextInt(a.length - i);

			swap(a, i, j);
		}
	}

	public static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader t = new FastReader();
		PrintWriter o = new PrintWriter(System.out);
		int test = t.nextInt();

		while (test-- > 0) {
			int n = t.nextInt();
			long[][] cost = new long[n][2];
			List<Integer>[] graph = new ArrayList[n];
			dp = new long[n][2];

			for (int i = 0; i < n; ++i) {
				cost[i][0] = t.nextLong();
				cost[i][1] = t.nextLong();
				graph[i] = new ArrayList<>();
			}

			for (int i = 0; i < n - 1; ++i) {
				int x = t.nextInt() - 1;
				int y = t.nextInt() - 1;

				graph[x].add(y);
				graph[y].add(x);
			}

			o.println(Math.max(dfs(graph, cost, 0, 0, -1), dfs(graph, cost, 0, 1, -1)));
		}

		o.flush();
		o.close();
	}

	private static long[][] dp;

	private static long dfs(List<Integer>[] graph, long[][] cost, int u, int j, int par) {
		if (dp[u][j] != 0)
			return dp[u][j];

		for (int v : graph[u])
			if (v != par) {
				long c1 = Math.abs(cost[u][j] - cost[v][0]) + dfs(graph, cost, v, 0, u);
				long c2 = Math.abs(cost[u][j] - cost[v][1]) + dfs(graph, cost, v, 1, u);
				dp[u][j] += Math.max(c1, c2);
			}

		return dp[u][j];
	}
}",0,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
4552d8a0,d3a96420,"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 D_Blue_Red_Permutation{
    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 array[]= new long[n];
        for(int i=0;i<n;i++){
            array[i]=s.nextLong();
        }
        String str=s.nextToken();
        ArrayList<Long> red = new  ArrayList<Long>();
        ArrayList<Long> blue = new  ArrayList<Long>();
        for(int i=0;i<n;i++){
            if(str.charAt(i)=='R'){
                red.add(array[i]);
            }
            else{
                blue.add(array[i]);
            }
        }
        Collections.sort(blue);
        int check1=0;
        for(int i=0;i<blue.size();i++){
            int yo=i+1;
            if(blue.get(i)<yo){
                check1=1;
                break;
            }
        }
        Collections.sort(red,Collections.reverseOrder());
        int number=n;
        int check2=0;
        for(int i=0;i<red.size();i++){
             if(red.get(i)>number){
                 check2=1;
                 break;
             }
             number--;
        }
        if(check1==0 && check2==0){
            res.append(""YES\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.*;

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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Plagiarised
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,Plagiarised
49e94e7e,f3d7ce08,"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 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,Non-plagiarised
1f748faf,851fafb6,"/*
    JAI MATA DI
 */

import java.util.*;

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; 
		    } 
		}
	 
	  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 int UB(long[] arr , long find , int l , int r) {
		while(l<=r) {
			int m = (l+r)/2;
			if(arr[m]<find) l = m+1;
			else r = m-1;
		}
		return l;
	}
	static int LB(long[] arr , long find,int l ,int r ) {
		while(l<=r) {
			int m = (l+r)/2;
			if(arr[m] > find) r = m-1;
			else l = m+1;
		}
		return r;
	}
	static int UB(int[] arr , long find , int l , int r) {
		while(l<=r) {
			int m = (l+r)/2;
			if(arr[m]<find) l = m+1;
			else r = m-1;
		}
		return l;
	}
	static int LB(int[] arr , long find,int l ,int r ) {
		while(l<=r) {
			int m = (l+r)/2;
			if(arr[m] > find) r = m-1;
			else l = m+1;
		}
		return r;
	}
	 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 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[][] 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 FR sc = new FR();
	 static StringBuilder sb = new StringBuilder();
	 public static void main(String args[]) {
		
		 int tc = 1;
		  tc = sc.nextInt();
		 
		 
		 while(tc-->0) {
			 TEST_CASE();
			 
		 }
		 
	    System.out.println(sb);
	 }


	 static void TEST_CASE() {
		 int n = sc.nextInt(); ;
		 int[] arr = new int[n];
		 for(int i =0 ; i<n;i++) {
			 arr[i] = sc.nextInt();
		 } 
		 boolean cond = false;
		
		 Set<Integer> set = new HashSet<>();
		 set.add(0);
		 for(int i =0 ; i<n ; i++) {
			 ArrayList<Integer> al = new ArrayList<>(set);
			 for(int e:al) {
				 int num = e+arr[i];
				 if(set.contains(num)) {
					 cond = true;
					 break;
				 }
				 set.add(num);
			 }
		 }
		 if(cond) System.out.println(""YES"");
		 else System.out.println(""NO"");
	 }

	 
}







","// package codeforce.cfGR15;

import java.io.PrintWriter;
import java.util.*;

public class D {
    //    MUST SEE BEFORE SUBMISSION
//    check whether int part would overflow or not, especially when it is a * b!!!!

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
//        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();
        }
        Set<Integer> set = new HashSet<>();
        for(int x : arr) {
            if (x == 0){
                out.println(""YES"");
                return;
            }else if (set.contains(x) || set.contains(-x)){
                out.println(""YES"");
                return;
            }
            set.add(x);
        }
        for (int i = 0; i < n; i++) {
            if (dfs(0, i, arr, 0)){
                out.println(""YES"");
                return;
            }
        }
        out.println(""NO"");
    }
    static boolean dfs(int idx, int need, int[] arr, int cur){
        if (cur == arr[need]) return true;
        if (idx == arr.length) return false;
        if (idx == need) return dfs(idx + 1, need, arr, cur);
        return dfs(idx + 1, need, arr, cur + arr[idx]) |
                dfs(idx + 1, need, arr, cur - arr[idx]) |
                dfs(idx + 1, need, arr, cur);
    }
}
",0,Non-plagiarised
08cf0478,0f14b12d,"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 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();
      }
   
    }
     }

",0,Non-plagiarised
584b0e9e,d9199dfd,"
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.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();  
    }
    
}  
",1,Plagiarised
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,Plagiarised
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,Plagiarised
968c1e7e,a4e1511a,"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());
		}
	}




}","//package Practice;
import java.io.*;
import java.util.*;


public class codefor
{
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        }
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                }
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return 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(),k=sc.nextInt(),i=0;
			long t[]=new long[n];
			int a[]=new int[k];
			for(i=0;i<k;i++)
				a[i]=sc.nextInt()-1;
			for(i=0;i<k;i++)
				t[a[i]]=sc.nextLong();
			long ans[]=new long[n];
			PriorityQueue<Long> pq=new PriorityQueue<>();
			for(i=0;i<n;i++)
			{
				if(t[i]!=0)
					pq.add(t[i]-i);
				if(pq.size()!=0)
				{
					ans[i]=pq.peek()+i;
				}
			}
			pq.clear();
			for(i=n-1;i>=0;i--)
			{
				if(t[i]!=0)
					pq.add(t[i]+i);
				if(pq.size()!=0)
				{
					long val=pq.peek()-i;
					if(ans[i]==0)
						ans[i]=val;
					else 
						ans[i]=Math.min(val, ans[i]);
				}
				}
			pq.clear();
			for(i=0;i<n;i++)
				System.out.print(ans[i]+"" "");
			System.out.println();
		}
	}

}











",0,Non-plagiarised
69b2fd22,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,Non-plagiarised
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,Plagiarised
29bbcd8b,d4779c71,"
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.Stack;
import java.util.StringTokenizer;

public class D {

   private static final String INPUT_FILE_PATH = """";

   void solve() {
      int n = in.nextInt();
      int[] h = new int[n];
      for (int i = 0; i < n; i++) h[i] = in.nextInt();

      Stack<Integer> increasing = new Stack();
      Stack<Integer> increasingIndices = new Stack();
      Stack<Integer> decreasing = new Stack();
      Stack<Integer> decreasingIndices = new Stack();
      increasing.push(h[0]);
      increasingIndices.push(0);
      decreasing.push(h[0]);
      decreasingIndices.push(0);

      int[] dp = new int[n];
      dp[0] = 0;

      for (int i = 1; i < n; i++) {
         dp[i] = dp[i - 1] + 1;

         while (!increasing.isEmpty() && increasing.peek() > h[i]) {
            dp[i] = Math.min(dp[i], 1 + dp[increasingIndices.peek()]);

            increasing.pop();
            increasingIndices.pop();
         }
         while (!decreasing.isEmpty() && decreasing.peek() < h[i]) {
            dp[i] = Math.min(dp[i], 1 + dp[decreasingIndices.peek()]);

            decreasing.pop();
            decreasingIndices.pop();
         }

         if (!increasing.isEmpty()) {
            dp[i] = Math.min(dp[i], 1 + dp[increasingIndices.peek()]);
         }
         if (!decreasing.isEmpty()) {
            dp[i] = Math.min(dp[i], 1 + dp[decreasingIndices.peek()]);
         }

         if (!increasing.isEmpty() && increasing.peek() == h[i]) {
            increasing.pop();
            increasingIndices.pop();
         }
         if (!decreasing.isEmpty() && decreasing.peek() == h[i]) {
            decreasing.pop();
            decreasingIndices.pop();
         }

         increasing.push(h[i]);
         increasingIndices.push(i);
         decreasing.push(h[i]);
         decreasingIndices.push(i);
      }
      out.println(dp[n - 1]);
   }

   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();
   }

}
","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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
312d9460,e7024f3e,"//https://codeforces.com/contest/1547/problem/E
//E. Air Conditioners
import java.util.*;
import java.io.*;
public class CF_1547_E{
	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, st1;

		int q = Integer.parseInt(br.readLine());
		while(q-->0){
			br.readLine();
			st = new StringTokenizer(br.readLine());
			int n = Integer.parseInt(st.nextToken());
			int k = Integer.parseInt(st.nextToken());

			PriorityQueue<Pair> right_side = new PriorityQueue<Pair>();

			int at[] = new int[n+1];
			st = new StringTokenizer(br.readLine());
			st1 = new StringTokenizer(br.readLine());

			for(int i=0;i<k;i++){
				int a = Integer.parseInt(st.nextToken());
				int t = Integer.parseInt(st1.nextToken());
				at[a] = t;
				right_side.add(new Pair(a, t));
			}

			long left= Integer.MAX_VALUE;

			for(int i=1;i<=n;i++){

				while(right_side.isEmpty()==false && right_side.peek().a<=i){
					Pair temp = right_side.poll();
					if(temp.t - temp.a <= left)
						left = temp.t - temp.a;
				}

				if(at[i]!=0){
					if(at[i]-i <=left)
						left = at[i] - i;
				}

				long ans = left+i;

				if(!right_side.isEmpty()){
					Pair right = right_side.peek();
					ans = Math.min(ans, right.t+right.a-i);
				}

				sb.append(ans+"" "");
			}
			sb.append(""\n"");
		}

		pw.print(sb);
		pw.flush();
		pw.close();
	}
}

class Pair implements Comparable<Pair>{
	int a, t;
	Pair(int a, int t){
		this.a = a;
		this.t = t;
	}
	public int compareTo(Pair A){
		return (this.a+this.t-A.a-A.t);
	}
}","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    static String solve(int n, int k, int[] a, int[] t) {
        Pair[] pairs = new Pair[k];
        for (int i = 0; i < k; i++) {
            pairs[i] = new Pair(a[i], t[i]);
        }
        Arrays.sort(pairs);
        int[] ret = new int[n + 1];
        Arrays.fill(ret, Integer.MAX_VALUE);

        int pIdx = 0;
        int ct = pairs[pIdx].t;
        ret[pairs[pIdx].a] = ct;
        for (int i = pairs[pIdx].a + 1; i <= n; i++) {
            ct++;
            if (pIdx + 1 < k && pairs[pIdx + 1].a == i) {
                if (ct > pairs[pIdx + 1].t) {
                    ct = pairs[pIdx + 1].t;
                }
                pIdx++;
            }
            ret[i] = ct;
            // System.out.println(Arrays.toString(ret));
        }
        // System.out.println();
        pIdx = k - 1;
        ct = pairs[pIdx].t;
        for (int i = pairs[pIdx].a - 1; i > 0; i--) {
            ct++;
            if (pIdx - 1 >= 0 && pairs[pIdx - 1].a == i) {
                if (ct > pairs[pIdx - 1].t) {
                    ct = pairs[pIdx - 1].t;
                }
                pIdx--;
            }
            if (ct < ret[i]) {
                ret[i] = ct;
            }
            // System.out.println(Arrays.toString(ret));
        }
        StringBuilder out = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            out.append(ret[i]).append("" "");
        }
        // System.out.println();
        // System.out.println();
        return out.toString();
    }

    static class Pair implements Comparable<Pair> {
        int a, t;

        public Pair(int a, int t) {
            this.a = a;
            this.t = t;
        }

        @Override public int compareTo(Pair o) {
            return this.a - o.a;
        }
    }


    public static void main(String[] args) throws IOException {
        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) {
            st = new StringTokenizer(br.readLine());
            st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(br.readLine());
            int[] a = new int[k];
            for (int i = 0; i < k; i++) {
                a[i] = Integer.parseInt(st.nextToken());
            }
            st = new StringTokenizer(br.readLine());
            int[] t = new int[k];
            for (int i = 0; i < k; i++) {
                t[i] = Integer.parseInt(st.nextToken());
            }

            out.append(solve(n, k, a, t)).append(""\n"");
        }
        System.out.println(out);
    }
}",0,Non-plagiarised
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,Non-plagiarised
2b7b2d45,a0b406e6,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;



public class D_1552 {
	 static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;
	 
	        public FastReader()
	        {
	            br = new BufferedReader(
	                new InputStreamReader(System.in));
	        }
	 
	        String next()
	        {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	 
	        long nextLong() { return 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 fs = new FastReader();
        int tc = fs.nextInt();
        
        while(tc-- > 0)
        {   boolean flag=false;
        	int n=fs.nextInt();
            int[] ar=new int[n];
            for(int i=0;i<n;i++)
            {ar[i]=fs.nextInt();}
        	for(int i=1;i<Math.pow(3, n);i++)
        	{
        		int copy=i;
        		int sum=0;
        		for(int j=0;j<n;j++)
        		{
        			int rem=copy%3;
        			sum+=rem==0?0:rem==1?ar[j]:-ar[j];
        			copy=copy/3;
        		}
        		if(sum==0)
        			{System.out.println(""yes"");
        			flag=true;
        			break;}
        			}
        	       if(flag==false)
        			System.out.println(""no"");
        	}
        
        }
        
    
    
}","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;
		}

	}
}",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
8d9871a9,eb6cfca7,"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.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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
317baeaf,e17c5159,"import java.util.*;
import java.io.*;

public class Main {
  public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		StringTokenizer st;

		int t = Integer.parseInt(br.readLine());
		while (t --> 0) {
			int n = Integer.parseInt(br.readLine());
			String a = br.readLine();
			String b = br.readLine();
			int alit = 0;
			int blit = 0;

			int ans = Integer.MAX_VALUE;

			for (int i = 0; i < n; i++) {
				if (a.charAt(i) == '1') alit++;
				if (b.charAt(i) == '1') blit++;
			}

			if (alit == blit) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) != b.charAt(i)) count++;
				ans = Math.min(count, ans);
			}
			
			if (alit == n - blit + 1) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) == b.charAt(i)) count++;
				ans = Math.min(ans, count);
			}

			if (ans == Integer.MAX_VALUE) {
				pw.println(""-1"");
			} else {
				pw.println(ans);
			}
		}

		pw.close();
  }
}","import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int t=Integer.valueOf(sc.nextLine());
        while (t-->0){
            int n=Integer.valueOf(sc.nextLine());
            int ans=100001;
            String a=sc.nextLine();
            String b=sc.nextLine();
            HashSet<Integer> listb=new HashSet<>();
            ArrayList<Integer> lista=new ArrayList<>();
            for (int i=0;i<n;i++){
                if(a.charAt(i)=='1') lista.add(i);
                if(b.charAt(i)=='1') listb.add(i);
            }
            int num=0;
            for (int i=0;i<lista.size();i++){
                if(listb.contains(lista.get(i))) num++;
            }
            //第一种情况
            if(lista.size()==listb.size()){
                ans=Math.min(ans,(listb.size()-num)*2);
            }
            //第二种情况 n-lista.size() listb.size()-num
            if(listb.size()-(n-lista.size())==1){
                ans=Math.min(ans,(num-1)*2+1);
            }
            System.out.println((ans==100001)?-1:ans);
        }
    }
}

",0,Non-plagiarised
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,Non-plagiarised
9291ca83,d6fb3b9e,"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.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,Non-plagiarised
b9595381,c4ca2ff3,"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;
    	}
    }
 
      



","/* 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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
18e2441c,24b20554," 

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());
		}
	}
}

","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);
    }
}
",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
6c4ac8d3,829d2024,"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;
            }
        }
    }

}
            
        ","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,Plagiarised
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,Plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
065e0cbd,9b449b4f,"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 int ask(int i){
        FastReader sc = new FastReader();
        System.out.println(""? "" + (i+1));
        System.out.flush();
        int x = sc.nextInt();
        return x - 1;
    }
	public static void main(String[] args) {
		FastReader sc = new FastReader();
		int t = sc.nextInt();
		int inf = 1000000007;
		while(t-->0){
		    int n = sc.nextInt();
		    int ans[] = new int[n];
		    for(int i=0;i<n;i++){
		        if(ans[i] == 0){
		            ArrayList<Integer> cycle = new ArrayList<Integer>();
    		        int x = ask(i), y = ask(i);
    		        cycle.add(y);
    		        while(y != x){
    		            y = ask(i);
    		            cycle.add(y);
    		        }  
    		        for(int j=0;j<cycle.size();j++){
    		            ans[cycle.get(j)] = cycle.get((j+1)%cycle.size()) + 1;
    		        }
		        }
		    }
		    
		    System.out.print(""! "");
		    for(int i=0;i<n;i++) System.out.print(ans[i] + "" "");
		    System.out.println();
		}
	}
}
","/*
        ""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[] permutation = new int[n];
        Arrays.fill(permutation, -1);

        // there may be multiple cycles in the given permutation
        for (int i = 0; i < n; i++) {
            if (permutation[i] == -1) { // ith permutation value is not found yet
                // so we find all values of permutation having i in their cycle
                // for that we always ask(i) so that we can get all values in that cycle
                List<Integer> cycle = new ArrayList<>();

                int startCycleValue = ask(i + 1);
                int currValueAt = ask(i + 1);

                cycle.add(currValueAt);
                while (currValueAt != startCycleValue) {
                    currValueAt = ask(i + 1);
                    cycle.add(currValueAt);
                }

                int m = cycle.size();
                for (int j = 0; j < m; j++) {
                    permutation[cycle.get(j)] = cycle.get((j + 1) % m);
                }
            }
        }

        out.println(""! "");
        for (int i = 0; i < n; i++) {
            out.print((permutation[i] + 1) + "" "");
        }
        out.println();
        out.flush();
    }

    private static int ask(int i) {
        out.println(""? "" + i + "" "");
        out.flush();
        int value = sc.nextInt();
        return value - 1;
    }


    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;
        }
    }
}",0,Non-plagiarised
53d782a0,5769b7b3,"import java.io.*;
import java.util.*;

public class B {
    //--------------------------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);
    static long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
    static int ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
    static long mod = 1000000007;
    //-----------------------------------------------------------------------//

    //--------------------------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""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


        w.close();
    }

    static void solve() throws IOException {
        int n = sc.ni();
        long k = sc.nl();
        Long[] arr = new Long[n];
        for(int i = 0; i < n; i++) arr[i] = sc.nl();
        Arrays.sort(arr);
        long sum = 0;
        for(int i = 0; i < n; i++) {
            sum += arr[i];
        }
        if(sum <= k) {
            w.p(0);
            return;
        }


        long cont = 0;
        long min = sum-k;
        for(int i = n-1; i >= 0; i--) {
            cont += arr[i];
            long psum = sum-cont;


            if(psum <= k) {
                long extra = k-psum;
                if(arr[0]*(n-i)<=extra) {
                    min = Math.min(min, n-i);
                    continue;
                }

                if(i == 0) {
                    long q = k/n;
                    long ans = arr[0]-q+n-1;
                    min = Math.min(min, ans);
                    continue;
                }
                extra += arr[0];
                long q = extra/(n-i+1);
                long ans = arr[0]-q+n-i;
                min = Math.min(min, ans);

            } else {
                long toRem = psum-k-arr[0];
                long q = (long)Math.ceil(toRem/(n-i+1.0));
                long ans = q+arr[0]+n-i;
                min = Math.min(min, ans);
            }
        }

        w.p(min);
    }

}","import java.io.*;
import java.util.*;

public class B {
    //--------------------------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);
    static long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
    static int ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
    static long mod = 1000000007;
    //-----------------------------------------------------------------------//

    //--------------------------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""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


        w.close();
    }

    static void solve() throws IOException {
        int n = sc.ni();
        long k = sc.nl();
        Long[] arr = new Long[n];
        for(int i = 0; i < n; i++) arr[i] = sc.nl();
        Arrays.sort(arr);
        long sum = 0;
        for(int i = 0; i < n; i++) {
            sum += arr[i];
        }
        if(sum <= k) {
            w.p(0);
            return;
        }


        long cont = 0;
        long min = sum-k;
        for(int i = n-1; i >= 0; i--) {
            cont += arr[i];
            long psum = sum-cont;


            if(psum <= k) {
                long extra = k-psum;
                if(arr[0]*(n-i)<=extra) {
                    min = Math.min(min, n-i);
                    continue;
                }

                if(i == 0) {
                    long q = k/n;
                    long ans = arr[0]-q+n-1;
                    min = Math.min(min, ans);
                    continue;
                }
                extra += arr[0];
                long q = extra/(n-i+1);
                long ans = arr[0]-q+n-i;
                min = Math.min(min, ans);

            } else {
                long toRem = psum-k-arr[0];
                long q = (long)Math.ceil(toRem/(n-i+1.0));
                long ans = q+arr[0]+n-i;
                min = Math.min(min, ans);
            }
        }

        w.p(min);
    }

}",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
69b8ffb2,ba468e1f,"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));
    			
    }

}","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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
1c90c367,e52863b8,"
/*

    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
 \______/ |__/  |__/    \_/    |__/  |__/                                                                 
/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
																																																				
																																																				

*/

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 q3{
    static FastScanner fs = new FastScanner();
    static PrintWriter pw = new PrintWriter(System.out);

    static int[] sec;
    static int[] health;
    static int[] pp;
    public static void main(String[] args){
        int T = fs.nextInt();
        for (int tt=0;tt<T;tt++){
            int n = fs.nextInt();
            sec = new int[n];
            health = new int[n];

            for (int i=0;i<n;i++) sec[i] = fs.nextInt();
            for (int i=0;i<n;i++) health[i] = fs.nextInt();

            pp = new int[]{sec[n-1]-health[n-1]+1, sec[n-1], health[n-1]};

            long sum = 0;
            for (int i=n-2;i>=0;i--){
                int left = sec[i] - health[i] + 1, right = sec[i], top = health[i];

                if (right < pp[0]){
                    sum += ((long)pp[2] + 1) * (long)pp[2] / 2;
                    pp = new int[]{left, right, top};
                }
                else if (left < pp[0]){
                    pp[0] = left;
                    pp[2] = top + (pp[1] - right);
                }
            }
            sum += ((long)pp[2] + 1) * (long)pp[2] / 2;

            pw.println(sum);
        }



        pw.close();
    }

//    ----------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());
        }
    }
}",0,Non-plagiarised
4e5ee0f7,d6fb3b9e,"


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());
        }
    }


}







","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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
8f30bfc3,af1b152e,"import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.StringJoiner;

public class Solution {

  private static List<Long> chairs;
  private static List<Long> folks;
  private static Long[] data;
  private static Long[][] cache;

  public static void main(String[] args) {
    Print print = new Print();
    Scan scan = new Scan();

    int n = scan.scanInt();
    data = scan.scan1dLongArray();
    chairs = new ArrayList<>();
    folks = new ArrayList<>();
    cache = new Long[n][n];

    for (int i = 0; i < n; i++) {
      if (data[i] == 0) {
        chairs.add((long) i);
      } else {
        folks.add((long) i);
      }
    }

    print.printLine(Long.toString(solve(folks, chairs, 0, 0)));
    print.close();
  }

  private static long solve(List<Long> folks, List<Long> chairs, int i, int j) {
    if (i == folks.size()) {
      return 0;
    }
    if (j == chairs.size()) {
      return Integer.MAX_VALUE;
    }

    if (cache[i][j] != null) {
      return cache[i][j];
    }

    return cache[i][j] = Math
        .min(Math.abs(folks.get(i) - chairs.get(j)) + solve(folks, chairs, i + 1, j + 1),
            solve(folks, chairs, i, j + 1));

  }


  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() {
      if (total < 0) {
        throw new InputMismatchException();
      }
      if (index >= total) {
        index = 0;
        try {
          total = in.read(buf);
        } catch (IOException ignored) {
        }
        if (total <= 0) {
          return -1;
        }
      }
      return buf[index++];
    }

    public int scanInt() {
      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() {
      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 Integer[] scan1dIntArray() {
      String[] s = this.scanString().split("" "");
      Integer[] arr = new Integer[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Integer.parseInt(s[i]);
      }
      return arr;
    }

    public Integer[][] scan2dIntArray(int n, int m) {
      Integer[][] arr = new Integer[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = Integer.parseInt(s[j]);
        }
      }
      return arr;
    }

    public String[] scan1dStringArray() {
      return this.scanString().split("" "");
    }

    public String[][] scan2dStringArray(int n, int m) {
      String[][] arr = new String[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = s[j];
        }
      }
      return arr;
    }

    public char[] scan1dCharArray() {
      return this.scanString().toCharArray();
    }

    public char[][] scan2dCharArray(int n, int m) {
      char[][] arr = new char[n][m];
      for (int i = 0; i < n; i++) {
        char[] s = this.scanString().toCharArray();
        for (int j = 0; j < m; j++) {
          arr[i][j] = s[j];
        }
      }
      return arr;
    }

    public Long[] scan1dLongArray() {
      String[] s = this.scanString().split("" "");
      Long[] arr = new Long[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Long.parseLong(s[i]);
      }
      return arr;
    }

    public Long[][] scan2dLongArray(int n, int m) {
      Long[][] arr = new Long[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = Long.parseLong(s[j]);
        }
      }
      return arr;
    }

    public String scanString() {
      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 == '\r' || n == '\t' || n == -1) {
        return true;
      }
      return false;
    }
  }

  static class Print {

    private final BufferedWriter bw;

    public Print() {
      bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public void print(String str) {
      try {
        bw.append(str);
      } catch (IOException ignored) {
      }
    }

    public void printLine(Integer[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (Integer x : arr) {
        sj.add(Integer.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(Integer[][] arr) {
      for (Integer[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (Integer y : x) {
          sj.add(Integer.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(String[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (String x : arr) {
        sj.add(x);
      }
      printLine(sj.toString());
    }

    public void printLine(String[][] arr) {
      for (String[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (String y : x) {
          sj.add(y);
        }
        printLine(sj.toString());
      }
    }

    public void printLine(char[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (char x : arr) {
        sj.add(Character.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(char[][] arr) {
      for (char[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (char y : x) {
          sj.add(Character.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(Long[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (Long x : arr) {
        sj.add(Long.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(Long[][] arr) {
      for (Long[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (Long y : x) {
          sj.add(Long.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(String str) {
      print(str);
      try {
        bw.append(""\n"");
      } catch (IOException ignored) {
      }
    }

    public void close() {
      try {
        bw.close();
      } catch (IOException ignored) {
      }
    }
  }

}
","import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.StringJoiner;

public class D {

  private static List<Long> chairs;
  private static List<Long> folks;
  private static Long[] data;
  private static Long[][] cache;

  public static void main(String[] args) {
    Print print = new Print();
    Scan scan = new Scan();

    int n = scan.scanInt();
    data = scan.scan1dLongArray();
    chairs = new ArrayList<>();
    folks = new ArrayList<>();
    cache = new Long[n][n];

    for (int i = 0; i < n; i++) {
      if (data[i] == 0) {
        chairs.add((long) i);
      } else {
        folks.add((long) i);
      }
    }

    print.printLine(Long.toString(solve(folks, chairs, 0, 0)));
    print.close();
  }

  private static long solve(List<Long> folks, List<Long> chairs, int i, int j) {
    if (i == folks.size()) {
      return 0;
    }
    if (j == chairs.size()) {
      return Integer.MAX_VALUE;
    }

    if (cache[i][j] != null) {
      return cache[i][j];
    }

    return cache[i][j] = Math
        .min(Math.abs(folks.get(i) - chairs.get(j)) + solve(folks, chairs, i + 1, j + 1),
            solve(folks, chairs, i, j + 1));

  }


  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() {
      if (total < 0) {
        throw new InputMismatchException();
      }
      if (index >= total) {
        index = 0;
        try {
          total = in.read(buf);
        } catch (IOException ignored) {
        }
        if (total <= 0) {
          return -1;
        }
      }
      return buf[index++];
    }

    public int scanInt() {
      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() {
      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 Integer[] scan1dIntArray() {
      String[] s = this.scanString().split("" "");
      Integer[] arr = new Integer[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Integer.parseInt(s[i]);
      }
      return arr;
    }

    public Integer[][] scan2dIntArray(int n, int m) {
      Integer[][] arr = new Integer[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = Integer.parseInt(s[j]);
        }
      }
      return arr;
    }

    public String[] scan1dStringArray() {
      return this.scanString().split("" "");
    }

    public String[][] scan2dStringArray(int n, int m) {
      String[][] arr = new String[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = s[j];
        }
      }
      return arr;
    }

    public char[] scan1dCharArray() {
      return this.scanString().toCharArray();
    }

    public char[][] scan2dCharArray(int n, int m) {
      char[][] arr = new char[n][m];
      for (int i = 0; i < n; i++) {
        char[] s = this.scanString().toCharArray();
        for (int j = 0; j < m; j++) {
          arr[i][j] = s[j];
        }
      }
      return arr;
    }

    public Long[] scan1dLongArray() {
      String[] s = this.scanString().split("" "");
      Long[] arr = new Long[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Long.parseLong(s[i]);
      }
      return arr;
    }

    public Long[][] scan2dLongArray(int n, int m) {
      Long[][] arr = new Long[n][m];
      for (int i = 0; i < n; i++) {
        String[] s = this.scanString().split("" "");
        for (int j = 0; j < m; j++) {
          arr[i][j] = Long.parseLong(s[j]);
        }
      }
      return arr;
    }

    public String scanString() {
      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 == '\r' || n == '\t' || n == -1) {
        return true;
      }
      return false;
    }
  }

  static class Print {

    private final BufferedWriter bw;

    public Print() {
      bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public void print(String str) {
      try {
        bw.append(str);
      } catch (IOException ignored) {
      }
    }

    public void printLine(Integer[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (Integer x : arr) {
        sj.add(Integer.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(Integer[][] arr) {
      for (Integer[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (Integer y : x) {
          sj.add(Integer.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(String[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (String x : arr) {
        sj.add(x);
      }
      printLine(sj.toString());
    }

    public void printLine(String[][] arr) {
      for (String[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (String y : x) {
          sj.add(y);
        }
        printLine(sj.toString());
      }
    }

    public void printLine(char[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (char x : arr) {
        sj.add(Character.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(char[][] arr) {
      for (char[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (char y : x) {
          sj.add(Character.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(Long[] arr) {
      StringJoiner sj = new StringJoiner("" "");
      for (Long x : arr) {
        sj.add(Long.toString(x));
      }
      printLine(sj.toString());
    }

    public void printLine(Long[][] arr) {
      for (Long[] x : arr) {
        StringJoiner sj = new StringJoiner("" "");
        for (Long y : x) {
          sj.add(Long.toString(y));
        }
        printLine(sj.toString());
      }
    }

    public void printLine(String str) {
      print(str);
      try {
        bw.append(""\n"");
      } catch (IOException ignored) {
      }
    }

    public void close() {
      try {
        bw.close();
      } catch (IOException ignored) {
      }
    }
  }

}
",1,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
480de7be,f4757480,"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;
        }
    }
}
","import java.util.*;
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]);
                Arrays.sort(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;
        }
    }
}
",1,Plagiarised
5d175166,d1391025,"import java.io.*;
import java.util.*;

public class A {
    //--------------------------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);
    static long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
    static int ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
    static long mod = 1000000007;
    //-----------------------------------------------------------------------//

    //--------------------------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""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


        w.close();
    }

    static int[] res;
    static List<List<Integer>> graph;
    static boolean two = true;
    static HashMap<pr<Integer, Integer>, Integer> hm;

    static void solve() throws IOException {
        int n = sc.ni();
        graph = new ArrayList<>();
        res = new int[n-1];
        hm = new HashMap<>();
        for(int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }
        boolean f = false;
        for(int i = 0; i < n-1; i++) {
            int a = sc.ni(), b = sc.ni();
            graph.get(a).add(b);
            graph.get(b).add(a);
            if(graph.get(a).size() > 2 || graph.get(b).size() > 2) f = true;
            hm.put(new pr<>(a, b), i);
            hm.put(new pr<>(b, a), i);
        }

        if(f) {
            w.p(-1);
            return;
        }

        int one = 0;
        for(int i = 0; i < n; i++) {
            if(graph.get(i).size() == 1) {
                one = i;
                break;
            }
        }
        dfs(one, -1);
        for(int i: res) {
            w.pr(i+"" "");
        }
        w.pl();
    }

    static void dfs(int at, int pt) {
        List<Integer> li = graph.get(at);
        if(pt != -1) {
            res[hm.get(new pr<>(at, pt))] = two?2:3;
            two = !two;
        }
        for(int to: li) {
            if(to == pt) continue;
            dfs(to, at);
        }
    }

    static class pr <T, V> {
            T a; V b;

            public pr(T a, V b) {
                this.a = a;
                this.b = b;
            }

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof pr)) return false;
                pr<?, ?> pr = (pr<?, ?>) o;
                return a.equals(pr.a) && b.equals(pr.b);
            }

            @Override
            public int hashCode() {
                return Objects.hash(a, b);
            }
        }

}","import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class C {

    static class scanner {
        static BufferedReader reader;
        static StringTokenizer tokenizer;
        static void init(InputStream input) {
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("""");
        }
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine());
            }
            return tokenizer.nextToken();
        }
        static int nextInt() throws IOException {return Integer.parseInt(next());}
        static double nextDouble() throws IOException {return Double.parseDouble(next());}
        static long nextLong() throws IOException {return Long.parseLong(next());}
    }
    static long min(long a, long b) {return Math.min(a, b);}
    static long min(long a, long b, long c) {return min(a, min(b, c));}
    static int min(int a, int b) {return Math.min(a, b);}
    static int min(int a, int b, int c) {return min(a, min(b, c));}
    static long max(long a, long b) {return Math.max(a, b);}
    static long max(long a, long b, long c) {return max(a, max(b, c));}
    static int max(int a, int b) {return Math.max(a, b);}
    static int max(int a, int b, int c) {return max(a, max(b, c));}
    static int abs(int x) {return Math.abs(x);}
    static long abs(long x) {return Math.abs(x);}
    static long ceil(double x) {return (long) Math.ceil(x);}
    static long floor(double x) {return (long) Math.floor(x);}
    static int ceil(int x) {return (int) Math.ceil(x);}
    static int floor(int x) {return (int) Math.floor(x);}
    static double sqrt(double x) {return Math.sqrt(x);}
    static double cbrt(double x) {return Math.cbrt(x);}
    static long sqrt(long x) {return (long) Math.sqrt(x);}
    static long cbrt(long x) {return (long) Math.cbrt(x);}
    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 double pow(double n, double power) {return Math.pow(n, power);}
    static long pow(long n, double power) {return (long) Math.pow(n, power);}
    static class Pair {int first, second;public Pair(int first, int second) {this.first = first;this.second = second;}}
    
    public static void main(String[] args) throws IOException {
        scanner.init(System.in);
        int t = 1;
        t = scanner.nextInt();
        while (t-- > 0) {
            solve();
        }
    }
    
    static void solve() throws IOException {
        int n = scanner.nextInt();
        List<List<Pair>> tree = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            tree.add(new ArrayList<>());
        }
        for (int i = 0; i < n-1; i++) {
            int u = scanner.nextInt()-1;
            int v = scanner.nextInt()-1;
            tree.get(u).add(new Pair(v, i));
            tree.get(v).add(new Pair(u, i));
        }
        int start = -1;
        for (int i = 0; i < n; i++) {
            if(tree.get(i).size() > 2) {
                System.out.println(-1);
                return;
            }
            else if(tree.get(i).size() == 1) {
                start = i;
            }
        }
        int[] res = new int[n-1];

        Queue<Integer> q = new LinkedList<>();
        q.add(start);
        int weight =  2, prev = -1;
        while (!q.isEmpty()) {
            int u = q.poll();
            for(Pair v : tree.get(u)) {
                if(v.first != prev) {
                    q.add(v.first);
                    res[v.second] = weight;
                    weight = 5 - weight;
                }
            }
            prev = u;
        }

        for(int i : res) {
            System.out.print(i + "" "");
        }
        System.out.println();

    }

   
}


",0,Non-plagiarised
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,Non-plagiarised
1071f735,cd835290,"//package com.company;
//import java.math.BigInteger;
import java.util.*;
//import java.util.Stack;
import java.io.BufferedReader;
import java.io.IOException;
//import java.io.*;
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.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
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 int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

     static class obj{
           long a1;
           long a2;
           //int a3;
           obj(long a1,long a2){
               this.a1=a1;
               this.a2=a2;
              // this.a3=a3;
           }
       }
       static  class sortby implements Comparator<obj>{
           public   int compare(obj o1,obj o2){
               return o1.a1>o2.a1?1:-1;
           }
       }
    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 power(long x,long y,long p){
        String b1=""""+y;
        long d=p;
        long reminderb=0;
        for(int i=0;i<b1.length();i++){
            reminderb=(reminderb*10+b1.charAt(i)-'0')%d;
        }
        y=reminderb;
        long res=1;
        x=x%p;
        while(y>0){
            if((y&1)>0)
                res=(res*x)%p;
            y=y>>1;
            x=(x*x)%p;
        }
        return res;
    }
    static boolean isComposite(int n)
    {
        // Corner cases
        if (n <= 1)
            System.out.println(""False"");

        if (n <= 3)
            System.out.println(""False"");

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0) return true;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return true;

        return false;
    }

    //static ArrayList<Integer>[] a;
   // static int[] vis;
    //static int[] col;
  /*  static boolean dfs(int i,int c){
        vis[i]=1;
        col[i]=c;
        //System.out.println(i+"" ""+c);
        for(int j:a[i]){
            if(vis[j]==0) {
                if (dfs(j, c ^ 1) == false)
                    return false;
            }
            else
                if(col[i]==col[j])
                    return false;
        }
        return true;
    }*/
   static int[] m;
    static int solve(int p,long d){
        if(p<1)
            return 0;
        if(m[p]!=0)
            return m[p];
      if(p==1)
          return 1;
      long to=0;
       for(int i=1;i<=p-1;i++){
           to+=solve(i,d);
           to=to%d;
       }
       for(int i=p;i>=2;i--){
           to+=solve(p/i,d);
           to=to%d;
       }
       m[p]=(int)to;
       return m[p];
   }
   static long[][] dis;
   // static long d=1000000007;
   public static long solve(long[] arr,int i,int j){
       if(i>j){
           return 0;
       }
       if(dis[i][j]!=-1)
       {
           return dis[i][j];
       }

       if(i==j){
           return arr[i];
       }
       long c=0;
     c=Math.max(arr[i]+Math.min(arr[j-1]+solve(arr,i+1,j-1),arr[i+1]+solve(arr,i+2,j)),arr[j]+Math.min(solve(arr,i+1,j-1),solve(arr,i,j-2)));
      dis[i][j]=c;
return c;
   }
    public static void main(String[] args) {
        FastReader s = new FastReader();
        //InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        //Scanner s=new Scanner(System.in);
         int t = s.nextInt();

        while(t-->0) {
            int n = s.nextInt();
            int m = s.nextInt();
            int x=s.nextInt();
            long[] a = new long[n];
            for(int i=0;i<n;i++){
                a[i]=s.nextInt();
            }
           out.println(""YES"");
            PriorityQueue<obj> p = new PriorityQueue<>(new sortby());
            for (int i = 0; i <m; i++) {
             p.add(new obj(a[i],i+1));
             out.print(i+1+"" "");
            }
            for(int i=m;i<n;i++){
                obj o=p.poll();
                p.add(new obj(o.a1+a[i],o.a2));
                out.print(o.a2+"" "");
            }
            out.println();
        }
       out.close();

}}
","import java.util.*;

public class CP {
    public static int[] swap(int arr[], int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }


    static int isPowerOfTwo(int n)
    {
        if(n == 0 )
        return 0;
        while(n != 1)
        {
            if(n % 2 != 0)
            return 0;
            n = n / 2;    
        }
        return 1;
    }

    public static void printArr(int[] a){
        for(int i=0; i<a.length; i++){
            System.out.print(a[i]+1+"" "");
        }
        System.out.println();
    }

    public static class Pair implements Comparable<Pair> {
        int val;
        int idx;

        Pair(int a, int b){
            this.val = a;
            this.idx = b;
        }

        public int compareTo(Pair o){
            return this.val - o.val;
        }
    }


    public static void main(String[] args) {
        // CF1
        // Scanner sc = new Scanner(System.in);
        // int t = sc.nextInt();
        // for (int i = 0; i < t; i++) {
        //     int n = sc.nextInt();
        //     int x = sc.nextInt();
        //     int[] arr = new int[n];
        //     int sum = 0;
        //     for (int j = 0; j < n; j++) {
        //         arr[j] = sc.nextInt();
        //         sum += arr[j];
        //     }
        //     if (x == sum) {
        //         System.out.println(""NO"");
        //     } else if (x > sum) {
        //         System.out.println(""YES"");
        //         for (int j = 0; j < n; j++) {
        //             System.out.print(arr[j] + "" "");
        //         }
        //         System.out.println();
        //     } else {// x<sum
        //         Arrays.sort(arr);
        //         int curr = 0;
        //         int k = 0;
        //         while ((curr != x) && (k < n)) {
        //             curr += arr[k];
        //             k++;
        //         }
        //         if(k==n) {
        //             System.out.println(""YES"");
        //             for (int j = 0; j < n; j++) {
        //                 System.out.print(arr[j] + "" "");
        //             }
        //             System.out.println();
        //         }
        //         else if (curr == x) {
                    
        //             arr = swap(arr, k-1, n - 1);
        //             System.out.println(""YES"");
        //             for (int j = 0; j < n; j++) {
        //                 System.out.print(arr[j] + "" "");
        //             }
        //             System.out.println();
                
        //         }else{
        //             System.out.println(""NO"");
        //         }

        //     }

        // }



        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int i = 0; i < t; i++) {
            int n = sc.nextInt();
            int m=sc.nextInt();
            int x = sc.nextInt();
            int[] arr = new int[n];
            int[] ans = new int[n];
            for (int j = 0; j < n; j++) {
                        arr[j] = sc.nextInt();
            }
            PriorityQueue<Pair> pq=new PriorityQueue<>();
            for (int j = 0; j < m; j++) {
                pq.add(new Pair(arr[j],j));
                ans[j]=j;
    }
    for (int j = m; j < n; j++) {
        Pair p=pq.remove();
        pq.add(new Pair(p.val+arr[j],p.idx));
        ans[j]=p.idx;
        }
        System.out.println(""YES"");
        printArr(ans); 

    }
}
}",1,Plagiarised
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,Non-plagiarised
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,Plagiarised
3afcc566,3dd65549,"//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 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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Non-plagiarised
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,Plagiarised
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,Plagiarised
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,Plagiarised
1dab88fb,4138b081,"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.*;
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);
    	}
    }
}",0,Non-plagiarised
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,Non-plagiarised
5c54f087,c6c7fa0c,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("""");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }
    
    int n,a,b,da,db,dist,vert;
    ArrayList<Integer>A[];
    
    void solve() throws IOException {
        for (int tc=ni();tc>0;tc--) {
            n=ni(); a=ni(); b=ni(); da=ni(); db=ni();
            A=new ArrayList[n+1];
            for (int i=1;i<=n;i++) A[i]=new ArrayList();
            for (int i=1;i<n;i++) {
                int u=ni(),v=ni();
                A[u].add(v);
                A[v].add(u);
            }
            
            dist=0;
            dfs1(a,0,0);
            if (dist<=da || db<=2*da) {
                out.println(""Alice"");
                continue;
            }
            
            dist=0;
            vert=0;
            dfs2(1,0,0);
            dist=0;
            dfs2(vert,0,0);
            
            if (dist<=2*da) out.println(""Alice"");
            else out.println(""Bob"");
        }
        out.flush();
    }
    
    void dfs2(int u,int p,int d) {
        if (d>dist) {
            dist=d;
            vert=u;
        }
        
        for (Integer v:A[u]) {
            if (v==p) continue;
            dfs2(v,u,d+1);
        }
    }
    
    void dfs1(int u,int p,int d) {
        if (u==b) dist=d;
        for (Integer v:A[u]) {
            if (v==p) continue;
            dfs1(v,u,d+1);
        }
    }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}","import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.PI;
import static java.lang.System.in;
import static java.lang.System.out;

public class B
{
    static ArrayList<ArrayList<Integer>> adj;
    static int dis[];

    static void dfs(int s, int p, int l)
    {
        dis[s] = l;
        for(int i : adj.get(s))
        {
            if(i==p)    continue;
            dfs(i, s, l+1);
        }
    }

    public static void main(String[] args) throws Exception 
    {
        Foster sc = new Foster();
        PrintWriter p = new PrintWriter(out);
        int t = sc.nextInt();
        while(t--!=0)
        {
            int n = sc.nextInt(), a = sc.nextInt(), b = sc.nextInt(), da = sc.nextInt(), db = sc.nextInt();
            adj = new ArrayList<>();
            for(int i = 0; i <= n; i++)
            {
                adj.add(new ArrayList<>());
            }
            for(int i = 1; i < n; i++)
            {
                int u = sc.nextInt(), v = sc.nextInt();
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            dis = new int[n+1];
            dfs(a, 0, 0);
            if(dis[b] <= da)    //Alice reached in first move
            {
                p.println(""Alice"");
                continue;
            }
            int farthest = 0, maxDis = 0;
            for(int i = 1; i <= n; i++)
            {
                if(maxDis < dis[i])
                {
                    maxDis = dis[i];
                    farthest = i;
                }
            }
            dfs(farthest, 0, 0);
            int diameter = 0;
            for(int i = 1; i <= n; i++)
            {
                diameter = Math.max(diameter, dis[i]);
            }
            if(db > 2*da && diameter > 2*da)
            {
                p.println(""Bob"");
            }
            else
            {
                p.println(""Alice"");
            }
        }
        p.close();
    }
/* 
*/    
/*
1. Check overflow in pow function or in general
2. Check indices of read array function
3. Think of an easier solution because the problems you solve are always easy
4. Check iterator of loop
5. If still doesn't work, then jump from the 729th floor 'coz ""beta tumse na ho paayega""

    Move to top!!
*/
    static class Foster 
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(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());
        }
        double nextDouble() 
        {
            return Double.parseDouble(next());
        }
        int[] intArray(int n)                   // Check indices
        {
            int arr[] = new int[n];
            for(int i = 0; i < n; i++)
            {
                arr[i] = nextInt();
            }
            return arr;
        }
        long[] longArray(int n)                 // Check indices
        {
            long arr[] = new long[n];
            for(int i = 0; i < n; i++)
            {
                arr[i] = nextLong();
            }
            return arr;
        }
        int[] getBits(int n)                    //in Reverse Order
        {
            int a[] = new int[31];
            for(int i = 0; i < 31; i++)
            {
                if(((1<<i) & n) != 0)
                    a[i] = 1;
            }
            return a;
        }
        static long pow(long... a)
        {
            long mod = Long.MAX_VALUE;
            if(a.length == 3)   mod = a[2];
            long res = 1;
            while(a[1] > 0)
            {
                if((a[1] & 1) == 1)
                    res = (res * a[0]) % mod;
                a[1] /= 2;
                a[0] = (a[0] * a[0]) % mod;
            }
            return res;
        }
        void print(Object... o) 
        {
            for(Object next : o)
            {
                System.err.print(next + "" "");
            }
        }
        void println(Object... o) 
        {
            for(Object next : o)
            {
                System.err.print(next + "" "");
            }
            System.err.println();
        }
        void watch(Object...a) throws Exception 
        {
            int i = 1;
            for (Object o: a) 
            {
                boolean found = false;
                if (o.getClass().isArray()) 
                {
                    String type = o.getClass().getName().toString();
                    switch (type) 
                    {
                        case ""[I"":
                        {
                            int[] test = (int[]) o;
                            println(i + "" : "" + Arrays.toString(test));
                            break;
                        }
                        case ""[[I"":
                        {
                            int[][] obj = (int[][]) o;

                            println(i + "" : "" + Arrays.deepToString(obj));
                            break;
                        }
                        case ""[J"":
                        {

                            long[] obj = (long[]) o;
                            println(i + "" : "" + Arrays.toString(obj));
                            break;
                        }
                        case ""[[J"":
                        {

                            long[][] obj = (long[][]) o;
                            println(i + "" : "" + Arrays.deepToString(obj));
                            break;
                        }
                        case ""[D"":
                        {

                            double[] obj = (double[]) o;
                            println(i + "" : "" + Arrays.toString(obj));
                            break;
                        }
                        case ""[[D"":
                        {

                            double[][] obj = (double[][]) o;
                            println(i + "" : "" + Arrays.deepToString(obj));
                            break;
                        }
                        case ""[Ljava.lang.String"":
                        {

                            String[] obj = (String[]) o;
                            println(i + "" : "" + Arrays.toString(obj));
                            break;
                        }
                        case ""[[Ljava.lang.String"":
                        {

                            String[][] obj = (String[][]) o;
                            println(i + "" : "" + Arrays.deepToString(obj));
                            break;
                        }
                        case ""[C"":
                        {
                            char[] obj = (char[]) o;
                            println(i + "" : "" + Arrays.toString(obj));
                            break;
                        }
                        case ""[[C"":
                        {

                            char[][] obj = (char[][]) o;
                            println(i + "" : "" + Arrays.deepToString(obj));
                            break;
                        }
                        default:
                        {
                            println(i + "" : type not identified"");
                            break;
                        }
                    }
                    found = true;
                }
                if (o.getClass() == ArrayList.class) 
                {
                    println(i + "" : LIST = "" + o);
                    found = true;
                }
                if (o.getClass() == TreeSet.class) 
                {
                    println(i + "" : SET = "" + o);
                    found = true;
                }
                if (o.getClass() == TreeMap.class) 
                {
                    println(i + "" : MAP = "" + o);
                    found = true;
                }
                if (o.getClass() == HashMap.class) 
                {
                    println(i + "" : MAP = "" + o);
                    found = true;
                }
                if (o.getClass() == LinkedList.class) 
                {
                    println(i + "" : LIST = "" + o);
                    found = true;
                }
                if (o.getClass() == PriorityQueue.class) 
                {
                    println(i + "" : PQ = "" + o);
                    found = true;
                }
                if (!found) 
                {
                    println(i + "" = "" + o);
                }
                i++;
            }
        }
    }
}",0,Non-plagiarised
921b6e4a,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,Plagiarised
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,Non-plagiarised
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,Non-plagiarised
31f29772,d04e5afb,"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 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);
        }

    }
}


",0,Non-plagiarised
201e3463,de599e42,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D
{
    public static void main(String[] args)
    {
        CP sc =new CP();
        int tt = sc.nextInt();
        while (tt-- > 0) {
            int n = sc.nextInt();
            TreeSet<Long> set = new TreeSet<>();
            long prev = -1;
            boolean flag = true;
            for (int i = 0; i < n; i++) {
                long x = sc.nextInt();
                if (i == 0) {
                    set.add(x);
                    prev = x;
                    continue;
                }
                if (x > prev) {
                    Long high = set.higher(prev);
                    if (high == null) set.add(x);
                    else if (high >= x) set.add(x);
                    else flag = false;
                } else if (x < prev) {
                    Long low = set.lower(prev);
                    if (low == null) set.add(x);
                    else if (low <= x) set.add(x);
                    else flag = false;
                }
                prev = x;
            }
            System.out.println(flag ? ""YES"" : ""NO"");
        }
    }
    /*****************************************************************************/
    static class CP
    {
        BufferedReader bufferedReader;
        StringTokenizer stringTokenizer;
        public CP() {
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        }
        int nextInt() {
            return Integer.parseInt(NNNN());
        }
        long nextLong() {
            return Long.parseLong(NNNN());
        }
        double nextDouble() {
            return Double.parseDouble(NNNN());
        }
        String NNNN() {
            while (stringTokenizer == null || !stringTokenizer.hasMoreElements()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                }
                catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return stringTokenizer.nextToken();
        }
        String nextLine() {
            String spl = """";
            try {
                spl = bufferedReader.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return spl;
        }
    }
    /*****************************************************************************/
}","import java.util.*;
import java.io.*;

public class _724 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            TreeSet<Long> set = new TreeSet<>();
            long prev = -1;
            boolean ok = true;
            for (int i = 0; i < n; i++) {
                long x = sc.nextInt();
                if (i == 0) {
                    set.add(x);
                    prev = x;
                    continue;
                }
                if (x > prev) {
                    Long high = set.higher(prev);
                    if (high == null) set.add(x);
                    else if (high >= x) set.add(x);
                    else {
                        ok = false;
                    }
                } else if (x < prev) {
                    Long low = set.lower(prev);
                    if (low == null) set.add(x);
                    else if (low <= x) set.add(x);
                    else {
                        ok = false;
                    }
                }
                prev = x;
            }
            out.println(ok ? ""YES"" : ""NO"");
        }
        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;
        }


    }

}",1,Plagiarised
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,Non-plagiarised
bf0df1d5,d1cd194e,"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.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,Non-plagiarised
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,Plagiarised
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,Non-plagiarised
4138b081,f59d9b6e,"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);
    	}
    }
}","/* 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();
	}
}
",0,Non-plagiarised
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,Plagiarised
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,Non-plagiarised