filename_1,filename_2,code_1,code_2,labels,notes
4a5b029f,fb05904c,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner scn = new Scanner(System.in);
		int t = scn.nextInt();
		while(t>0){
			int n = scn.nextInt();
			String a = scn.next();
			String b = scn.next();
		
	//	System.out.println(a);
			int ob=0,oa=0,za=0;
			for(int i=0;i<a.length();i++){
				if(a.charAt(i)=='1'){
					
					oa++;
				}else{
					za++;
				}
			}
			for(int i=0;i<b.length();i++){
				if(b.charAt(i)=='1'){
					ob++;	
				}
			}
		//	System.out.println(ob+"" ""+za);
			int min = Integer.MAX_VALUE;
			if(ob==oa){
				int op=0;
				for(int i=0;i<a.length();i++){
					if(a.charAt(i)!=b.charAt(i)){
						op++;
					}
				}
			
				min = Math.min(min,op);
			}
			if(ob==za+1){
				int op=0;
				for(int i=0;i<n;i++){
					if(a.charAt(i)==b.charAt(i)){
						op++;
					}
				}
				min = Math.min(min,op);
			}
			
			if(min!=Integer.MAX_VALUE){
				System.out.println(min);
				}else{
				System.out.println(-1);
			}
			t--;
		}
	}
}
","import java.util.*;
import java.io.*;
import java.math.*;

public class Coder {

  static int n;
  static char a[];
  static char b[];
  static StringBuffer str=new StringBuffer();

  static void solve(){
    boolean flag=true;
    for(int i=0;i<n;i++) if(a[i]!=b[i]) flag=false;
    if(flag){str.append(""0\n""); return;}
    int tot=0;
    int tot1=0;
    for(int i=0;i<n;i++) if(a[i]=='1') tot++;
    for(int i=0;i<n;i++) if(b[i]=='1') tot1++;
    if(tot==0){
      if(tot1!=0) str.append(""-1\n"");
      else str.append(""0\n"");
    }else{
      int x=tot-1;
      int ul=n-tot;
      if(tot!=tot1 && (ul+1)!=tot1) str.append(""-1\n"");
      else{
        int same=0, nsame=0;
        int zs, os;
        int zd, od;
        zs=os=zd=od=0;
        for(int i=0;i<n;i++){
          if(a[i]==b[i]){
            same++;
            if(a[i]=='0') zs++;
            else os++;
          }
          else{
            nsame++;
            if(a[i]=='0') zd++;
            else od++;
          }
        }
        
        // else if(zd>0 && od>0 && os>0 && zs>0) str.append(Math.min(nsame, same)).append(""\n"");
        // else if(zd>0 && od>0) str.append(nsame).append(""\n"");
        // else if(zs>0 && os>0) str.append(same).append(""\n"");
        // else str.append(""-1\n"");
        if(same==1 && nsame==n-1 && os==1) str.append(""1\n"");
        else if(zd==od && od>0 && os>0 && os-zs==1) str.append(Math.min(nsame, same)).append(""\n"");
        else if(zd==od && od>0) str.append(nsame).append(""\n"");
        else if(os>0 && os-zs==1) str.append(same).append(""\n"");
        else str.append(""-1\n"");
      }
    } 
  }

  public static void main(String[] args) throws java.lang.Exception {
    BufferedReader bf;
    PrintWriter pw;
    boolean lenv=false;
    if(lenv){
      bf = new BufferedReader(
                          new FileReader(""input.txt""));
      pw=new PrintWriter(new
            BufferedWriter(new FileWriter(""output.txt"")));
    }else{
      bf = new BufferedReader(new InputStreamReader(System.in));
      pw = new PrintWriter(new OutputStreamWriter(System.out));
    }
    
    int t = Integer.parseInt(bf.readLine().trim());
    while (t-- > 0) {
      String st[]=bf.readLine().trim().split(""\\s+"");
      n=Integer.parseInt(st[0]);
      a=bf.readLine().trim().toCharArray();
      b=bf.readLine().trim().toCharArray();
      solve();
    }
    pw.println(str);
    pw.flush();
    // System.outin.print(str);
  }
}
",0,Non-plagiarised
69c97258,db01da00,"import java.util.Scanner;
import java.util.ArrayList;
import java.lang.Math;

public class fell {
	private static final Scanner cin = new Scanner(System.in);
	private static final int maxVal = 1000000000;

	public static void main(String[] args) {
		int n = cin.nextInt();
		ArrayList<Integer> a = new ArrayList<>();
		ArrayList<Integer> b = new ArrayList<>();

		for (int i = 0; i < n; i++) {
			int t = cin.nextInt();
			if (t == 0)
				a.add(i);
			else
				b.add(i);
		}

		if (a.size() == n) {
			System.out.println(0);
			return;
		}

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

		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++) {
				if (i == 0)
					dp[i][j] = 0;
				else
					dp[i][j] = maxVal;
			}
		
		for (int i = 0; i < a.size(); i++) {
			for (int j = 0; j < Math.min(i + 1, b.size() + 1); j++) {
				dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
				if (j == b.size())
					continue;
				dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], dp[i][j] + Math.abs(a.get(i) - b.get(j)));
			}
		}

		System.out.println(dp[a.size()][b.size()]);
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class Main {
    static int func(List<Integer> ones, List<Integer> zeroes, int idO, int idZ, int o, int z, Integer[][] memo) {
        if(idZ == zeroes.size() || idO == ones.size()) {
            return 0;
        }
        
        if(memo[idO][idZ] != null) {
            return memo[idO][idZ];
        }
        
        if(o == z) {
            return memo[idO][idZ] = Math.abs(ones.get(idO) - zeroes.get(idZ))
                + func(ones, zeroes, idO + 1, idZ + 1, o - 1, z - 1, memo);
        } else {
            return memo[idO][idZ] = Math.min(
                Math.abs(ones.get(idO) - zeroes.get(idZ))
                + func(ones, zeroes, idO + 1, idZ + 1, o - 1, z - 1, memo),
                func(ones, zeroes, idO, idZ + 1, o, z - 1, memo)
            );
        }
    }
    
	public static void main (String[] args) {
	   // Scanner scan = new Scanner(System.in);
    	FastScanner scan = new FastScanner();
        int n =  scan.nextInt();
        int[] arr = scan.readArray(n);
        
        List<Integer> ones = new ArrayList<>();
        List<Integer> zeroes = new ArrayList<>();
        
        for(int i = 0; i < n; i++) {
            if(arr[i] == 0) {
                zeroes.add(i);
            } else {
                ones.add(i);
            }
        }
        
        int o = ones.size();
        int z = zeroes.size();
        
        Integer[][] memo = new Integer[o + 1][z + 1];
        
        int ans = func(ones, zeroes, 0, 0, o, z, memo);
        
        System.out.println(ans);
    }
/*
    int n = scan.nextInt();
            int[] arr = scan.readArray(n);
    
    int n = scan.nextInt();
            int m = scan.nextInt();
            int[][] arr = new int[n][m];
            for(int i = 0; i < n; i++) {
                for(int j = 0; j < m; j++) {
                    arr[i][j] = scan.nextInt();
                }
            }
    
*/
    
    
    
    
}
",0,Non-plagiarised
ca0c55ad,e14d1ba0,"import java.util.*;
public class ss
{
    public static void main(String[]args)
    {
        Scanner in=new Scanner (System.in);
        int t=in.nextInt();
        for(int i1=0;i1<t;i1++)
        {
            int n=in.nextInt();
	
	long[] ar=new long[n];
	
	for(int i=0;i<n;i++)
	{
		ar[i]=in.nextLong();
		
	}
	
	long[] ans=new long[n];
	ans[0]=ar[0]*n;
	long m=ar[0];
	long s1=ar[0];
	for(int i=2;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);

		


	}
	ans[1]=ar[1]*n;
	 m=ar[1];
	 s1=ar[1];
	for(int i=3;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);
	}
	long mini=ans[0]+ans[1];
	for(int i=1;i<n-1;i++)
	{
		mini=Math.min(ans[i]+ans[i+1],mini);
	}
	System.out.println(mini);
}
}
}
","import java.util.*;
public class ss
{
    public static void main(String[]args)
    {
        Scanner in=new Scanner (System.in);
        int t=in.nextInt();
        for(int i1=0;i1<t;i1++)
        {
            int n=in.nextInt();
	
	long[] ar=new long[n];
	
	for(int i=0;i<n;i++)
	{
		ar[i]=in.nextLong();
		
	}
	
	long[] ans=new long[n];
	ans[0]=ar[0]*n;
	long m=ar[0];
	long s1=ar[0];
	for(int i=2;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);
 
		
 
 
	}
	ans[1]=ar[1]*n;
	 m=ar[1];
	 s1=ar[1];
	for(int i=3;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);
	}
	long mini=ans[0]+ans[1];
	for(int i=1;i<n-1;i++)
	{
		mini=Math.min(ans[i]+ans[i+1],mini);
	}
	System.out.println(mini);
}
}
}
",1,Plagiarised
09586ae3,88c90c09,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            for(int i=0;i<n;i++) a[i]=input.nextInt();
            long i=1,j=(long)1e15;
            while(i<j)
            {
                long mid=(i+j)/2;
                if(fun(a,mid,n))
                {
                    i=mid+1;
                }
                else
                {
                    j=mid;
                }
            }
            out.println(i-1);
        }
        out.close();
    }
    public static boolean fun(int a[],long x,int n)
    {
        long arr[]=new long[n];
        for(int i=0;i<n;i++) arr[i]=a[i];
        long b[]=new long[n];
        for(int i=n-1;i>=2;i--)
        {
            if(b[i]+arr[i]<x) return false;
            long z=Math.max(0,x-b[i]);
            long u=arr[i]-z;
            long y=u/3;
            b[i-1]+=y;
            b[i-2]+=2*y;
        }
        if(arr[0]+b[0]<x || arr[1]+b[1]<x) return false;
        return true;
    }
    
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.sql.SQLOutput;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        //int a = 1;
        int t;
        t = in.nextInt();
        //t = 1;
        while (t > 0) {
            //out.print(""Case #""+(a++)+"": "");
            solver.call(in,out);
            t--;
        }
        out.close();

    }

    static class TaskA {
        int n;
        long[] arr;
        public void call(InputReader in, PrintWriter out) {
            n = in.nextInt();
            arr = new long[n];

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextLong();
            }
            long l, r, mid;
            l = 0;
            r = (long)1e10;
            while (l  + 1 < r){
                mid = ( l + r)/2;
                if(ans(mid)){
                    l = mid;
                }
                else{
                    r = mid;
                }
            }

            out.println(l);
        }

        public boolean ans(long mid) {
            long[] array = new long[n];
            long a, b;
            for (int i = n - 1; i >= 2; i--) {
                a = mid - array[i];
                if(a > 0){
                    b = arr[i] - a;
                    if(b >= 0){
                        b/=3;
                        array[i - 1] += b;
                        array[i - 2] += 2*b;
                    }
                    else{
                        return false;
                    }
                }
                else{
                    b = arr[i];
                    b/=3;
                    array[i - 1] += b;
                    array[i - 2] += 2*b;
                }
            }
            for (int i = 0; i < 2; i++) {
                if(arr[i] + array[i] < mid){
                    return false;
                }
            }
            return true;
        }
    }

    

    


    

    

    

    

    static final Random random=new Random();

    

    
}
",0,Non-plagiarised
ac144188,e899614e,"import java.util.*;
import java.io.*;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.Math.max;
public class EdB {
	static long[] mods = {1000000007, 998244353, 1000000009};
	static long mod = mods[0];
	public static MyScanner sc;
    public static PrintWriter out;
	public static void main(String[] largewang) throws Exception{
		// TODO Auto-generated method stub
 		sc = new MyScanner();
 		out = new PrintWriter(System.out);
 		int t = sc.nextInt();
 		while (t-->0) {
 			int n = sc.nextInt();
 			Set<Long> sums = new HashSet<>();
 			boolean found = false;
 			int[] arr = readArrayInt(n);
 			for(int j = 0;j<n;j++){
 				if (arr[j] == 0)
 					found = true;
 			}
 			for(int j = 1;j<(1<<n);j++){
 				long sum = 0;
 				for(int k = 0;k<n;k++){
 					if (((1<<k)&j) != 0) {
 						sum += (long)abs(arr[k]);
 					}
 				}
 				if (sums.contains(sum)) {
 					found = true;
 					break;
 				} else {
 					sums.add(sum);
 				}
 			}
 			verdict(found);
 		}
 		out.close();
 		
 	}
	
	
	
	static int[] readArrayInt(int n){
    	int[] array = new int[n];
    	for(int j = 0;j<n;j++)
    		array[j] = sc.nextInt();
    	return array;
    }
	
	
	
	
	
	
	
	static void verdict(boolean a){
        out.println(a ? ""YES"" : ""NO"");
    }
    	
}
","import java.util.*;
import java.io.*;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.Math.max;
public class EdB {
	static long[] mods = {1000000007, 998244353, 1000000009};
	static long mod = mods[0];
	public static MyScanner sc;
    public static PrintWriter out;
	public static void main(String[] largewang) throws Exception{
		// TODO Auto-generated method stub
 		sc = new MyScanner();
 		out = new PrintWriter(System.out);
 		int t = sc.nextInt();
 		while (t-->0) {
 			int n = sc.nextInt();
 			Set<Long> sums = new HashSet<>();
 			boolean found = false;
 			int[] arr = readArrayInt(n);
 			for(int j = 0;j<n;j++){
 				if (arr[j] == 0)
 					found = true;
 			}
 			for(int j = 1;j<(1<<n);j++){
 				long sum = 0;
 				for(int k = 0;k<n;k++){
 					if (((1<<k)&j) != 0) {
 						sum += (long)abs(arr[k]);
 					}
 				}
 				if (sums.contains(sum)) {
 					found = true;
 					break;
 				} else {
 					sums.add(sum);
 				}
 			}
 			verdict(found);
 		}
 		out.close();
 		
 	}
	
	
	
	static int[] readArrayInt(int n){
    	int[] array = new int[n];
    	for(int j = 0;j<n;j++)
    		array[j] = sc.nextInt();
    	return array;
    }
	
	
	
	
	
	
	
	static void verdict(boolean a){
        out.println(a ? ""YES"" : ""NO"");
    }
    	
}
",1,Plagiarised
0b04b41e,9291ca83,"import java.io.BufferedReader;
import java.io.*;
import java.util.*;

public class josph {

static BufferedReader br;


// 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=Math.max(max,cnt);
}
System.out.println(max);
}

}



























public static String cin() throws Exception {
return br.readLine();
}









public static Integer cinI() throws Exception {
return Integer.parseInt(br.readLine());
}













}
","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
2b8f032c,a195911e,"import java.io.*;
import java.util.*;

public class Main {

	static int INF = (int)1e9 + 1;
	
	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		PrintWriter out = new PrintWriter(System.out);

		/******  CODE STARTS HERE  *****/
		//--------------------------------------------------------------------------------------------------------
		int t = fs.nextInt();
		w:while(t-->0) {
			int n = fs.nextInt();
			int[] k = fs.readArray(n);
			int[] h = fs.readArray(n);
			long ans = 0;
			int mtn = INF, prev = k[n-1];
			
			for(int j=n-1; j>=0; j--) {
				if(mtn!=INF && mtn > k[j]) {
					int x = prev-mtn+1;
					ans += ((long)x*(x+1))/2;
					mtn = INF;
					prev = k[j];
				}
				if(mtn >= k[j]-h[j]+1) 
					mtn = k[j]-h[j]+1;
				
				if(j==0) {
					int x = prev-mtn+1;
					ans += ((long)x*(x+1))/2;
				}
			}
			out.println(ans);
		}
		out.close();
	}
    
	//******  CODE ENDS HERE  *****
	//----------------------------------------------------------------------------------------------------------------
	
	
	
	
	//----------- FastScanner class for faster input---------------------------
	
}
","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 int find(int A[],int a) {
//	  if(A[a]==a)
//		  return a;
//	  return find(A, A[a]);
//}
//FENWICK TREE



//END







static long[] inputL(int n) {
	long A[]=new long[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.nextLong();
	   }
	   return A;
   }
















































     static int i() {
    	 return sc.nextInt();
     }
     
       
     
     
  
  
  
  
  
      
      
      
      
     
        
     
}
",0,Non-plagiarised
2c865582,2ef4c176,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.StringTokenizer;

public class Main {
    


    static long dfs(int cur,int parent,int taken,HashMap<Integer,ArrayList<node>> hm,ArrayList<node> al,long[][] dp){
        long ans=0;
        if(dp[cur-1][taken]!=-1) return dp[cur-1][taken];
        int v=taken==0?al.get(cur-1).l:al.get(cur-1).r;
        for(node x:hm.get(cur)){
            int xl=x.l,xr=x.r,idx=x.idx;
            if(idx!=parent){
                ans+=Math.max(Math.abs(v-xl)+dfs(idx,cur,0,hm,al,dp),Math.abs(v-xr)+dfs(idx,cur,1,hm,al,dp));
            }
        }
        return dp[cur-1][taken]=ans;
    }
    public static void main(String[] args) {
        FastReader obj = new FastReader();
        int t = obj.nextInt();
        while(t-->0) {
            int n = obj.nextInt(),a,b;
            ArrayList<node> al=new ArrayList<>();
            for(int i=0;i<n;i++){
                a = obj.nextInt();
                b = obj.nextInt();
                al.add(new node(a,b,i+1));
            }
            HashMap<Integer,ArrayList<node>> hm=new HashMap<>();
            for(int i=0;i<n-1;i++){
                a = obj.nextInt();
                b = obj.nextInt();
                if(!hm.containsKey(a)){
                    hm.put(a,new ArrayList<node>());
                }
                if(!hm.containsKey(b)){
                    hm.put(b,new ArrayList<node>());
                }
                hm.get(a).add(al.get(b-1));
                hm.get(b).add(al.get(a-1));
            }
            long[][] dp=new long[n+2][2];
            for(long[] x:dp) Arrays.fill(x,-1);
            long ans1,ans2;
            ans1=dfs(1,0,0,hm,al,dp);
            ans2=dfs(1,0,1,hm,al,dp);
            System.out.println(Math.max(ans1,ans2));
        }
    }
}

class node{
    int l,r,idx;
    node(int l1,int r1,int i){
        l=l1;
        r=r1;
        idx=i;
    }
}
","import java.io.*;
import java.util.*;

public class Template {

	static int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int yo = sc.nextInt();
		while (yo-- > 0) {
			int n = sc.nextInt();
			
			Map<Integer,Pair> map = new HashMap<>();
			
			for(int i = 0; i < n; i++) {
				map.put(i, new Pair(sc.nextLong(),sc.nextLong()));
			}
			
			List<List<Integer>> list = new ArrayList<>();
			for(int i = 0; i < n; i++) {
				list.add(new ArrayList<>());
			}
			for(int i = 0; i < n-1; i++) {
				int x = sc.nextInt()-1;
				int y = sc.nextInt()-1;
				list.get(x).add(y);
				list.get(y).add(x);
			}
			
			// l -> 0, r -> 1
			
			for(int i = 0; i < 1e5+3; i++) {
				for(int j = 0; j < 2; j++) {
					dp[i][j] = -1;
				}
			}
			long a1 = dfs(map,list,0,0,-1);
			long a2 = dfs(map,list,1,0,-1);
			long ans = Math.max(a1, a2);
			out.println(ans);
		}
		out.close();
	}

//	static Map<String,Long> dp = new HashMap<>();
	static long[][] dp = new long[(int)1e5+10][2];
	private static long dfs(Map<Integer, Pair> map, List<List<Integer>> list, 
							int x, int node, int parent) {
		
		
		if(dp[node][x] != -1) {
			return dp[node][x];
		}

		List<Integer> neighbours = list.get(node);
		
		long ans1 = 0;
		if(x == 0) {
			ans1 = map.get(node).x;
		}
		else {
			ans1 = map.get(node).y;
		}
		
		
		long uAns = 0;
		for(int e : neighbours) {
			if(e == parent) continue;
			long ua1 = dfs(map,list,0,e,node);
			long ua2 = dfs(map,list,1,e,node);
			// consider 0
			long a1 = ua1 + Math.abs(map.get(e).x-ans1);
			// consider 1
			long a2 = ua2 + Math.abs(map.get(e).y-ans1);
			uAns += Math.max(a1, a2);
		}
		
		return dp[node][x] = uAns;
	}

	static class Pair {
		long x;
		long y;

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

	

	

	

	

	

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

public class Codechef {
	static long fans[] = new long[200001];
	static long inv[] = new long[200001];
	static long mod = 1000000007;

	

	

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

	

	

	

	
}


","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
9debf95c,ac596a43,"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 static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    


    


    static long mod = 1000000007;

    

    


    

    

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

    

    


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

    

    
    
    

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


    }


}







","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 static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    


    


    static long mod = 1000000007;

    

    


    

    

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

    

    


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

    

    
    
    

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


    }


}







",1,Plagiarised
b434c275,fdc4f384,"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 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 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 int i()
	{
		return in.nextInt();
	}

	

	

	

	

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


//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

","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 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<6; 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[6];
				for(char x:X)f[x-'a']++;
				for(int j=0; j<6; j++)q[j].add(new node1(f[j],i,s));
			}
			
			int max=0;
			for(int i=0; i<6; 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 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 int i()
	{
		return in.nextInt();
	}

	

	

	

	

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


//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",1,Plagiarised
63bfa731,949502c2,"import java.util.*;
import java.io.*;

public class D {
    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
    static int diameter = 0;
    static int[] depth = new int[(int)1e5 + 7];
    public static void main(String[] args) {
        FastReader in = new FastReader();
        int t = in.nextInt();
        while(t-- > 0){
            int n = in.nextInt();
            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
            for(int i = 1; i <= n; i++){
                adj[i] = new ArrayList<>();
            }
            for(int i = 1; i <=n; i++){
                adj[i].clear();
            }
            for(int i = 0; i < n- 1; i++){
                int u = in.nextInt();
                int v = in.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            diameter = 0;
            depth[a] = 0;
            dfs(a, -1);
            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
        }
    }
    static int dfs(int node, int parent){
        int len = 0;
        for(int x : adj[node]){
            if(x != parent){
                depth[x] = depth[node] + 1;
                int cur = 1 + dfs(x, node);
                diameter = Math.max(diameter, cur + len);
                len = Math.max(len, cur);
//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
            }
        }
        return len;
    }
    

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

	

	

	

	

	

	

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
",1,Plagiarised
35857a5a,ab7507bf,"import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class solution { 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt();
			int c[][]=new int[n][5];
			int sum[]=new int[5];
			for(int i=0;i<n;i++) {
				String a=s.next();
				for(int j=0;j<a.length();j++) {
					c[i][a.charAt(j)-'a']++;
				}
				for(int j=0;j<5;j++) {
					sum[j]+=c[i][j];
				}
			}
			int sum1=0;
			for(int i=0;i<5;i++) {
				sum1+=sum[i];
			}
			int ans=0;
			
			for(int i=0;i<5;i++) {
				int sum2=sum1-sum[i];
				//out.println(sum2);
				if(sum[i]>sum2) {
					ans=n;
					break;
				}else {
					
					ArrayList<Integer> f=new ArrayList<>();
					for(int j=0;j<n;j++) {
						int sum3=0;
						for(int k=0;k<5;k++) {
							if(k!=i) {
								sum3+=c[j][k];
							}else {
								sum3-=c[j][k];
							}
						}
						f.add(sum3);
					}
					Collections.sort(f);
					while(sum[i]<=sum2 && f.size()>0 && f.get(f.size()-1)>0) {
						sum2-=f.get(f.size()-1);
						f.remove(f.size()-1);
						//out.println(sum2);
					}
					if(sum[i]>sum2) {
						ans=Math.max(ans,f.size());
					}
					//out.println(ans+"" Ayush"");
				}
			}
			out.println(ans);
		}
		out.close();
    }
    
    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);
	}
    
    
    
    
    
}
","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();
	}

	

}
",0,Non-plagiarised
32ff22fe,f0d91796,"import java.io.*;
import java.util.*;
public class MyClass {
    public static void pA(int[]a){
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+"" "");
        }
        System.out.println();
    }
    public static void main(String args[])throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int t=Integer.parseInt(br.readLine());
        while(t-->0){
            int n=Integer.parseInt(br.readLine());
            String s[]=br.readLine().split("" "");
            int arr[]=new int[n];
            int a[]=new int[n];
            for(int i=0;i<n;i++) arr[i]=Integer.parseInt(s[i]);
            if(n%2==0){
                for(int i=0;i<n-1;i+=2){
                    a[i]=arr[i+1];
                    a[i+1]=-1*arr[i];
                }
            }
            else{
                if(arr[1]+arr[2]!=0){
                    a[0]=arr[1]+arr[2];
                    a[1]=-1*arr[0];
                    a[2]=-1*arr[0];
                }
                else if(arr[0]+arr[1]!=0){
                    a[2]=arr[0]+arr[1];
                    a[0]=-1*arr[2];
                    a[1]=-1*arr[2];
                }
                else{
                    a[1]=arr[0]+arr[2];
                    a[0]=-1*arr[1];
                    a[2]=-1*arr[1];
                }
                for(int i=3;i<n-1;i+=2){
                    a[i]=arr[i+1];
                    a[i+1]=-1*arr[i];
                }
            }
            pA(a);
        }
    }
}
","import java.io.*;
import java.util.*;
 
public class cf {
 
    public static void main(String[] args){
 
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-- > 0){
 			
 			int n=sc.nextInt();
            int arr[]=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
            }
            int ans[]=new int[n];
            if(n%2==0){
                for(int i=0;i<n;i=i+2){
                    ans[i]=-arr[i+1];
                    ans[i+1]=arr[i];
                }
            }
            else{
                if(arr[0]+arr[1]!=0){
                    ans[0]=-arr[2];
                    ans[1]=-arr[2];
                    ans[2]=arr[0]+arr[1];
                }
                else{
                    if(arr[1]+arr[2]!=0){
                        ans[1]=-arr[0];
                        ans[2]=-arr[0];
                        ans[0]=arr[1]+arr[2];
                    }
                    else{
                        ans[0]=-arr[1];
                        ans[2]=-arr[1];
                        ans[1]=arr[0]+arr[2];
                    }
                }
                for(int i=3;i<n;i=i+2){
                    ans[i]=-arr[i+1];
                    ans[i+1]=arr[i];
                }
            }
            for(int j=0;j<n;j++){
                System.out.print(ans[j]+"" "");
            }
            System.out.println();
            

            
            

            

            
           
 			

        }	        	
        	
 			
    }
 
    
    
    
 
}

//////////////////////////////////////////////////////////////
// LCM AND GCD
/*
	public static int gcd(int a,int b){
		if(b == 0){
			return a;
		}
		return gcd(b,a%b);
	}
 
	public static int lcm(int a,int b){
		 return (a / gcd(a, b)) * b;
	}*/


///////////////////////////////////////////////////////////////////////////////////

//Iterator



/*Iterator iterator = object.iterator();
 
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "" "");
        }*/
///////////////////////////////////////////////////////////////////////////////////



",0,Non-plagiarised
4499e3b9,cbbbed5f,"import java.io.*;
import java.util.*;

public class Main {

    static public void dfs(ArrayList<ArrayList<Integer>> g, int u, long[][] dp, long[] l, long[] r, int p) {
        dp[u][0] = 1;
        for (int i = 0; i < g.get(u).size(); i++) {
            int v = g.get(u).get(i);
            if (v == p) continue;
            if (dp[v][0] == 0) {
                dfs(g, v, dp, l, r, u);
            }
            dp[u][1] += Math.max(Math.abs(l[u] - l[v]) + dp[v][1], Math.abs(l[u] - r[v]) + dp[v][2]);
            dp[u][2] += Math.max(Math.abs(r[u] - l[v]) + dp[v][1], Math.abs(r[u] - r[v]) + dp[v][2]);
        }
    }

    static public void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int T = Integer.parseInt(st.nextToken());
        for (int t = 1; t <= T; t++) {
            st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long[] l = new long[n + 1], r = new long[n + 1];
            ArrayList<ArrayList<Integer>> g = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                st = new StringTokenizer(br.readLine());
                l[i + 1] = Integer.parseInt(st.nextToken());
                r[i + 1] = Integer.parseInt(st.nextToken());
                g.add(new ArrayList<>());
            }
            g.add(new ArrayList<>());

            for (int i = 0; i < n - 1; i++) {
                st = new StringTokenizer(br.readLine());
                int u = Integer.parseInt(st.nextToken()), v = Integer.parseInt(st.nextToken());
                g.get(v).add(u);
                g.get(u).add(v);
            }
            long[][] dp = new long[n + 1][3];
            dfs(g, 1 , dp, l, r, -1);
            bw.write(Math.max(dp[1][1], dp[1][2]) + ""\n"");
        }
        bw.flush();
    }
}
","import java.util.*;
import java.io.*;

public class C{

	private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int vertices;
    private static LinkedList<Integer> adj[];
    private static long dp[][];
    private static int l[];
    private static int r[];
    private static boolean vis[];

    public static void dfs(int v) {
        if(vis[v])
            return;
        vis[v] = true;
        Iterator<Integer> iterator = adj[v].listIterator();
        while(iterator.hasNext()) {
            int child = iterator.next();
            if(!vis[child]) {
                dfs(child);
                long left = dp[child][0] + Math.abs(l[v] - l[child]);
                dp[v][0] += Math.max(left, dp[child][1] + Math.abs(l[v] - r[child]));
                long right = dp[child][0] + Math.abs(r[v] - l[child]);
                dp[v][1] += Math.max(right, dp[child][1] + Math.abs(r[v] - r[child]));
            }
        }
    }

	public static void main (String[] args) throws IOException {
        int t = Integer.parseInt(br.readLine());
        while(t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            vertices = n;
            dp = new long[n+1][2];
            adj = new LinkedList[n+1];
            vis = new boolean[n+1];
            l = new int[n+1];
            r = new int[n+1];
            for(int i=1;i<=n;i++) {
                adj[i] = new LinkedList<>();
            }
            for(int i=1;i<=n;i++) {
                String lr[] = br.readLine().split("" "");
                l[i] = Integer.parseInt(lr[0]);
                r[i] = Integer.parseInt(lr[1]);
            }
            for(int i=0;i<n-1;i++) {
                String uv[] = br.readLine().split("" "");
                int u = Integer.parseInt(uv[0]);
                int v = Integer.parseInt(uv[1]);
                adj[u].add(v);
                adj[v].add(u);
            }
            dfs(1);
            long ans = Math.max(dp[1][0], dp[1][1]);
            bw.write(ans + ""\n"");
        }
        bw.flush();
    }
}
",0,Non-plagiarised
3b10bd6d,f2cf6a74,"import java.util.*;
public class B {
    //static int num = (int)Math.pow(10,6);
	static Scanner sc = null;
	public static void main(String[] args) {
		//System.out.println(""Enter :"");
		sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-- >0){
		    int n = sc.nextInt();
		    sc.nextLine();
		    String a[] = new String[n];
		    for(int i=0;i<n;i++){
		        a[i] = sc.nextLine();
		    }
		    ArrayList<Character> a1 = new ArrayList<>();
		    a1.add('a');
		    a1.add('b');
		    a1.add('c');
		    a1.add('d');
		    a1.add('e');
		    int res = 0;
		    for(Character ch : a1){
		        ArrayList<Integer> a2 = new ArrayList<>();
		        for(int i=0;i<n;i++){
		             int f1 = 0;
		             int f2 = 0;
		             String s = a[i];
		             for(int j=0;j<s.length();j++){
		                 char c2 = s.charAt(j);
		                 if(c2==ch)
		                 f1++;
		                 else
		                 f2++;
		             }
		             a2.add(f1-f2);
		        }
		        Collections.sort(a2);
		        int sum = 0;
		        int count = 0;
		        for(int j = n-1;j>=0;j--){
		            int num = a2.get(j);
		            sum+=num;
		            if(sum>0){
		                count++;
		            }
		            else
		            break;
		        }
		        res = Math.max(res,count);
		    }
		    System.out.println(res);
		}
	}
}
","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
11d91f31,4323e2bd,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;

public class ArmChairs {
    static final Random random = new Random();

    

    

    

    public static void main(String[] args) {
        FastReader fs = new FastReader();
        int t = 1;

        for (int z = 0; z < t; z++) {
            int n = fs.nextInt();
            List<Integer> empty = new ArrayList<>();
            List<Integer> chairs = new ArrayList<>();
            for(int i = 0; i < n; i++) {
                int status = fs.nextInt();
                if(status == 1) chairs.add(i+1);
                else empty.add(i+1);
            }
            int[][] dp = new int[empty.size() + 1][chairs.size() + 1];
            dp[0][0] = 0;
            for(int i = 1; i <= chairs.size(); i++) dp[0][i] = (int)3e+8;
            for(int i = 1; i <= empty.size(); i++) {
                for(int j = 1; j <= chairs.size(); j++) {
                    // Shift jth person to ith chair
                    dp[i][j] = dp[i-1][j-1] + Math.abs(empty.get(i-1) - chairs.get(j-1));
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j]);
                }
                //System.out.println(i + "" "" + Arrays.toString(dp[i]));
            }
            //System.out.println(empty.size() + "" "" + chairs.size());
            System.out.println(dp[empty.size()][chairs.size()]);
        }
    }
}
","import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<ArrayList<Integer>> g;
	static long mod=(long)(1e9+7);
	static int D1[],D2[],par[];
	static boolean set[];
	static int value[];
	static long INF=Long.MAX_VALUE;
	static int dp[][];
	static int N,M;
	static int A[][],B[][];
	static int s=1;
	public static void main(String args[])throws IOException
	{  					
		int N=i();
		int A[]=input(N);
		ArrayList<Integer> one=new ArrayList<Integer>();
		ArrayList<Integer> zero=new ArrayList<Integer>();
		for(int i=1; i<=N; i++)
		{
			if(A[i-1]==1)one.add(i);
			else zero.add(i);
		}
		int sum[][]=new int[N+5][N+5];
		for(int i=1; i<=one.size(); i++)
		{
			for(int j=1; j<=zero.size(); j++)
			{
				sum[i][j]=Math.abs(one.get(i-1)-zero.get(j-1));
			}
			//print(sum[i]);
		}
		dp=new int[N+5][N+5];
		//for(int d[]:dp)Arrays.fill(d, Integer.MAX_VALUE);
		Arrays.fill(dp[0], 0);
		for(int i=1; i<=one.size(); i++)
		{
			for(int j=i; j<=zero.size(); j++)
			{
				if(i==j)
				{
					dp[i][j]=dp[i-1][j-1]+sum[i][j];
				}
				else
				{
					dp[i][j]=Math.min(dp[i][j-1], dp[i-1][j-1]+sum[i][j]);
				}
			}
		}
		System.out.println(dp[one.size()][zero.size()]);
//		f(0,0,one,zero,0);
		//for(int d[]:dp)print(d);
		
	}	
	
	
	


	

	
	
	
	
	

	
	
	
	

	static long min(long a,long b,long c)
	{
		return Math.min(a, Math.min(c, b));
	}

	
	
	
	
	

	
	

	
	
	
	
	
	

	//Debugging Functions Starts

	
	
	
	
	

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	
	static int i()
	{
		return in.nextInt();
	}

	

	static int[] input(int N){
		int A[]=new int[N];
		for(int i=0; i<N; i++)
		{
			A[i]=in.nextInt();
		}
		return A;
	}

	

	//IO FUNCTIONS END

}



//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",0,Non-plagiarised
90d0ffd0,b21c7532,"import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class C {

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

    static class Task {
        int n, m;
        char[][] a;
        ArrayList<int[]> moves;

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            n = scan.nextInt();
            m = scan.nextInt();
            a = new char[n][m];
            moves = new ArrayList<>();
            for(int i = 0; i < n; i++) a[i] = scan.next().toCharArray();
            if(n % 2 == 0) {
                for (int i = 0; i < n; i += 2) {
                    if (m % 2 == 0) {
                        for (int j = 0; j < m; j += 2) move(i, j);
                    } else {
                        for (int j = 0; j < m - 3; j += 2) move(i, j);
                        if (one(i, m - 2).size() == 4) {
                            move(i, m - 3);
                            move(i, m - 2);
                        } else {
                            move(i, m - 3);
                            move(i, m - 2);
                        }
                    }
                }
            }
            else {
                for (int i = 0; i < n - 1; i += 2) {
                    if (m % 2 == 0) {
                        for (int j = 0; j < m; j += 2) move(i, j);
                    } else {
                        for (int j = 0; j < m - 3; j += 2) move(i, j);
                        if (one(i, m - 2).size() == 4) {
                            move(i, m - 3);
                            move(i, m - 2);
                        } else {
                            move(i, m - 3);
                            move(i, m - 2);
                        }
                    }
                }
                if (m % 2 == 0) {
                    for (int j = 0; j < m; j += 2) move(n - 2, j);
                } else {
                    for (int j = 0; j < m - 3; j += 2) move(n - 2, j);
                    if (one(n - 2, m - 2).size() == 4) {
                        move(n - 2, m - 3);
                        move(n - 2, m - 2);
                    } else {
                        move(n - 2, m - 3);
                        move(n - 2, m - 2);
                    }
                }
            }
            out.println(moves.size() / 3);
            for(int i = 0; i < moves.size(); i += 3) {
                for(int j = 0; j < 3; j++) out.printf(""%d %d "", moves.get(i + j)[0], moves.get(i + j)[1]);
                out.println();
            }
        }

        void move(int y, int x) {
            ArrayList<int[]> o = one(y, x), z = zero(y, x);
            while(!o.isEmpty()) {
                int first = -1, second = -1;
                if(o.size() <= 2) {
                    first = 1;
                    second = 2;
                }
                else {
                    first = 3;
                    second = 0;
                }
                for(int i = 0; i < first; i++) {
                    int[] t = o.get(i);
                    a[t[0] - 1][t[1] - 1] = '0';
                    moves.add(t);
                }
                for(int i = 0; i < second; i++) {
                    int[] t = z.get(i);
                    a[t[0] - 1][t[1] - 1] = '1';
                    moves.add(t);
                }
                o = one(y, x);
                z = zero(y, x);
            }
        }

        ArrayList<int[]> one(int y, int x) {
            ArrayList<int[]> res = new ArrayList<>();
            for(int i = y + 1; i >= y; i--) {
                for(int j = x + 1; j >= x; j--) {
                    if(a[i][j] == '1') res.add(new int[] {i + 1, j + 1});
                }
            }
            return res;
        }
        ArrayList<int[]> zero(int y, int x) {
            ArrayList<int[]> res = new ArrayList<>();
            for(int i = y; i <= y + 1; i++) {
                for(int j = x; j <= x + 1; j++) {
                    if(a[i][j] == '0') res.add(new int[] {i + 1, j + 1});
                }
            }
            return res;
        }
    }

    

    

    

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

public class B{
	public static void main(String[] args){
		FastReader in = new FastReader(); 
		int t = in.nextInt();
		// int t = 1;
		while(t-- != 0){
			int n = in.nextInt(), m = in.nextInt();
		 	
		 	int[][] arr = new int[n][m];
		 	
		 	for(int i = 0; i < n; i++){
		 		String s = in.next();
		 		for(int j = 0; j < m; j++){
		 			arr[i][j] = s.charAt(j)-'0';
		 		}
		 	}

		 	// for(int i = 0; i < n; i++){
		 	// 	System.out.println(Arrays.toString(arr[i]));
		 	// }
		 	int res = 0;
		 	for(int i = 0; i < n-1; i += 2){
		 		for(int j = 0; j < m-1; j += 2){
		 			int r = arr[i][j] + arr[i][j+1] + arr[i+1][j] + arr[i+1][j+1];
		 			if(r == 1) res += 3;
		 			else if(r == 2) res += 2;
		 			else if(r == 3) res += 1;
		 			else if(r == 4) res += 4;
		 		}
		 	}
		 	
		 	if(n % 2 == 1){
		 		for(int j = 0; j < m-1; j += 2){
		 			int r = arr[n-1][j] + arr[n-1][j+1];
		 			if(r == 1) res += 3;
		 			else if(r == 2) res += 2;
		 		}
		 	}
		 	if(m % 2 == 1){
		 		for(int i = 0; i < n-1; i += 2){
		 			int r = arr[i][m-1] + arr[i+1][m-1];
		 			if(r == 1) res += 3;
		 			else if(r == 2) res += 2;
		 		}	
		 	}

		 	if(n % 2 == 1 && m % 2 == 1){
		 		if(arr[n-1][m-1] == 1) res+= 3;
		 	}

		 	System.out.println(res);

		 	for(int i = 0; i < n-1; i += 2){
		 		for(int j = 0; j < m-1; j += 2){
		 			int a = arr[i][j], b = arr[i][j+1], c = arr[i+1][j], d = arr[i+1][j+1];
		 			int r = a+b+c+d;
		 			if(r == 1){
		 				print1(i+1, j+1, a,b,c,d);
		 			}
		 			else if(r == 2){
		 				print2(i+1, j+1, a,b,c,d);
		 			}
		 			else if(r == 3){
		 				print3(i+1, j+1, a,b,c,d);
		 			}	
		 			else if(r == 4){
		 				print4(i+1, j+1, a,b,c,d);
		 			}
		 		}
		 	}

		 	// System.out.println(""AFTER"");
		 	if(n % 2 == 1){
		 		for(int j = 0; j < m-1; j += 2){
		 			int r = arr[n-1][j] + arr[n-1][j+1];
		 			int a = 0, b = 0, c = arr[n-1][j], d=arr[n-1][j+1];
		 			if(r == 1) print1(n-1,j+1, a,b,c,d);
		 			else if(r==2)print2(n-1,j+1, a,b,c,d);
		 			// System.out.println(""n is od + "" + j);
		 			// System.out.printf(""%d %d %d %d\nABCD\n"", a,b,c,d);
		 		}
		 	}
		 	if(m % 2 == 1){
		 		for(int i = 0; i < n-1; i += 2){
		 			int r = arr[i][m-1] + arr[i+1][m-1];
		 			int a = 0, b = arr[i][m-1], c = 0, d=arr[i+1][m-1];
		 			if(r == 1) print1(i+1,m-1, a,b,c,d);
		 			else if(r==2) print2(i+1,m-1, a,b,c,d);
		 			// System.out.println(""m is odd + "" + i);
		 		}	
		 	}

		 	if(n % 2 == 1 && m % 2 == 1){
		 		if(arr[n-1][m-1] == 1){
		 			print1(n-1, m-1,0,0,0,1);
		 			// System.out.println(""ekeui de "");
		 		}
		 	}

		}
		
		
	}

	public static void print3(int i, int j, int a, int b, int c, int d){
		if(a == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i, j+1, i+1,j, i+1, j+1);//b c d
		}else if(b == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
		}else if(c == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i,j+1,i+1,j+1); //a b d
		}else{
			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i,j+1); //a c b
		}
	}

	public static void print2(int i, int j, int a, int b, int c, int d){
		if(a == 0 && b==0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i,j+1); //a c b
			a = 1;
			b = 1;
			c = 0;
			print3(i, j, a, b, c, d);
		}else if(a == 0 && c == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i,j+1); //a c b
			a = 1;
			c = 1;
			b = 0;
			print3(i, j, a, b, c, d);
		}else if(a == 0 && d == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j+1, i,j+1); //a d b
			a = 1;
			d = 1;
			b = 0;
			print3(i, j, a, b, c, d);
		}else if(b == 0 && d == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j+1,i,j+1); //a d b
			a = 0;
			d = 1;
			b = 1;
			print3(i, j, a, b, c, d);
		}else if(c == 0 && d == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i+1,j,i+1,j+1,i,j+1); //c d b
			c = 1;
			d = 1;
			b = 0;
			print3(i, j, a, b, c, d);
		}else if(c == 0 && b == 0){
			System.out.printf(""%d %d %d %d %d %d\n"", i+1,j, i+1,j+1, i,j+1); //c d b
			c = 1;
			d = 0;
			b = 1;
			print3(i, j, a, b, c, d);
		}
	}

	public static void print1(int i, int j, int a, int b, int c, int d){
		if(a == 1){
			System.out.printf(""%d %d %d %d %d %d\n"", i, j, i+1,j, i+1, j+1);//a c d
			a = 0;
			c=1;
			d=1;
			print2(i, j,a,b,c,d);
		}else if(b == 1){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j+1,i+1,j,i+1,j+1); //b c d
			b=0;
			c=1;
			d=1;
			print2(i, j,a,b,c,d);
		}else if(c == 1){
			System.out.printf(""%d %d %d %d %d %d\n"", i,j, i+1,j, i+1,j+1); // a c d
			c=0;
			a=1;
			d=1;
			print2(i, j,a,b,c,d);
		}else{
			System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
			d=0;
			a=1;
			c=1;
			print2(i, j,a,b,c,d);
		}
	}

	public static void print4(int i, int j, int a, int b, int c, int d){
		System.out.printf(""%d %d %d %d %d %d\n"", i,j,i+1,j,i+1,j+1); // a c d
		a=0;
		d=0;
		c=0;
		print1(i,j,a,b,c,d);
	}


	
}
",0,Non-plagiarised
38601291,3bcd2014,"import java.io.*;
import java.util.*;

public class stones {
    public static void main (String[] args) throws IOException {
        // set up
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        //BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(""test.in"")));
        PrintWriter out = new PrintWriter(System.out);
        int T = Integer.parseInt(input.readLine());
        for (int i=0;i<T;i++) {
            // read in test case
            int n = Integer.parseInt(input.readLine());
            int[] seq = new int[n];
            StringTokenizer st = new StringTokenizer(input.readLine());
            int low = 0;
            int high = 0;
            for (int j=0;j<n;j++) {
                seq[j] = Integer.parseInt(st.nextToken());
                high = Math.max(high, seq[j]);
            }
            // binary search on answer
            while (low<high) {
                int mid = (low+high+1)/2;
                //System.out.println(possible(seq, mid));
                if (possible(seq, mid)) {
                    low = mid; }
                else high = mid-1; }
            out.println(low);
        }
        out.close();

    }

    static boolean possible(int[] seq, int goal) {
        /* checks if array can be made to have smallest value
        greater than or equal to given goal value */
        //System.out.println(goal);
        int L = seq.length;
        int[] arr = Arrays.copyOf(seq, L);
        //System.out.println(Arrays.toString(arr));
        for (int i=L-1;i>=2;i--) {
            //System.out.println(Arrays.toString(arr));
            if (arr[i] < goal) return false;
            int max_d = Math.min((arr[i] - goal)/3, seq[i]/3);
            //System.out.println(arr[i]);
            //System.out.println(max_d);
            arr[i-1] += max_d;
            arr[i-2] += max_d*2;
            arr[i] -= max_d*3;
        }
        //System.out.println(Arrays.toString(arr));
        for (int num: arr) {
            if (num < goal) return false; }
        return true;
    }
}
","import java.io.*;
import java.util.*;

import javax.sound.midi.MidiChannel;

public class Main {
    static PrintWriter out;
    static FastReader sc;

    public static void main(String[] args) throws FileNotFoundException {
        boolean t = true;
        boolean f = false;
        if (f) {
            out = new PrintWriter(""output.txt"");
            sc = new FastReader(""input.txt"");
        } else {
            out = new PrintWriter((System.out));
            sc = new FastReader();
        }

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

    

    

    

    

}
",0,Non-plagiarised
a101df86,dffa45ac,"import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);

		// long mod = 1_000_000_007L;
		// long mod = 998_244_353L;

		int t = sc.nextInt();

		for ( int zzz=0; zzz<t; zzz++ ) {

			int n = sc.nextInt();

			int[] a = new int[n];
			String[] b = new String[n];
			for ( int i=0; i<n; i++ ) {
				a[i] = sc.nextInt();
			}

			int pos = 0;
			if ( n%2==1 ) {
				int a01 = a[0]+a[1];
				if ( a01==0 ) {
					a01 = a[0]-a[1];
					b[0] = String.valueOf(a[2]);
					b[1] = String.valueOf(0-a[2]);
					b[2] = String.valueOf(0-a01);
				} else {
					b[0] = String.valueOf(a[2]);
					b[1] = String.valueOf(a[2]);
					b[2] = String.valueOf(0-a01);
				}

				pos = 3;
			}

			for ( int i=pos; i<n; i=i+2 ) {
				b[i] = String.valueOf(a[i+1]);
				b[i+1] = String.valueOf(0-a[i]);
			}

			System.out.println(String.join("" "", b));
		}
	}
}
","import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);

		// long mod = 1_000_000_007L;
		// long mod = 998_244_353L;

		int t = sc.nextInt();

		for ( int zzz=0; zzz<t; zzz++ ) {

			int n = sc.nextInt();

			int[] a = new int[n];
			String[] b = new String[n];
			for ( int i=0; i<n; i++ ) {
				a[i] = sc.nextInt();
			}

			int pos = 0;
			if ( n%2==1 ) {
				int a01 = a[0]+a[1];
				if ( a01==0 ) {
					a01 = a[0]-a[1];
					b[0] = String.valueOf(a[2]);
					b[1] = String.valueOf(0-a[2]);
					b[2] = String.valueOf(0-a01);
				} else {
					b[0] = String.valueOf(a[2]);
					b[1] = String.valueOf(a[2]);
					b[2] = String.valueOf(0-a01);
				}

				pos = 3;
			}

			for ( int i=pos; i<n; i=i+2 ) {
				b[i] = String.valueOf(a[i+1]);
				b[i+1] = String.valueOf(0-a[i]);
			}

			System.out.println(String.join("" "", b));
		}
	}
}
",1,Plagiarised
3d88acb8,8aadde13,"import java.util.*;
import java.io.*;
public class D {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt();
			int[] arr = new int[n];
			for(int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			if(check(arr)) System.out.println(""YES"");
			else System.out.println(""NO"");
		}

	}
	static boolean check(int[] arr) {
		int n = arr.length;
		TreeSet<Integer> set = new TreeSet<>();
		set.add(arr[0]);
		for(int i = 1; i < n; i++) {
			set.add(arr[i]);
			if(arr[i-1] == arr[i]) continue;
			Integer x = set.lower(arr[i]);
			if(x != null && x == arr[i-1]) continue;
			x = set.higher(arr[i]);
			if(x != null && x == arr[i-1]) continue;
			return false;
		}
		return true;
	}
	
	

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class A {
    public static void main(String args[]) throws Exception {
        FastScanner sc = new FastScanner();
        int T = 1;
        T = sc.nextInt();
        PrintWriter pw = new PrintWriter(System.out);
        while (T-- > 0) {
            solve(sc, pw);
        }
        pw.close();
    }

    public static void solve(FastScanner sc, PrintWriter pw) throws Exception {
        int n = sc.nextInt();
        int[] arr = new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        if(check(arr)) pw.println(""YES"");
        else pw.println(""NO"");
    }

    public static boolean check(int[] arr){
        int n=arr.length;
        TreeSet<Integer> S = new TreeSet<>();
        S.add(arr[0]);
        for(int i=1;i<n;i++) {
            S.add(arr[i]);
            if (arr[i] == arr[i - 1]) continue;
            Integer lb = S.lower(arr[i]);
            if (lb != null && lb == arr[i - 1]) continue;
            Integer ub = S.higher(arr[i]);
            if (ub != null && ub == arr[i - 1]) continue;
            return false;
        }
        return true;
    }

    
}
",1,Plagiarised
01c915a2,480de7be,"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[];
	

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

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

					     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;
					    
					            }
					            
					            
					            public String toString() {
					                return x + "" "" + y+"" ""+z;
					            }
					            
					    
					     
					    }
					    
					    }
","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 hasMoreTokens(){
            return peekToken()!=null;
        }
        public int getInt(){
            return Integer.parseInt(nextToken());
        }
        
        
        public String getWord(){
            return nextToken();
        }
        
        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
4e9c4bf9,7011024d,"import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class E1525D {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int[] arr = new int[n];
        ArrayList<Integer> occupied = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            arr[i] = scn.nextInt();
            if (arr[i] == 1) occupied.add(i);
        }
        int[][] dp = new int[n + 1][occupied.size() + 1];
        for (int[] row : dp) Arrays.fill(row, (int) 1e9);
        dp[0][0] = 0;
        for (int i = 1; i <= n; i++) {
            dp[i][0] = 0;
            for (int j = 1; j <= occupied.size(); j++) {
                dp[i][j] = dp[i - 1][j];
                if (arr[i - 1] == 0)
                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1] + Math.abs(i - 1 - occupied.get(j - 1)));
            }
        }
        System.out.println(dp[n][occupied.size()]);


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

public class D {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayList<Integer> occupied = new ArrayList<>();
        ArrayList<Integer> vacant = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            if (x == 1)
                occupied.add(i);
            else
                vacant.add(i);
        }

        Solution Solution = new Solution(occupied, vacant);

//        System.out.println(Solution.tabulation());
        System.out.println(Solution.memoization());
    }
}

class Solution {

    ArrayList<Integer> occupied, vacant;
    int x, y;

    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
        this.occupied = occupied;
        this.vacant = vacant;
        x = occupied.size(); y = vacant.size();
    }

    

    

    int 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
316c9955,e7370eec,"import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.LinkedList;

public class C {

    private static boolean[] visited;
    private static Node[] nodes;

    private static void run() throws IOException {
        int n = in.nextInt();
        nodes = new Node[n];
        for (int i = 0; i < n; i++) {
            nodes[i] = new Node();
            nodes[i].index = i;
            nodes[i].l = in.nextInt();
            nodes[i].r = in.nextInt();
        }
        for (int i = 0; i < n - 1; i++) {
            int x = in.nextInt() - 1;
            int y = in.nextInt() - 1;
            nodes[x].next.add(y);
            nodes[y].next.add(x);
        }

        visited = new boolean[n];
        dfs(0);
        out.println(Math.max(nodes[0].ans_l, nodes[0].ans_r));
    }

    private static void dfs(int now) {
        visited[now] = true;

        for (int next : nodes[now].next) {
            if (visited[next]) continue;

            dfs(next);
            nodes[now].ans_l += Math.max(nodes[next].ans_l + Math.abs(nodes[now].l - nodes[next].l), nodes[next].ans_r + Math.abs(nodes[now].l - nodes[next].r));
            nodes[now].ans_r += Math.max(nodes[next].ans_l + Math.abs(nodes[now].r - nodes[next].l), nodes[next].ans_r + Math.abs(nodes[now].r - nodes[next].r));
        }
    }

    static class Node {
        int index;
        long l, r;
        long ans_l, ans_r;
        LinkedList<Integer> next = new LinkedList<>();
    }

    public static void main(String[] args) throws IOException {
        in = new Reader();
        out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            run();
        }

        out.flush();
        in.close();
        out.close();
    }

    

    static final long mod = 1000000007;

    

    

    @SuppressWarnings(""FieldCanBeLocal"")
    private static Reader in;
    private static PrintWriter out;

    

    

    

    

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

public class C {
    static InputReader in;
    static PrintWriter out;

    public static void main(String[] args) {
        //initReaderPrinter(true);
        initReaderPrinter(false);
        solve(in.nextInt());
        //solve(1);        
    }
    static int n;
    static List<Integer>[] adj;
    static long[] l, r;
    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            n = in.nextInt();
            adj = new List[n + 1];
            for(int i = 0; i <= n; i++) {
                adj[i] = new ArrayList<>();
            }
            l = new long[n + 1];
            r = new long[n + 1];
            for(int i = 1; i <= n; i++) {
                l[i] = in.nextInt();
                r[i] = in.nextInt();
            }
            for(int i = 0; i < n - 1; i++) {
                int u = in.nextInt();
                int v = in.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            long[] ans = dfs(1, 0);
            out.println(Math.max(ans[0], ans[1]));
        }
        out.close();
    }

    static long[] dfs(int curr, int par) {
        long[] ans = new long[2];
        for(int next : adj[curr]) {
            if(next == par) continue;
            long[] nextAns = dfs(next, curr);
            ans[0] += Math.max(nextAns[0] + Math.abs(l[curr] - l[next]), nextAns[1] + Math.abs(l[curr] - r[next]));
            ans[1] += Math.max(nextAns[0] + Math.abs(r[curr] - l[next]), nextAns[1] + Math.abs(r[curr] - r[next]));
        }
        return ans;
    }

    static void initReaderPrinter(boolean test) {
        if (test) {
            try {
                in = new InputReader(new FileInputStream(""src/input.in""));
                out = new PrintWriter(new FileOutputStream(""src/output.out""));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            in = new InputReader(System.in);
            out = new PrintWriter(System.out);
        }
    }

    
}
",0,Non-plagiarised
7814575b,8cfe3ee0,"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);
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class Comprog {

    static FastReader fr = new FastReader();

    private static void testCase() {
        int n = fr.nextInt();
        int [][] scoreChanges = new int [5][n];
        int [] totalScores = new int [5];

        // initialize
        for (int i = 0; i < 5; i++)
            totalScores[i] = 0;
        
        for (int i = 0; i < 5; i++)
            for (int j = 0; j < n; j++)
                scoreChanges[i][j] = 0;
        
        for (int wordIndex = 0; wordIndex < n; wordIndex++) {
            String nextWord = fr.nextLine();
            for (int charIndex = 0; charIndex < 5; charIndex++) {
                // How many more of the current char ('a' or 'b' or etc.) are in nextWord than
                // the total number of chars in it
                int change = 2 * countCharsInString(nextWord, (char) ('a' + charIndex)) - nextWord.length();
                totalScores[charIndex] += change;
                scoreChanges[charIndex][wordIndex] = change;
            }
        }


        for (int charIndex = 0; charIndex < 5; charIndex++)
            Arrays.sort(scoreChanges[charIndex]);

        int round = 0;
        boolean done = false;
        while (round < n && !done) {
            for (int charIndex = 0; charIndex < 5; charIndex++) {
                if (totalScores[charIndex] > 0) {
                    System.out.println(n - round);
                    done = true;
                    break;
                }
                totalScores[charIndex] -= scoreChanges[charIndex][round];
            }
            round++;
        }
        if (!done)
            System.out.println(0);
    }


    public static int countCharsInString(String str, char c) {
        int cnt = 0;
        for (int i = 0; i < str.length(); i++)
            if (str.charAt(i) == c)
                cnt++;
        return cnt;
    }

    public static void main(String[] args) {
        int t;
        t = fr.nextInt();
        for (int i = 0; i < t; i++)
            testCase();
    }




    

    



    
}
",0,Non-plagiarised
6d55e68b,d8a171a3,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class _1615C16 {

  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(in.readLine());
    int n;
    int s1, e1;
    char[] start, end;
    for (int s = 0; s < t; s++) {
      n = Integer.parseInt(in.readLine());
      start = in.readLine().toCharArray();
      end = in.readLine().toCharArray();
      s1 = 0;
      e1 = 0;
      for (int i = 0; i < n; i++) if (start[i] == '1') s1++;
      for (int i = 0; i < n; i++) if (end[i] == '1') e1++;
      if (e1 == n - s1 + 1) {
        for (int i = 0; i < n; i++) {
          if (start[i] == '1') start[i] = '0';
          else start[i] = '1';
        }
        int ct = 0;
        for (int i = 0; i < n; i++) if (start[i] != end[i]) ct++;
        int ct2 = Integer.MAX_VALUE;
        if (s1 == e1) {
          for (int i = 0; i < n; i++) {
            if (start[i] == '1') start[i] = '0';
            else start[i] = '1';
          }
          ct2 = 0;
          for (int i = 0; i < n; i++) if (start[i] != end[i]) ct2++;
        }
        System.out.println(Math.min(ct, ct2));
      } else if (s1 == e1) {
        int ct = 0;
        for (int i = 0; i < n; i++) if (start[i] != end[i]) ct++;
        int ct2 = Integer.MAX_VALUE;
        if (e1 == n - s1 + 1) {
          ct2 = 0;
          for (int i = 0; i < n; i++) if (start[i] != end[i]) ct2++;
        }
        System.out.println(Math.min(ct, ct2));
      } else {
        System.out.println(-1);
      }
    }
  }
}
","import java.io.*;
import java.util.*;

public class B {
	
	public static void main(String[] args)throws IOException {
		
		FastScanner scan = new FastScanner();
		PrintWriter output = new PrintWriter(System.out);
		int t = scan.nextInt();
		for(int tt = 0;tt<t;tt++) {
			int n = scan.nextInt();
			char initial[] = scan.next().toCharArray();
			char desired[] = scan.next().toCharArray();
			int lit1 = 0, lit2 = 0;
			int ans = Integer.MAX_VALUE;
			for(int i = 0;i<n;i++) {
				if(initial[i]=='1') lit1++;
				if(desired[i]=='1') lit2++;
			}
			if(lit1==lit2) {
				int count = 0;
				for(int i = 0;i<n;i++) if(initial[i]!=desired[i]) count++;
				ans = Math.min(ans, count);
			}
			if(lit2==(n-lit1+1)) {
				int count = 0;
				for(int i = 0;i<n;i++) if(initial[i]==desired[i]) count++;
				ans = Math.min(ans, count);
			}
			if(ans == Integer.MAX_VALUE) ans = -1;
			output.println(ans);	
		}
		output.flush();
	}
	
	
	
	
	
	
	
	

}
",0,Non-plagiarised
9d1bfd29,fe07e031,"import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintWriter;
    import java.util.*;
 
    public class SetorDecrease {
        static InputReader inputReader=new InputReader(System.in);
        static void solve()
        {
            int n=inputReader.nextInt();
            long k=inputReader.nextLong();
            long sum=0;
            long arr[]=new long[n];
            for (int i=0;i<n;i++)
            {
                arr[i]=inputReader.nextLong();
            }
            SortDec(arr);
            for (int i=0;i<n-1;i++)
            {
                sum+=arr[i];
            }
            long ans=Long.MAX_VALUE;
            for (int i=0;i<n;i++)
            {
               long remval=k-sum;
               long val=fdiv(remval,i+1);
               ans=Math.min(ans,i+Math.max(arr[n-1]-val,0));
               sum-=arr[i];
            }
            out.println(ans);
        }
        static void SortDec(long arr[])
        {
            List<Long>list=new ArrayList<>();
            for(long ele:arr)
            {
                list.add(ele);
            }
            Collections.sort(list,Collections.reverseOrder());
            int n=arr.length;
            for (int i=0;i<n;i++)
            {
                arr[i]=list.get(i);
 
            }
 
        }
       static long fdiv(long X, long Y) {
            if (X >= 0) {
                return X / Y;
            } else {
                return (X-Y+1) / Y;
            }
        }
        static PrintWriter out=new PrintWriter((System.out));
        public static void main(String args[])throws IOException
        {
            int t=inputReader.nextInt();
            while (t-->0) {
                solve();
            }
                out.close();
        }
        
    }
","import java.io.*;
import java.util.*;


public class Main {
    static int i, j, k, n, m, t, y, x, sum = 0;
    static long mod = 998244353;
    static FastScanner fs = new FastScanner();
    static PrintWriter out = new PrintWriter(System.out);
    static String str;

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

        t = fs.nextInt();

        while (t-- > 0) {

            n = fs.nextInt();
            long k = fs.nextLong();

            long sum=0;

            int[] arr = fs.readArray(n);

            for(i=0;i<n;i++)
                sum+=arr[i];

            Arrays.sort(arr);

            long[] suffix = new long[n];

            suffix[n-1] = arr[n-1]-arr[0];

            for(i=n-2;i>=0;i--){
                suffix[i] = suffix[i+1]+arr[i]-arr[0];
            }

            long ans = sum-k;

            if(ans<=0){
                out.println(0);
                continue;
            }

            for(i=n-1;i>0;i--){

                long temp = sum-k;
                long ansHere;
                if(suffix[i]>=temp){
                    ansHere = n-i;
                }

                else{
                    long y = temp - suffix[i];

                    long x = n-i+1;

                    long moves = y/x;

                    if(y%x!=0)
                        moves++;

                    ansHere = moves+(n-i);
                }

                ans = Math.min(ans,ansHere);
            }

            out.println(ans);

        }

        out.close();
    }

   /*static long nck(int n , int k){
        long a = fact[n];
        long b = modInv(fact[k]);
        b*= modInv(fact[n-k]);
        b%=mod;

        return (a*b)%mod;
    }

   static void populateFact(){
        fact[0]=1;

        fact[1] = 1;

        for(i=2;i<300005;i++){
            fact[i]=i*fact[i-1];
            fact[i]%=mod;
        }
    }
    */


    

    

    

    

    


    

}
",0,Non-plagiarised
f28b8cb4,ff3283cf,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    

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

        int q = Integer.parseInt(br.readLine());

        for (int i = 0; i < q; i++) {
            br.readLine();

            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());

            // read input a
            st = new StringTokenizer(br.readLine());
            int[] a = new int[k];
            for (int j = 0; j < k; j++) {
                a[j] = Integer.parseInt(st.nextToken());
            }

            // read input t
            st = new StringTokenizer(br.readLine());
            int[] t = new int[k];
            for (int j = 0; j < k; j++) {
                t[j] = Integer.parseInt(st.nextToken());
            }

            // known temperatures
            int[] c = new int[n];
            Arrays.fill(c, Integer.MAX_VALUE);
            for (int j = 0; j < k; j++) {
                c[a[j] - 1] = t[j];
            }

            // temperature from left to right
            long[] left = new long[n];
            Arrays.fill(left, Integer.MAX_VALUE);
            long p = Integer.MAX_VALUE;
            for (int j = 0; j < n; j++) {
                p = Math.min(p + 1, c[j]);
                left[j] = p;
            }

            // temperature from right to left
            long[] right = new long[n];
            Arrays.fill(right, Integer.MAX_VALUE);
            p = Integer.MAX_VALUE;
            for (int j = n - 1; j >= 0; j--) {
                p = Math.min(p + 1, c[j]);
                right[j] = p;
            }

            for (int j = 0; j < n; j++) {
                System.out.print(Math.min(left[j], right[j]) + "" "");
            }
            System.out.println();
        }
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codeforces {
    public static void main(String[] args) throws java.lang.Exception {
        /* your code goes here */
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
       int t = Integer.parseInt(buf.readLine());
        StringBuilder sb = new StringBuilder();
       for (int i = 0; i < t; i++) {
           String st=buf.readLine();
          String st1[]=(buf.readLine()).split("" "");
          int n=Integer.parseInt(st1[0]);
          int k=Integer.parseInt(st1[1]);
          int a[]=new int[k];
          int temp[]=new int[k];
          long arr[]=new long[n];
          String st2[]=(buf.readLine()).split("" "");
           String st3[]=(buf.readLine()).split("" "");
           for(int j=0;j<k;j++)
           {
               a[j]=Integer.parseInt(st2[j]);
               temp[j]=Integer.parseInt(st3[j]);
           }
          for(int j=0;j<k;j++)
          {
              arr[a[j]-1]=temp[j];
          }
          long min=Integer.MAX_VALUE;
          long left[]=new long[n];
          long right[]=new long[n];
          if(arr[0]==0)
              left[0]=min;
          else
              left[0]=arr[0];
          for(int j=1;j<n;j++)
          {
              if(arr[j]==0)
              {
                  left[j]=left[j-1]+1;
              }
              else
              {
                  left[j]=Math.min(left[j-1]+1,arr[j]);
              }
          }
          if(arr[n-1]==0)
              right[n-1]=min;
          else
              right[n-1]=arr[n-1];
          for(int j=n-2;j>=0;j--)
          {
              if(arr[j]==0)
              {
                  right[j]=right[j+1]+1;
              }
              else
              {
                  right[j]=Math.min(right[j+1]+1,arr[j]);
              }
          }
          for(int j=0;j<n;j++)
          {
              arr[j]=Math.min(left[j],right[j]);
              sb.append(arr[j]+"" "");
          }
          sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
",0,Non-plagiarised
6e207cbf,e19376ca,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        int sm, n;
        while(t > 0) {
            t--;
            n = sc.nextInt();
            String s1,s2;
            s1 = sc.next();
            s2 = sc.next();
            int a[] = new int[4];
            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
            for(int i = 0 ; i < n ; i++) {
                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
                else a[3]++;
            }
            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
            
            if (a[0] == a[1]) {
                n1 = 2*a[0];
            }
            if((a[2] - 1) == a[3]) {
                // System.out.println(a[3] + 1);
                n2 = 2*a[3] + 1;
            } 
            if((a[3] + 1) == a[2]) {
                // System.out.println(a[2] + 1);
                n3 = 2*a[2] + 1;
            } 
            int ans = Math.min(n1, Math.min(n2,n3));
            if(ans == Integer.MAX_VALUE) {
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
	}
}
","import java.io.*;
import java.util.*;

public class new1{

    
    public static int count(int[] arr, int[] dest) {
    	int n = arr.length;
    	int count = 0;
    	for(int i = 0; i < n; i++) {
    		if(arr[i] != dest[i]) count++;
    	}
    	return count;
    }
    
    
    

	
	public static void main(String[] args)  throws IOException{
    	BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		FastReader s = new FastReader();
		int t = s.nextInt();
		
		
    	for(int z = 0; z < t; z++) {
    		int n = s.nextInt();
    		String str1 = s.next();
    		String str2 = s.next();
    		int count1  = 0; int count2 = 0;
    		for(int i = 0; i < n; i++) {
    			if(str1.charAt(i) == '1') count1++;
    			if(str2.charAt(i) == '1') count2++;
    		}
    		if(!(count1 == count2 || n - count1 + 1 == count2)) {
    			System.out.println(-1);
    			continue;
    		}
    		
    		int[] arr = new int[n];
    		int[] dest = new int[n];
    		for(int i = 0; i < n; i++) {
    			arr[i] = str1.charAt(i) - '0';
    			dest[i] = str2.charAt(i) - '0';
    		}
    		int ans1 = count(arr, dest);
    		int ans2 = Integer.MAX_VALUE;
    		int flag = 0;
    		for(int i = 0; i < n; i++) {
    			if(flag == 0 && arr[i] == 1 && dest[i] == 1) {
    				flag = 1;
    			}
    			else {
    				arr[i] = 1 - arr[i];
    			}
    		}
    		//System.out.println(ans1);
    		if(flag == 1) {
    			ans2 = Math.min(ans2, count(arr, dest) + 1);
    		}
    		else {
    			for(int i = 0; i < n; i++) {
    				if(str1.charAt(i) == '1' && flag == 0) {
    					flag = 1; arr[i] = 1;
    					break;	
    				}
    			}
    			
    		}
    		if(flag == 1) ans2 = Math.min(ans2, count(arr, dest) + 1);
    		int ans = Integer.MAX_VALUE;
    		if(count1 == count2) ans = Math.min(ans, ans1);
    		if(n - count1 + 1 == count2) ans = Math.min(ans, ans2);
    		System.out.println(ans);
    		
    		
    		
    	}
    	//output.flush();

    }
}



",0,Non-plagiarised
856a8eda,a3e272af,"import java.io.*;
import java.util.*;

public class three{
	public static class Pair implements Comparable<Pair>{
		int min;
		int idx;
		
	}

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 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 + ""]"";
    //     }
    // }
    //--------------------------------------------------------
}
","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
        
        }
    
    /* 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();
       
    }

    

    

    

    

    

    

}
",0,Non-plagiarised
2695ce73,ac8acb97,"import java.io.*;
import java.util.*;

public class c {
/*
3
2
13 88
3
2 3 1
5
4 3 2 1 4

202
13
19

+ - + - +
1, 2
2, 1
3, 3
*/
	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		
		int t = in.nextInt();
		for ( ; t > 0; t--) {
			int n = in.nextInt();
			long[] vals = new long[n];
			for (int i = 0; i < n; i++)
				vals[i] = in.nextInt();
			
				
			// System.out.println(Arrays.toString(pre));
			// sSystem.out.println(Arrays.toString(pre1));
			
			long oo = (long)(1e18);
			long[] min = {oo, oo};
			long[] sub = {n, n};
			long sum = 0;
			long max = oo;
			for (int i = 0; i < n; i++) {
				min[i % 2] = Math.min(min[i % 2], vals[i]);
				sub[i % 2]--;
				sum += vals[i];
				if (i > 0) {
					max = Math.min(max, sum + min[0] * sub[0] + min[1] * sub[1]);
				}
			}
			out.println(max);
		}
		
		
		out.close();
	}
	
	
}
","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
5f3a2a70,e7a997b5,"import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;

public class Main {

    private static Node[] nodes;
    private static boolean[] visited;

    private static void run() throws IOException {
        int n = in.nextInt();

        nodes = new Node[n];
        for (int i = 0; i < n; i++) {
            nodes[i] = new Node();
        }

        Edge[] edges = new Edge[n - 1];

        for (int i = 0; i < n - 1; i++) {
            edges[i] = new Edge();
            edges[i].id = i;
            edges[i].u = in.nextInt() - 1;
            edges[i].v = in.nextInt() - 1;

            nodes[edges[i].u].edge.add(edges[i]);
            nodes[edges[i].v].edge.add(edges[i]);
        }

        for (int i = 0; i < n; i++) {
            if (nodes[i].edge.size() >= 3) {
                out.println(-1);
                return;
            }
        }

        int end_pos = 0;
        visited = new boolean[n];
        while (nodes[end_pos].edge.size() != 1) {
            end_pos++;
        }

        visited = new boolean[n];
        dfs(end_pos, 2);

        for (int i = 0; i < n - 1; i++) {
            out.print(edges[i].ans);
            out.print(' ');
        }
        out.println();
    }

    private static void dfs(int now, int d) {
        visited[now] = true;
        for (Edge edge : nodes[now].edge) {
            if (visited[edge.get_next(now)]) {
                continue;
            }

            edge.ans = d;
            dfs(edge.get_next(now), d ^ 1);
        }
    }

    private static class Node {
        ArrayList<Edge> edge = new ArrayList<>();
    }

    private static class Edge {
        int id, u, v, ans = -1;

        int get_next(int now) {
            return now != u ? u : v;
        }
    }

    public static void main(String[] args) throws IOException {
        in = new Reader();
        out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            run();
        }

        out.flush();
        in.close();
        out.close();
    }

    

    static final long mod = 1000000007;

    

    

    

    @SuppressWarnings(""FieldCanBeLocal"")
    private static Reader in;
    private static PrintWriter out;

    

    

    

    

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

}


",0,Non-plagiarised
2ff0355e,83935617,"import java.io.*;
import java.util.*;

public class PhoenixAndTowers {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	
	static class Pair implements Comparable<Pair> {
		int val, idx;
		Pair (int val, int idx) { this.val = val; this.idx = idx; }
		
	}
	public static void main(String[] args) throws IOException {
		int T = readInt();
		for (int t = 0; t < T; t ++) {
			int n = readInt(), m = readInt(), x = readInt();
			Pair[] h = new Pair[n + 1];
			h[0] = new Pair(100000, 0);
			for (int i = 1; i <= n; i ++) h[i] = new Pair(readInt(), i);
			Arrays.sort(h, Collections.reverseOrder());
			
			int[] ans = new int[n + 1], sum = new int[m + 1];

			PriorityQueue<Pair> q = new PriorityQueue<Pair>();
			for (int i = 1; i <= m; i ++) q.add(new Pair(0, i));
			for (int i = 1; i <= n; i ++) {
				Pair p = q.poll();
				sum[p.idx] += h[i].val;
				ans[h[i].idx] = p.idx;
				q.add(new Pair(p.val + h[i].val, p.idx));
			}
			
			
			int max = 0, min = Integer.MAX_VALUE;
			for (int i = 1; i <= m; i ++) {
				max = Math.max(max, sum[i]);
				min = Math.min(min, sum[i]);
			}
			
			if (max - min > x) System.out.println(""NO"");
			else {
				System.out.println(""YES"");
				for (int i = 1; i < n; i ++) System.out.print(ans[i] + "" "");
				System.out.println(ans[n]);
			}
		}
	}

	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());
	}
	
	
	static String readLine() throws IOException {
		return br.readLine().trim();
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

// Created by @thesupremeone on 02/05/21
public class C {
    static class Tower implements Comparable<Tower>{
        int index;
        int height = 0;
        LinkedList<Integer> blocks;
        public Tower(int index) {
            this.index = index;
            blocks = new LinkedList<>();
        }
        void addBlock(int block){
            blocks.add(block);
            height += block;
        }
        
    }

    void solve() throws IOException {
        int ts = getInt();
        for (int t = 1; t <= ts; t++){
            int n = getInt();
            int m = getInt();
            int x = getInt();
            Integer[] h = new Integer[n];
            Integer[] org = new Integer[n];
            for (int i = 0; i < n; i++){
                h[i] = getInt();
                org[i] = h[i];
            }
            if(m==1){
                println(""YES"");
                for (int i = 0; i < n; i++) {
                    print(""1 "");
                }
                println("""");
                continue;
            }
            TreeSet<Tower> towers = new TreeSet<>();
            for (int i = 0; i < m; i++){
                Tower tower = new Tower(i+1);
                towers.add(tower);
            }
            Arrays.sort(h, Comparator.reverseOrder());
            for (int i = 0; i < n; i++) {
                Tower tower = towers.pollFirst();
                if(tower!=null){
                    tower.addBlock(h[i]);
                    towers.add(tower);
                }
            }
            Tower first = towers.first();
            Tower last = towers.last();
            int diff = Math.abs(first.height-last.height);
            if(diff<=x){
                println(""YES"");
                HashMap<Integer, LinkedList<Integer>> map = new HashMap<>();
                for (Tower tower : towers){
                    for(int block : tower.blocks){
                        LinkedList<Integer> list;
                        if(map.containsKey(block)){
                            list = map.get(block);
                        }else {
                            list = new LinkedList<>();
                            map.put(block, list);
                        }
                        list.add(tower.index);
                    }
                }
                for (int i = 0; i < n; i++) {
                    int block = org[i];
                    LinkedList<Integer> list = map.get(block);
                    if(!list.isEmpty()){
                        int e = list.pollFirst();;
                        print(e+"" "");
                    }
                }
                println("""");
            }else {
                println(""NO"");
            }
        }
    }

    public static void main(String[] args) throws Exception {
        if (isOnlineJudge()) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new BufferedWriter(new OutputStreamWriter(System.out));
            new C().solve();
            out.flush();
        } else {
            Thread judge = new Thread();
            in = new BufferedReader(new FileReader(""input.txt""));
            out = new BufferedWriter(new FileWriter(""output.txt""));
            judge.start();
            new C().solve();
            out.flush();
            judge.suspend();
        }
    }
    static boolean isOnlineJudge(){
        try {
            return System.getProperty(""ONLINE_JUDGE"")!=null
                    || System.getProperty(""LOCAL"")==null;
        }catch (Exception e){
            return true;
        }
    }
    // Fast Input & Output
    static BufferedReader in;
    static StringTokenizer st;
    static BufferedWriter out;
    static String getLine() throws IOException{
        return in.readLine();
    }
    static String getToken() throws IOException{
        if(st==null || !st.hasMoreTokens())
            st = new StringTokenizer(getLine());
        return st.nextToken();
    }
    static int getInt() throws IOException {
        return Integer.parseInt(getToken());
    }
    
    static void print(Object s) throws IOException{
        out.write(String.valueOf(s));
    }
    static void println(Object s) throws IOException{
        out.write(String.valueOf(s));
        out.newLine();
    }
}
",0,Non-plagiarised
04df7bb8,ee270b2a,"import java.math.BigInteger;
										import java.sql.Array;
									    import java.util.ArrayList;
										import java.util.Arrays;
										import java.util.Collection;
										import java.util.Collections;
										import java.util.Comparator;
										import java.util.Deque;
										import java.util.HashMap;
										import java.util.HashSet;
										import java.util.InputMismatchException;
										import java.util.LinkedList;
										import java.util.PriorityQueue;
										import java.util.Queue;
										import java.util.Scanner;
										import java.util.Set;
										import java.util.Stack;
										import java.io.BufferedReader;
										import java.io.IOException;
										import java.io.InputStream;
										import java.io.InputStreamReader;
										import java.util.Scanner;
										import java.util.StringTokenizer;
										import java.util.TreeMap;
										import java.util.TreeSet;
										
											
											
											
											
											
											public class Main {
							
												
												static HashMap<Integer,Boolean>map;
												
											static long dp[][];
											static 	boolean flag;
										static	HashSet<Long>hs;
											static long mod=(long)(1e9+7);
												public static void main(String[] args) {
												StringBuilder ans=new StringBuilder();
												FastReader sc=new FastReader();
													
												
												int t=sc.nextInt();
												
												
												while(t-->0) {
													
													int n=sc.nextInt();
													
													
													//int n=sb.length();
													
													
													
													int k=sc.nextInt();
													
													
													long L[]=new long[n];
													long R[]=new long[n];
													int a[]=new int[k];
													int temp[]=new int[k];
													
													for(int i=0;i<k;i++)
														a[i]=sc.nextInt();
													
													for(int i=0;i<k;i++)
														temp[i]=sc.nextInt();
													
													int c[]=new int [n];
													Arrays.fill(c, Integer.MAX_VALUE);
													for(int i=0;i<k;i++)
														c[a[i]-1]=temp[i];
												
													long p=Integer.MAX_VALUE;
													
													for(int i=0;i<n;i++)
													{
														p=Math.min(p+1, c[i]);
														
														L[i]=p;
														
														
													}
													p=Integer.MAX_VALUE;
													for(int i=n-1;i>=0;i--)
													{
														p=Math.min(p+1, c[i]);
														
														R[i]=p;
														
														
													}
													
													for(int i=0;i<n;i++)
													{
														ans.append(Math.min(L[i], R[i])+"" "");
													}
											ans.append(""\n"");
													
												}
												System.out.println(ans);
												
												}
													
											
													


												
												
							
												
												
												
												
												
												
												
												
											
												
												
												
												
												
												
												
												
												
												
												
												
												
													
													
												
												
												
												
												
												
												
												
												
												
												
												
												
												
												
									
												
												
											
												
										
												
												
												
												
												
											 
												
											 
												
												
												
											
												
											
												
												
												
												
												
												 
												  
												
												   
												
									
												//System.out.println(count);
												
											
												
												
												
												
												
												
										
										
												
										
												
												
												
												
												//	System.out.println(max);
										
												
											
												
											
									
				//System.out.println(ans.toString());
				//main(						
											
							
					
				
						
												
												
												
								
												
								
												
												
								
												
												
												
												
												
												
												
									
									
												
												
												
												
								
								
								
							
								
									
												
												
												
								
												
												
												
									
							
												
									
									
												
												
												
												
												
												
												
												
												
												
												
									
										
										
										
										
				
				
					
				
				
										
											
																					
											
									    
									 
										
											}
","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
3d88acb8,b6023b26,"import java.util.*;
import java.io.*;
public class D {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt();
			int[] arr = new int[n];
			for(int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			if(check(arr)) System.out.println(""YES"");
			else System.out.println(""NO"");
		}

	}
	static boolean check(int[] arr) {
		int n = arr.length;
		TreeSet<Integer> set = new TreeSet<>();
		set.add(arr[0]);
		for(int i = 1; i < n; i++) {
			set.add(arr[i]);
			if(arr[i-1] == arr[i]) continue;
			Integer x = set.lower(arr[i]);
			if(x != null && x == arr[i-1]) continue;
			x = set.higher(arr[i]);
			if(x != null && x == arr[i-1]) continue;
			return false;
		}
		return true;
	}
	
	

}
","import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<ArrayList<Integer>> g;
	static long mod=1000000007;
	static int D1[],D[],par[];
	static boolean set[];
	static long INF=Long.MAX_VALUE;
	public static void main(String args[])throws IOException
	{  	

		int T=i();
		while(T-->0)
		{
			int N=i();
			long A[]=inputLong(N);
			boolean f=true;
			TreeSet<Long> set=new TreeSet<>();
			for(int i=0; i<N; i++)
			{
				if(i>=2)
				{
					if(A[i]<A[i-1])
					{
						if(set.ceiling(A[i]+1)!=A[i-1])f=false;
					}
					if(A[i]>A[i-1])
					{
						if(set.floor(A[i]-1)!=A[i-1])f=false;
					}
				}
				set.add(A[i]);
			}
			if(f)System.out.println(""YES"");
			else System.out.println(""NO"");
		}
	}

	
	
	
	
	

	

	
	
	
	
	

	
	

	
	
	
	
	
	

	//Debugging Functions Starts

	
	
	
	
	

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	
	static int i()
	{
		return in.nextInt();
	}

	

	

	static long[] inputLong(int N)     {
		long A[]=new long[N];
		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
		return A;
	}

	//IO FUNCTIONS END

}
//class pair implements Comparable<pair>{
//	int index; long a;
//	pair(long a,int index)
//	{
//		this.a=a;
//		this.index=index;
//	}
//	public int compareTo(pair X)
//	{
//		if(this.a>X.a)return 1;
//		if(this.a==X.a)return this.index-X.index;
//		return -1;
//	}
//}

//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",0,Non-plagiarised
3d06b643,6bcc5afd,"import java.io.*;
import java.util.*;

public class ArmChairs {
    

    public static int solution(int n, int[] arr) {

        ArrayList<Integer> one = new ArrayList<Integer>();
        ArrayList<Integer> zero = new ArrayList<Integer>();

        for (int i = 0; i < n; i++) {
            if (arr[i] == 1) {
                one.add(i);
            } else {
                zero.add(i);
            }
        }

        int[][] dp = new int[one.size() + 1][zero.size() + 1];

        for (int i = 1; i <= one.size(); i++) {
            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
            for (int j = i + 1; j <= zero.size(); j++) {
                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
            }
        }

        return dp[one.size()][zero.size()];
    }


    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());

        String[] s = br.readLine().split("" "");
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(s[i]);
        } 

        log.write(Integer.toString(solution(n, arr)) + ""\n"");
        log.flush();
        
    }

}
","import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner s=new Scanner(System.in);
     int n=s.nextInt();
     int a[]=new int[n];
     ArrayList<Integer> lt1=new ArrayList<>();
     ArrayList<Integer> lt0=new ArrayList<>();
     for(int i=0;i<n;i++)
     {
         int l=s.nextInt();
         if(l==0)
         lt0.add(i+1);
         else
         lt1.add(i+1);
     }
     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
     for(int i=1;i<=lt1.size();i++)
     {
         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
         for(int j=i+1;j<=lt0.size();j++)
         {
             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
         }
     }
     System.out.println(dp[lt1.size()][lt0.size()]);
     
    }
}
",1,Plagiarised
ae4d5b49,f665e87b,"import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException{
        //BufferedReader f = new BufferedReader(new FileReader(""uva.in""));
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int t = Integer.parseInt(f.readLine());
        while(t-- > 0) {
            int n = Integer.parseInt(f.readLine());
            int[][] occ = new int[n][6];
            for(int i = 0; i < n; i++) {
                char[] temp = f.readLine().toCharArray();
                for(char j: temp) {
                    occ[i][j-'a']++;
                }
                occ[i][5] = occ[i][0]+occ[i][1]+occ[i][2]+occ[i][3]+occ[i][4];
            }
            int max = 0;
            for(int i = 0; i < 5; i++) {
                int[] temp = new int[n];
                for(int j = 0; j < n; j++) {
                    temp[j] = occ[j][i]-(occ[j][5]-occ[j][i]);
                }
                Arrays.sort(temp);
                int j;
                int cur = 0;
                for(j = n-1; j >= 0; j--) {
                    if(cur+temp[j] <= 0) {
                        break;
                    }
                    cur += temp[j];
                }
                max = Math.max(max, n-j-1);
            }
            out.println(max);
        }
        f.close();
        out.close();
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.TreeMap;


public class C_CF {

    public static void main(String[] args) {
        FastScanner57 fs = new FastScanner57();
        PrintWriter pw = new PrintWriter(System.out);
        int t = fs.ni();
        //int t = 1;
        for (int tc = 0; tc < t; tc++) {
            int n = fs.ni();
            String[] s = new String[n];
            for (int i = 0; i < n; i++) {
                s[i] = fs.next();
            }
            int res = c(0,s);
            for (int i = 1; i < 5; i++) {
                res = Math.max(res,c(i,s));
            }
            pw.println(res);
        }
        
        pw.close();

    }
    public static int c(int l, String[] s) {
        List<Integer> list = new ArrayList();
        for (int i = 0; i < s.length; i++) {
            String t = s[i];
            int ct = 0;
            for (int j = 0; j < t.length(); j++) {
                if (t.charAt(j)-'a'==l) {
                    ct++;
                } else {
                    ct--;
                }
            }
            list.add(ct);
        }
        Collections.sort(list);
        Collections.reverse(list);
        int sum = 0;
        for (int i = 0; i < s.length; i++) {
            sum += list.get(i);
            if (sum<=0) return i;
        }
        return list.size();
    }
    

    

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

    

}




",0,Non-plagiarised
53196443,e496d229,"import java.lang.*;
import java.util.*;
import java.io.*;

public class Main {
    static FastScanner in = new FastScanner();

    static void solve() {
        int n = in.nextInt();
        long[] a = new long[n], odd = new long[n], even = new long[n];
        long[] sum = new long[n];
        long m1 = Long.MAX_VALUE, m2 = Long.MAX_VALUE;
        long st = 0;

        for (int i = 0; i < n; ++i) {
            a[i] = in.nextLong();
            if (i % 2 == 0 && a[i] < m1)
                m1 = a[i];
            if (i % 2 == 1 && a[i] < m2)
                m2 = a[i];
            st += a[i];
            odd[i] = m1; even[i] = m2;
            sum[i] = st;
        }

        long ans = Long.MAX_VALUE;
        for (int i = 1; i < n; ++i) {
            long aux = sum[i] + odd[i] * (n - i - 1 + (i + 1) / 2) + even[i] * (n - (i + 1) / 2);
            if (aux < ans && aux > 0)
                ans = aux;
        }

        System.out.println(ans);
    }

    public static void main(String[] args) {
        int T = in.nextInt();
        while (T-- > 0)
            solve();
    }

    
}


","import java.util.*;
//import java.util.Stack;


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();
            long[] a=new long[n];
            long[] odd=new long[n];
            long[] even=new long[n];
            long[] sum=new long[n];
            long m1=Long.MAX_VALUE;
            long m2=Long.MAX_VALUE;
            long st=(long)0;
            for(int i=0;i<n;i++){
              a[i]=s.nextLong();
              if(i%2==0&&m1>a[i])
                  m1=a[i];
              if(i%2==1&&m2>a[i])
                  m2=a[i];
              st+=a[i];
              odd[i]=m1;
              even[i]=m2;
              sum[i]=st;
            }
            long minc=Long.MAX_VALUE;
            for(int i=1;i<n;i++){

                long c=sum[i]+odd[i]*(n-i-1+(i+1)/2)+even[i]*(n-(i+1)/2);
                if(c<minc&&c>0)
                    minc=c;
            }
            System.out.println(minc);
        }
    }
}
",1,Plagiarised
016510dc,f1540246,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class TaskC {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Solver {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(),m = in.nextInt();
            int[][] a = new int[n][m];
            for(int i=0;i<n;i++){
                String s = in.next();
                for(int j=0;j<m;j++){
                    a[i][j] = (s.charAt(j)-'0');
                }
            }
            ArrayList<Pair> ans = new ArrayList<>();
            for(int i=0;i<=n-2;i++){
                for(int j=0;j<=m-2;j++) {
                    int cnt = 0;
                    if (a[i][j] == 1) cnt++;
                    if (a[i + 1][j] == 1) cnt++;
                    if(a[i][j+1]==1) cnt++;
                    if(a[i+1][j+1]==1) cnt++;
                    if(cnt==4){
                        a[i][j] = 0;
                        a[i+1][j] = 0;
                        a[i+1][j+1] = 0;
                        ans.add(new Pair((i+1),(j+1)));
                        ans.add(new Pair((i+2),(j+1)));
                        ans.add(new Pair((i+2),(j+2)));
//                        out.println();
                        cnt = 1;
                    }
                    if(cnt==1){
                        boolean flag = false;
                        for(int x=0;x<2;x++){
                            for(int y=0;y<2;y++){
                                if(a[i+x][j+y]==1){
//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
                                    ans.add(new Pair((i+1+x),(j+1+y)));
                                    int cnt2 = 1;
                                    for(int sx=0;sx<2;sx++){
                                        for(int sy=0;sy<2;sy++){
                                            if(a[i+sx][j+sy]!=1){
//                                                out.print((i+sx+1)+"" ""+(j+1+sy)+"" "");
                                                a[i+sx][j+sy]=1;
                                                ans.add(new Pair((i+sx+1),(j+sy+1)));
                                                cnt2++;
                                                if(cnt2==3){
                                                    a[i+x][j+y]=0;
                                                    flag = true;
                                                    break;
                                                }
                                            }
                                        }
                                        if(flag) break;
                                    }
                                    if(flag) break;
                                }
                                if(flag) break;
                            }
                            if(flag) break;
                        }
//                        out.println();
                        cnt = 2;
                    }
                    if(cnt==2){
                        boolean flag = false;
                        for(int x=0;x<2;x++){
                            for(int y=0;y<2;y++){
                                if(a[i+x][j+y]==1){
//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
                                    ans.add(new Pair((i+1+x),(j+1+y)));
                                    int cnt2 = 1;
                                    for(int sx=0;sx<2;sx++){
                                        for(int sy=0;sy<2;sy++){
                                            if(a[i+sx][j+sy]!=1){
//                                                out.print((i+sx+1)+"" ""+(j+1+sy)+"" "");
                                                cnt2++;
                                                ans.add(new Pair((i+sx+1),(j+1+sy)));
                                                a[i+sx][j+sy]=1;
                                                if(cnt2==3){
                                                    a[i+x][j+y]=0;
                                                    flag = true;
                                                    break;
                                                }
                                            }
                                        }
                                        if(flag) break;
                                    }
                                    if(flag) break;
                                }
                                if(flag) break;
                            }
                            if(flag) break;
                        }
//                        out.println();
                        cnt = 3;
                    }
                    if(cnt==3){
                        for(int x=0;x<2;x++){
                            for(int y=0;y<2;y++){
                                if(a[i+x][j+y]==1){
                                    a[i+x][j+y]=0;
                                    ans.add(new Pair((i+1+x),(j+1+y)));
//                                    out.print((i+1+x)+"" ""+(j+1+y)+"" "");
                                }
                            }
                        }
//                            out.println();
                    }
                }
            }
            out.println((ans.size())/3);
            for(int i=0;i<ans.size();i+=3){
                for(int j=0;j<=2;j++){
                    out.print(ans.get(i+j).a+"" ""+ans.get(i+j).b+ "" "");
                }
                out.println();
            }
        }
    }
    static class Pair{
        int a,b;
        public Pair(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    
}
","import java.io.*;
import java.util.*;

public class C {
    static InputReader in;
    static PrintWriter out;

    public static void main(String[] args) {
        //initReaderPrinter(true);
        initReaderPrinter(false);
        solve(in.nextInt());
        //solve(1);        
    }

    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            int n = in.nextInt(), m = in.nextInt();
            char[][] g = new char[n][];
            for(int i = 0; i < n; i++) {
                g[i] = in.next().toCharArray();
            }
            List<List<Integer>> list = new ArrayList<>();
            for(int i = 0; i < n - 1; i++) {
                for(int j = 0; j < m - 1; j++) {
                    list.addAll(change(g, i, j));
                }
            }
            out.println(list.size());
            for(int i = 0; i < list.size(); i++) {
                for(int j = 0; j < 6; j++) {
                    out.print(list.get(i).get(j) + "" "");
                }
                out.println();
            }
        }
        out.close();
    }

    static List<List<Integer>> change(char[][] g, int i, int j) {
        List<List<Integer>> list = new ArrayList<>();
        int cnt = 0;
        cnt += g[i][j] - '0';
        cnt += g[i][j + 1] - '0';
        cnt += g[i + 1][j] - '0';
        cnt += g[i + 1][j + 1] - '0';
        if(cnt != 0) {
            if(cnt == 4) {
                List<Integer> op = new ArrayList<>();
                op.add(i + 1); op.add(j + 1 + 1); op.add(i + 1 + 1); op.add(j + 1); op.add(i + 1 + 1); op.add(j + 1 + 1);
                list.add(op);
                g[i][j + 1] = '0';
                g[i + 1][j] = '0';
                g[i + 1][j + 1] = '0';
                cnt = 1;
            }
            if(cnt == 1) {
                List<Integer> op = new ArrayList<>();
                int zeroCnt = 0;
                for(int k1 = 0; k1 < 2; k1++) {
                    for(int k2 = 0; k2 < 2; k2++) {
                        if(g[i + k1][j + k2] == '0' && zeroCnt < 2) {
                            op.add(i + k1 + 1);
                            op.add(j + k2 + 1);
                            zeroCnt++;
                        }
                        else if(g[i + k1][j + k2] == '1'){
                            op.add(i + k1 + 1);
                            op.add(j + k2 + 1);
                        }
                    }
                }
                list.add(op);
                zeroCnt = 0;
                for(int k1 = 0; k1 < 2; k1++) {
                    for(int k2 = 0; k2 < 2; k2++) {
                        if(g[i + k1][j + k2] == '0' && zeroCnt < 2) {
                            g[i + k1][j + k2] = '1';
                            zeroCnt++;
                        }
                        else if(g[i + k1][j + k2] == '1'){
                            g[i + k1][j + k2] = '0';
                        }
                    }
                }
                cnt = 2;
            }
            if(cnt == 2) {
                List<Integer> op = new ArrayList<>();
                int oneCnt = 0;
                for(int k1 = 0; k1 < 2; k1++) {
                    for(int k2 = 0; k2 < 2; k2++) {
                        if(g[i + k1][j + k2] == '0') {
                            op.add(i + k1 + 1);
                            op.add(j + k2 + 1);
                        }
                        else if(oneCnt < 1){
                            op.add(i + k1 + 1);
                            op.add(j + k2 + 1);
                            oneCnt++;
                        }
                    }
                }
                list.add(op);
                oneCnt = 0;
                for(int k1 = 0; k1 < 2; k1++) {
                    for(int k2 = 0; k2 < 2; k2++) {
                        if(g[i + k1][j + k2] == '0') {
                            g[i + k1][j + k2] = '1';
                        }
                        else if(oneCnt < 1){
                            g[i + k1][j + k2] = '0';
                            oneCnt++;
                        }
                    }
                }
                cnt = 3;
            }
            if(cnt == 3) {
                List<Integer> op = new ArrayList<>();
                for(int k1 = 0; k1 < 2; k1++) {
                    for(int k2 = 0; k2 < 2; k2++) {
                        if(g[i + k1][j + k2] == '1') {
                            op.add(i + k1 + 1);
                            op.add(j + k2 + 1);
                        }
                    }
                }
                list.add(op);
            }
            for(int k1 = 0; k1 < 2; k1++) {
                for(int k2 = 0; k2 < 2; k2++) {
                    g[i + k1][j + k2] = '0';
                }
            }
        }
        return list;
    }

    static void initReaderPrinter(boolean test) {
        if (test) {
            try {
                in = new InputReader(new FileInputStream(""src/input.in""));
                out = new PrintWriter(new FileOutputStream(""src/output.out""));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            in = new InputReader(System.in);
            out = new PrintWriter(System.out);
        }
    }

    
}
",0,Non-plagiarised
7686c854,abd16ff0,"import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.IntToLongFunction;
import java.lang.*;
import java.io.*;
import java.math.*;
public final class CF
{
     public static void main(String[]args)throws IOException
    {
        FastReader ob=new FastReader();
        int t=ob.nextInt();
        StringBuffer sb=new StringBuffer();
        while(t-->0)
        {
            int n=ob.nextInt();
            PriorityQueue<Long> a=new PriorityQueue<>();
            PriorityQueue<Long> b=new PriorityQueue<>();
            long ans=Long.MAX_VALUE;
            long sum=0;
            for(int i=0;i<n;i++)
            {
               long x=ob.nextInt();
               if(i%2==0)
               a.add(x);
               else
               b.add(x);  
               sum+=x;
               if(i!=0)
               ans=Math.min(ans,sum+(a.peek()*(n-a.size()))+(b.peek()*(n-b.size())));
            }
            
            sb.append(ans+""\n"");
        }
        System.out.println(sb);
    }
}


","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
72d9eb5b,af0deeab,"import java.util.*;
import java.io.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();

            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }

            Collections.sort(blue);
            Collections.sort(red);

            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
","import java.io.*;
import java.util.*;

public class Solution {
    static int M = 998244353;
    static Random rng = new Random();

    private static boolean testCase(int n, int[] a, String colors) {
        boolean[] contains = new boolean[n];
        int any = 0, rem = n, idx;
        List<Integer> fromLeft = new ArrayList<>(), fromRight = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            if (colors.charAt(i) == 'B') {
                if (a[i] <= 0) {
                    return false;
                } else if (a[i] >= n) {
                    any++;
                } else {
                    fromLeft.add(a[i]);
                }
            } else {
                if (a[i] > n) {
                    return false;
                } else if (a[i] <= 1) {
                    any++;
                } else {
                    fromRight.add(a[i]);
                }
            }
        }

        sort(fromLeft);
        sort(fromRight);

        //System.out.println(fromLeft);
        //System.out.println(fromRight);

        idx = 1;

        for (int i = 0; i < fromLeft.size(); i++) {
            //try to assign a[i] to idx
            //System.out.println(String.format(""Assign %d to %d"", a[i], idx));
            if (fromLeft.get(i) < idx) {
                return false;
            } else {
                contains[idx - 1] = true;
                rem--;
                idx++;
            }
        }

        idx = n;

        for (int i = fromRight.size() - 1; i >= 0; i--) {
            //System.out.println(String.format(""Assign %d to %d"", a[i], idx));
            if (idx < fromRight.get(i)) {
                return false;
            } else {
                contains[idx - 1] = true;
                rem--;
                idx--;
            }
        }

        return any >= rem;
    }

    public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt();  // Scanner has functions to read ints, longs, strings, chars, etc.
        //in.nextLine();
        for (int tt = 1; tt <= t; ++tt) {
            int n = in.nextInt();
            int[] a = in.readArray(n);
            String colors = in.next();

            out.println(testCase(n, a, colors) ? ""YES"" : ""NO"");
        }

        out.close();
    }

    

    private static void sort(int[] arr) {
        int temp, idx;

        for (int i = arr.length - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
        }

        Arrays.sort(arr);
    }

    private static void sort(long[] arr) {
        long temp;
        int idx;

        for (int i = arr.length - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
        }

        Arrays.sort(arr);
    }

    private static <T> void sort(T[] arr) {
        T temp;
        int idx;

        for (int i = arr.length - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
        }

        Arrays.sort(arr);
    }

    private static <T> void sort(T[] arr, Comparator<? super T> cmp) {
        T temp;
        int idx;

        for (int i = arr.length - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
        }

        Arrays.sort(arr, cmp);
    }

    private static <T extends Comparable<? super T>> void sort(List<T> list) {
        T temp;
        int idx;

        for (int i = list.size() - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = list.get(i);
            list.set(i, list.get(idx));
            list.set(idx, temp);
        }

        Collections.sort(list);
    }

    private static <T> void sort(List<T> list, Comparator<? super T> cmp) {
        T temp;
        int idx;

        for (int i = list.size() - 1; i > 0; i--) {
            idx = rng.nextInt(i + 1);

            temp = list.get(i);
            list.set(i, list.get(idx));
            list.set(idx, temp);
        }

        Collections.sort(list, cmp);
    }
}
",0,Non-plagiarised
7d7cf9a7,e45446bc,"import java.util.*;
import java.io.*;
import java.math.*;

public class Coder {
  static int n;
  static long c[];
  static StringBuilder str = new StringBuilder("""");
  static void solve() {
      long mne=c[0];
      long mno=c[1];
      long ans=(c[0]+c[1])*n;
      long se=c[0];
      long so=c[1];
      long ecnt=1,ocnt=1;
      for(int i=2;i<n;i++){
          if(i%2==0){mne=Math.min(mne, c[i]);se+=c[i];ecnt++;}
          else{mno=Math.min(mno, c[i]);so+=c[i];ocnt++;}
          
          ans=Math.min(ans, se+mne*(n-ecnt)+so+mno*(n-ocnt));
      }
      str.append(ans).append(""\n"");
  }

  public static void main(String[] args) throws java.lang.Exception {
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    int q = Integer.parseInt(bf.readLine().trim());
    while(q-->0) {
        n=Integer.parseInt(bf.readLine().trim());
        c=new long[n];
        String s[]=bf.readLine().trim().split(""\\s+"");
        for(int i=0;i<n;i++) c[i]=Long.parseLong(s[i]);
      solve();
    }
    System.out.print(str);
  }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class C {

//	            ***                          ++                      
//             +=-==+                      +++=-                     
//            +-:---==+                   *+=----=                   
//           +-:------==+               ++=------==                  
//           =-----------=++=========================                
//          +--:::::---:-----============-=======+++====             
//          +---:..:----::-===============-======+++++++++           
//          =---:...---:-===================---===++++++++++         
//          +----:...:-=======================--==+++++++++++        
//          +-:------====================++===---==++++===+++++      
//         +=-----======================+++++==---==+==-::=++**+     
//        +=-----================---=======++=========::.:-+*****    
//       +==::-====================--:  --:-====++=+===:..-=+*****   
//       +=---=====================-...  :=..:-=+++++++++===++*****  
//       +=---=====+=++++++++++++++++=-:::::-====+++++++++++++*****+ 
//      +=======++++++++++++=+++++++============++++++=======+****** 
//      +=====+++++++++++++++++++++++++==++++==++++++=:...  . .+**** 
//     ++====++++++++++++++++++++++++++++++++++++++++-.     ..-+**** 
//     +======++++++++++++++++++++++++++++++++===+====:.    ..:=++++ 
//     +===--=====+++++++++++++++++++++++++++=========-::....::-=++* 
//     ====--==========+++++++==+++===++++===========--:::....:=++*  
//     ====---===++++=====++++++==+++=======-::--===-:.  ....:-+++   
//     ==--=--====++++++++==+++++++++++======--::::...::::::-=+++    
//     ===----===++++++++++++++++++++============--=-==----==+++     
//     =--------====++++++++++++++++=====================+++++++     
//     =---------=======++++++++====+++=================++++++++     
//     -----------========+++++++++++++++=================+++++++    
//     =----------==========++++++++++=====================++++++++  
//     =====------==============+++++++===================+++==+++++ 
//     =======------==========================================++++++

//	 created by : Nitesh Gupta

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();
		while (t-- > 0) {
			String[] scn = (br.readLine()).trim().split("" "");
			int n = Integer.parseInt(scn[0]);
			long[] arr = new long[n];
			scn = (br.readLine()).trim().split("" "");
			for (int i = 0; i < n; i++) {
				arr[i] = Long.parseLong(scn[i]);
			}
			long min;
			long hor = arr[0], ver = arr[1];
			long min1 = 0, min2 = 0;
			min = (hor + ver) * n;
			long x = 0, y = 0;
			for (int i = 2; i < n; i++) {
				if (i % 2 == 0) {
					x += 1;
					if (arr[i] >= hor) {
						min1 += arr[i];
					} else {
						min1 += hor;
						hor = arr[i];
					}
					
					
				} else {
					y += 1;
					if (arr[i] >= ver) {
						min2 += arr[i];
					} else {
						min2 += ver;
						ver = arr[i];
					}
				}
				long pro =  (n - x) * hor + (n - y) * ver;
				min = Math.min(min, min1 + min2 +pro);
			}
			sb.append(min);
			sb.append(""\n"");
		}
		System.out.println(sb);
		return;

	}

	

	

	

}
",0,Non-plagiarised
884f5678,cf27732e,"import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class JaiShreeRam{
	static Scanner in=new Scanner();
	static long mod = 1000000007;
	static ArrayList<ArrayList<Integer>> adj;
	public static void main(String[] args) throws Exception{
		
		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 int[] nia(int n){
		int[] arr= new int[n];
		int i=0;
		while(i<n){
			arr[i++]=in.readInt();
		}
		return arr;
	}
	
	
	
		
}
","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 ----------------------
	

	

}
",0,Non-plagiarised
7974ffba,94b3b86d,"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;


    }
    
    
    


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


   

   
}
",0,Non-plagiarised
3dd65549,f229aa7f,"import java.util.*;
import java.io.*;

public class codeforces {
	public static void main(String[] args) throws Exception {
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt();
			char[] a=sc.next().toCharArray();
			char[] b=sc.next().toCharArray();
			int e0=0;
			int e1=0;
			int o0=0;
			int o1=0;
			for(int i=0;i<n;i++) {
				if(a[i]!=b[i]) {
					if(a[i]=='1') {
						e1++;
					}else {
						e0++;
					}
				}else {
					if(a[i]=='1') {
						o1++;
					}else {
						o0++;
					}
				}
			}
			int ans=Integer.MAX_VALUE;
			
			if(e1==e0) {
				ans=Math.min(ans, e1+e0);
			}
			if(o1==o0+1) {
				ans=Math.min(ans, o1+o0);
			}
//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
			pw.println(ans==Integer.MAX_VALUE?-1:ans);
		}
		pw.close();
	}

	

	

	

	static long mod = 1000000007;
	static Random rn = new Random();
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
}
","import java.util.*;
import java.io.*;
import java.math.*;

public class cf {
	static PrintWriter pw = new PrintWriter(System.out);

	public static void main(String[] args) throws IOException, InterruptedException {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();
			char[] a = sc.next().toCharArray();
			char[] b = sc.next().toCharArray();
			int x = 0, y = 0, lit = 0,lit2 = 0;
			for (int i = 0; i < n; i++) {
				if (a[i] == '1')
					lit++;
				if (b[i] == '1')
					lit2++;
				if (a[i] == b[i])
					x++;
				else
					y++;
			}
			if(lit == lit2 || n - lit + 1 == lit2) {
				if (lit == lit2 && n - lit + 1 == lit2) {
					pw.println(Math.min(x,y));
				}else if(lit == lit2) {
					pw.println(y);
				}else {
					pw.println(x);
				}
			}else {
				pw.println(-1);
			}
		}
		pw.close();
	}

	

	

	

}
",0,Non-plagiarised
60557643,948e98b6,"import java.util.Scanner;

public class D {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int lines = s.nextInt();

        s.nextLine();

        for (int i = 0; i < lines; i += 1) {
            solve(s.nextInt(), s);
        }
    }


    public static void solve(int n, Scanner s) {
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = s.nextInt();
        }

        int b[] = new int[n];
        for (int i = 0; i + 1 < n; i += 2) {
            b[i + 1] = a[i];
            b[i] = -a[i + 1];
        }

        while (b[n - 2] == 0 || b[n - 1] == 0) {
            b[n - 1] += a[n - 2];
            b[n - 2] -= a[n - 1];
        }
        
        StringBuilder erg = new StringBuilder();
        for (int i = 0; i < n; i++) {
            erg.append(b[i]).append("" "");
        }

        System.out.println(erg);
    }
}
","import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

import java.util.*;

public class Main
{

  

    public static void main(String[] args)
    {
        FastScanner input = new FastScanner();
       StringBuilder result = new StringBuilder();
        int tc = input.nextInt();
        while (tc-- > 0) {
          int n = input.nextInt();
      int a[] = new int[n];
      int b[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = input.nextInt();
            
        }
        if(n%2==0)
        {
            for (int i = 0; i <n; i+=2) {
                b[i] = a[i+1];
                b[i+1] = -a[i];
            }
        }
        else
        {
            
            for (int i = 0; i <n-3; i+=2) {
                b[i] = a[i+1];
                b[i+1] = -a[i];
            }
            int last1 = a[n-3];
            int last2 = a[n-2];
            int last3 = a[n-1];
            if(last1+last2!=0)
            {
                b[n-3] = -last3;
                b[n-2] = -last3;
                b[n-1] = (last1+last2);
            }
            else if(last1+last3!=0)
            {
                b[n-3] = -last2;
                b[n-2] = (last1+last3);
                b[n-1] = -last2;
            }
            else if(last2+last3!=0)
            {
                b[n-3] =(last2+last3);
                b[n-2] = -last1;
                b[n-1] = -last1;
            }
        }
        for (int i : b) {
            result.append(i+"" "");
        }
        result.append(""\n"");   
        }
        System.out.println(result);
        
      
    }

    

}
",0,Non-plagiarised
9028caf7,a4e39423,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","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 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;
    }

    
}
",0,Non-plagiarised
c34bb733,ea899386,"import java.io.*;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.math.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Vector;
import static java.lang.Math.sqrt;
import static java.lang.Math.floor;






public class topcoder {
   
	


	
	
	
static class pairr implements  Comparable<pairr>{
	Integer value;
	Integer index;
	
	   public pairr(Integer value, Integer index) {
		    this.value = value;
		    this.index = index;
	   }
	   
}



	 
	
	
	 
	 
	 
	 
	 
	 
	 
		     
		     
		     
		     
			  
			  
			  
			      
			    // Prints all prime numbers smaller than 'n'
			
			    
			    
			    
			 
               
            
			  public static int add(long n, long num, long a, int i) {
				//System.out.println(num);
				  if(num > n)return -1;
				
				  if(num == n) {
					  
					  return i;
				  }
				  
				if(a < 2050)return -1;
				  
				
				 
				  long temp = num+a;
				  
				  if(temp <= n) {
				return	  add(n,temp,a,i+1);
				  }else if(temp > n){
					  a /= 10;
					  return add(n,num,a,i);
				  }
				  
			      return -1;
				  }
			
				   
		
		
		
		
		
		
		
		
		
		  
		  

		    
		    
		    
		    
		    
		
		
			
	    
	   
	  
			
	    public static void main(String args[])throws IOException{
			 
	    	//	 System.setIn(new FileInputStream(""Case.txt""));
	    		 BufferedReader ob = new BufferedReader(new InputStreamReader(System.in));
	    	    
	    		 
	    		 int t = Integer.parseInt(ob.readLine());
	    		 
	    		 
	    		 while( t--> 0) {
	    		
	    		StringTokenizer	 st = new StringTokenizer(ob.readLine());
	    			 int n = Integer.parseInt(st.nextToken());
	    			 int m = Integer.parseInt(st.nextToken());
	    			 int x = Integer.parseInt(st.nextToken());
	    			 
	    			 int []ar = new int[n];
	    			 st = new StringTokenizer(ob.readLine());
	    			 PriorityQueue<Integer>pq = new PriorityQueue<>();
	    			 
	    			 for(int i = 0; i < n; i++) {
	    				 ar[i] = Integer.parseInt(st.nextToken());
	    				 pq.add(ar[i]);
	    			 }
	    			 
	    			 
	    	PriorityQueue<pairr>p = new PriorityQueue<>();
	    	for(int i =0; i < n; i++) {
	    		p.add(new pairr(ar[i],i));
	    	}
	    	int []ans = new int[n];
	    	
	    	
	    	for(int i = 0; i < n; i++) {
	    	pairr a = p.poll();
	    	ans[a.index] = (i%m)+1;
	    	}
	    	
	    	System.out.println(""YES"");
	    	for(int i = 0; i < n; i++ ) {
	    		System.out.print(ans[i]+"" "");
	    	}
	    	System.out.println();
	    		 }
	    }
}
","import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static class Tower implements Comparable<Tower>{
		int val;
		int index;
		public Tower(int ind, int v) {
			val = v;
			index = ind;
		}
		
	}
	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
2fdcf0ad,d20e861b,"import java.util.*;
import java.io.*;

import static java.lang.Math.*;

public class Main {
    static Scanner sc = new Scanner(System.in);
    static PrintWriter pw = new PrintWriter(System.out);

    static int[][] map;
    static int n, m;

    static ArrayList<String> actions = new ArrayList<>();
    static String[] move = new String[]{"""", ""0110"", ""1001"", ""1101"", ""1001"", ""1110"", ""1011"", ""0000"", ""0110"", ""0111"", ""1101"", ""0000"", ""0111"", ""0000"", ""0000"", ""0001""};
    static int[] xdif = new int[]{0, 0, 1, 1}, ydif = new int[]{0, 1, 0, 1};

    public static void main(String[] args) throws IOException {
        int tests = sc.nextInt();
        for (int t = 0; t < tests; t++)
            solve();
        pw.close();
    }

    static void solve() throws IOException {
        n = sc.nextInt();
        m = sc.nextInt();
        map = new int[n][m];
        actions.clear();
        for (int i = 0; i < n; i++) {
            String line = sc.next();
            for (int j = 0; j < m; j++)
                map[i][j] = line.charAt(j) - '0';
        }
        if (n % 2 + m % 2 == 2)
            removeCorner();
        if (n % 2 == 1)
            for (int y = 0; y + 1 < m; y += 2)
                removeDown(y);
        if (m % 2 == 1)
            for (int x = 0; x + 1 < n; x += 2)
                removeRight(x);
        for (int x = 0; x + 1 < n; x += 2)
            for (int y = 0; y + 1 < m; y += 2)
                square(x, y);
        pw.println(actions.size());
        for (String action : actions)
            pw.println(action);
    }

    static void square(int x, int y) {
        String type = """" + map[x][y] + map[x][y + 1] + map[x + 1][y] + map[x + 1][y + 1];
        if (map[x][y] + map[x + 1][y] + map[x][y + 1] + map[x + 1][y + 1] > 0) {
            int[][] poses = new int[3][];
            int index = 0;
            for (int t = 0; t < 4; t++) {
                if (map[x + xdif[t]][y + ydif[t]] != move[Integer.parseInt(type, 2)].charAt(t) - '0')
                    poses[index++] = new int[]{x + xdif[t], y + ydif[t]};
            }
            action(poses[0][0], poses[0][1], poses[1][0], poses[1][1], poses[2][0], poses[2][1]);
            square(x, y);
        }
    }

    static void invert(int x, int y) {
        map[x][y] = 1 - map[x][y];
    }

    static void removeCorner() {
        if (map[n - 1][m - 1] == 1)
            action(n - 1, m - 1, n - 2, m - 1, n - 1, m - 2);
    }

    static void removeRight(int x) {
        int y = m - 1;
        if (map[x][y] + map[x + 1][y] == 2)
            action(x, y, x + 1, y, x, y - 1);
        else if (map[x][y] == 1)
            action(x, y, x, y - 1, x + 1, y - 1);
        else if (map[x + 1][y] == 1)
            action(x + 1, y, x, y - 1, x + 1, y - 1);
    }

    static void removeDown(int y) {
        int x = n - 1;
        if (map[x][y] + map[x][y + 1] == 2)
            action(x, y, x, y + 1, x - 1, y);
        else if (map[x][y] == 1)
            action(x, y, x - 1, y, x - 1, y + 1);
        else if (map[x][y + 1] == 1)
            action(x, y + 1, x - 1, y, x - 1, y + 1);
    }

    static void action(int x1, int y1, int x2, int y2, int x3, int y3) {
        actions.add((x1 + 1) + "" "" + (y1 + 1) + "" "" + (x2 + 1) + "" "" + (y2 + 1) + "" "" + (x3 + 1) + "" "" + (y3 + 1));
        invert(x1, y1);
        invert(x2, y2);
        invert(x3, y3);
    }
}



","import java.util.*;

public class CodeForces{
// 4
//   -3 -5 -2 1
// k  2  4  0 3
static ArrayList<int[]> ans = new ArrayList<>();
    
    public static void add(int a,int b,int c,int d,int e,int f){
        int[] tem=new int[6];
        tem[0]=a;tem[1]=b;tem[2]=c;tem[3]=d;tem[4]=e;tem[5]=f;
        ans.add(tem);
    }
   public static void helper(int[][] arr,int r,int c){
       for(int k=0;k<12;k++){
           if(arr[r][c]==1){
               add(r,c,r+1,c,r,c+1);
               arr[r][c]=1-arr[r][c];
               arr[r+1][c]=1-arr[r+1][c];
               arr[r][c+1]=1-arr[r][c+1];
           }
           if(arr[r][c+1]==1){
                add(r,c+1,r+1,c+1,r,c);
               arr[r][c+1]=1-arr[r][c+1];
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r][c]=1-arr[r][c];
           }
           if(arr[r+1][c]==1){
                add(r+1,c+1,r,c,r+1,c);
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r][c]=1-arr[r][c];
               arr[r+1][c]=1-arr[r+1][c];
           }
           if(arr[r+1][c+1]==1){
                add(r+1,c+1,r+1,c,r,c+1);
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r+1][c]=1-arr[r+1][c];
               arr[r][c+1]=1-arr[r][c+1];
           }
           
       }
       
   } 
   public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
		    int n = sc.nextInt();
		    int m = sc.nextInt();
		    ans.clear();
		    int[][] arr=new int[n][m];
		    for(int i=0;i<n;i++){
		        String str = sc.next();
		        for(int j=0;j<m;j++){
		            arr[i][j]=str.charAt(j)-'0';
		        }
		    }
		    
		    for(int i=0;i<n;i+=2){
		        for(int j=0;j<m;j+=2){
		            if(i==n-1&&j==m-1){
		                helper(arr,i-1,j-1);
		            }else if(i==n-1){
		                helper(arr,i-1,j);
		            }else if(j==m-1){
		                helper(arr,i,j-1);
		            }else{
		                helper(arr,i,j);
		            }
		            
		        }
		    }
		    System.out.println(ans.size());
		    for(int[] move:ans){
		        for(int i=0;i<6;i++){
		            System.out.print(move[i]+1 +"" "");
		        }
		        System.out.println();
		    }
		  //  for(int i=0;i<n;i++){
		        
		  //      for(int j=0;j<m;j++){
		  //          System.out.print(arr[i][j] +"" "");
		  //      }
		  //      System.out.println();
		  //  }	
		
		    
		}   
		
		
        
	}
}
",0,Non-plagiarised
3088ca9c,a2cf5634,"import java.util.*;
import java.io.*;


public class MyClass {
    public static void main(String args[]) {
     Scanner sc = new Scanner(System.in);
     int t = sc.nextInt();
     while(t>0)
     {
         int n = sc.nextInt();
         sc.nextLine();
         String [] str = new String[n];
         int res = 0;
         for(int i=0;i<n;i++)
         {
             str[i]=sc.nextLine();
         }
         int [][] freq = new int [n][5];
         for(int i=0;i<n;i++)
         {
             for(int j=0;j<str[i].length();j++)
             {
                 int k = str[i].charAt(j)-'a';
                 freq[i][k]++;
             }
         }
         for(int i=0;i<5;i++)
         {
             int [] arr = new int[n];
             for(int j=0;j<n;j++)
             {
                 int pos = freq[j][i];
                 int sum=0;
                 for(int k = 0;k<5;k++)
                 {
                     sum+=freq[j][k];
                 }
                 sum-=pos;
                 arr[j]=(pos-sum);
             }
             Arrays.sort(arr);
            //  int p = n-1;
             int count=0;
             int sum=0;
             for(int p=n-1;p>=0;p--)
             {
                 sum+=arr[p];
                 if(sum>0)
                 {
                     count++;
                 }
                 else
                 {
                     break;
                 }
             }
             res=Math.max(count , res);
         }
         
         System.out.println(res);
         t--;
         
     }
    }
}
","import java.util.*;

import javax.sql.rowset.serial.SerialArray;
import javax.swing.text.html.HTMLDocument.HTMLReader.PreAction;
import java.io.*;
import java.math.*;
import java.sql.Array;;

public class Main {
	

//*************************  FR CLASS ENDS **********************************

	static long mod = (long) (1e9 + 7);

	

	

	

	

	

	

	

//	----------------------------------DSU--------------------------------

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

	/* ***************************************************************************************************************************************************/


	
	
	
	static FR sc = new FR();
	static StringBuilder sb = new StringBuilder();
	
	
	public static void main(String args[]) throws IOException {
		
		int tc = sc.nextInt();
//		int tc = 1;
		while (tc-- > 0) {
			TEST_CASE();
		}
		sb.setLength(sb.length() - 1);
		System.out.println(sb);
	}

	static void TEST_CASE() throws IOException {
		// BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int n = sc.nextInt();
		String[] strs = new String[n];
		
		for(int i = 0; i < n; i++) {
			strs[i] = sc.next();
		}
		
		int max = -1;
		
		for(int i = 0; i < 5; i++) {
			ArrayList<Integer> arr = new ArrayList<>();
			for(int j = 0; j < n; j++) {
				String s = strs[j];
				char letter = (char)(97+i);
				int val = 0;
				for(int k = 0; k < s.length(); k++) {
					if(s.charAt(k) == letter)
						val++;
					else
						val--;
				}
				arr.add(val);
			}
			Collections.sort(arr, Collections.reverseOrder());
			int val = 0;
			int ans = 0;
			for(int x : arr) {
				val += x;
				if(val <= 0)
					break;
				else
					ans++;
			}
			max = Math.max(ans, max);
		}
		sb.append(max + ""\n"");
	}
}
",0,Non-plagiarised
22b41936,45f5632f,"import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {

     static ArrayList<Integer> list1 = new ArrayList<>() ;
     static ArrayList<Integer> list2 = new ArrayList<>() ;
     static int n , m ;
     static long dp[][] ;

     static long solver(int i , int j ){
         // i = empty chairs

         if (j == m)return 0 ;
         int tt1 = n-i ;
         int tt2 = m-j ;
         if (n-i < m-j)return  Long.MAX_VALUE/2  ;
         if ( dp[i][j] != -1 )return dp[i][j] ;

        long a = solver(i+1 , j) ;
        long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;

        return dp[i][j] = min(a , b) ;

     }



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

//        try {


            FastScanner in = new FastScanner();
            PrintWriter out = new PrintWriter(System.out);


            int N = in.nextInt() ;
            int a[] = in.readArray(N) ;
        for (int i = 0; i <N ; i++) {
            if (a[i] == 1)list2.add(i) ;
            else list1.add(i) ;
        }

         n = list1.size() ;
         m = list2.size() ;
            dp = new long[n][m] ;


            for(int i=0 ; i<n ; i++)
                for(int j=0 ; j<m ; j++)
                    dp[i][j] = -1 ;

     
        System.out.println(solver(0 , 0 ));








            out.flush();
            out.close();

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

    }

    

    static ArrayList<Integer> list = new ArrayList<>();
    static boolean A[] = new boolean[2 * 90000001];


    

    

    

    


    

    

    

    

    


    


    


    


}
","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) 
         
        
        // A O(log n) function returning primefactorization 
        // by dividing by smallest prime factor at every step 
         
        // function to find first index >= x 
         
        
        // function to find last index <= y 
         
        
        // function to count elements within given range 
        
        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]);
        }
        
        

    }

    

    
    // fast input reader class;
    
}
",0,Non-plagiarised
05f939b3,e647bef7,"import java.io.*;
import java.util.*;
public class D_668 {
    static int p=1000000007;
    static  int dia=Integer.MIN_VALUE;
    public static void main(String[] args) throws Exception{
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(java.io.FileDescriptor.out), ""ASCII""), 512);
        FastReader sc=new FastReader();
        int t=sc.nextInt();
       StringBuilder sb=new StringBuilder();
        while(t-->0)
        {
            int n=sc.nextInt();
            int a=sc.nextInt();
            int b=sc.nextInt();
            int da=sc.nextInt();
            int db=sc.nextInt();
            dia=Integer.MIN_VALUE;
            int dp[]=new int[(int) n+1];
            List<Integer> adj[]=new ArrayList[n+1];
            for(int i=0;i<=n;i++)
            {
                adj[i]=new ArrayList<>();
            }
            Set<Integer> s=new HashSet<>();
            for(int i=1;i<n;i++)
            {
                int u=sc.nextInt();
                int v=sc.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            dfs(dp,adj,a,-1,0);
           // System.out.println(dia+"" ""+dp[b]);
            if(2*da>=db||2*da>=dia||da>=dp[b])
                sb.append(""Alice\n"");
            else
                sb.append(""Bob\n"");

        }
        System.out.println(sb.toString());
        out.flush();
    }
    public static int dfs(int dp[],List<Integer> adj[],int i,int p,int d)
    {
        dp[i]=d;
        int last_max=0;
        for(int v:adj[i])
        {
            if(p!=v&&dp[v]==0)
            {
                int max=1+dfs(dp,adj,v,i,d+1);
                dia=Math.max(dia,max+last_max);
                last_max=Math.max(last_max,max);
            }
        }
        return last_max;
    }
    
    
    int bit[]=new int[(int)1e6];
    
    


    ///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
    


}
","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 MyWriter extends PrintWriter {
        private MyWriter(OutputStream outputStream) {
            super(outputStream);
        }

        

        

        void println(int[] a) {
            for (int v : a) {
                println(v);
            }
        }

        

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

    

    

    public static void main(String[] args) {
        out = new MyWriter(new BufferedOutputStream(System.out));
        sc = new MyScanner();
        new Main().run();
        out.close();
    }
}
",0,Non-plagiarised
2bda1866,e4ab72e5,"import java.io.*;
import java.util.*;

public class Main {
	
	
	public static void main(String[] args) throws Exception {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));		
		
		int T = Integer.parseInt(in.readLine());
		
		for (int ts=1; ts<=T; ts++) {
			int N = Integer.parseInt(in.readLine());
			String A = in.readLine();
			String B = in.readLine();
			
			int ans = -1;
			
			//even number of ops
			int fromZero = 0;
			int fromOne = 0;
			for (int i=0; i<N; i++) {
				if (A.charAt(i) != B.charAt(i)) {
					if (A.charAt(i) == '0') {
						fromZero++;
					} else {
						fromOne++;
					}
				}
			}
			if (fromZero == fromOne) {
				ans = fromZero + fromOne;
			}
			
			
			//odd number of ops
			int zero = 0;
			int one = 0;
			for (int i=0; i<N; i++) {
				if (A.charAt(i) == B.charAt(i)) {
					if (A.charAt(i) == '0') {
						zero++;
					} else {
						one++;
					}
				}
			}
			
			if (one == zero + 1) {
				int current = one + zero;
				if (ans == -1)
					ans = current;
				else
					ans = Math.min(ans, current);
			}
			
			out.write(ans + ""\n"");
		}
		
		in.close();
		out.close();
	}

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

public class q3 {
    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//    public static long mod = 1000000007;


    public static void solve() throws Exception {
        String[] parts = br.readLine().split("" "");
        int n = Integer.parseInt(parts[0]);

        StringBuilder a = new StringBuilder(br.readLine());
        StringBuilder b = new StringBuilder(br.readLine());

        boolean flag = true;
        for(int i = 0;i < n;i++) if(a.charAt(i) != b.charAt(i)) flag = false;
        if(flag){
            System.out.println(0);
            return;
        }

        if(n == 1){
            System.out.println(-1);
            return;
        }

        int aco = 0,bco = 0;
        for(int i = 0;i < a.length();i++) {
            if(a.charAt(i) == '1') aco++;
            if(b.charAt(i) == '1') bco++;
        }

        if(aco == 0 || bco == 0){
            System.out.println(-1);
            return;
        }

        if(aco == bco || n - aco + 1 == bco){

        }else{
            System.out.println(-1);
            return;
        }

        int ez = 0,eo = 0,nez = 0,neo = 0;
        for(int i = 0;i < n;i++){
            if(a.charAt(i) == b.charAt(i)){
                if(a.charAt(i) == '1') eo++;
                else ez++;
            }else{
                if(a.charAt(i) == '1') neo++;
                else nez++;
            }
        }

        HashSet<String> vis = new HashSet<>();
        Queue<String> que = new LinkedList<>();

        vis.add(ez + "" "" + eo + "" "" + nez + "" "" + neo);
        que.add(ez + "" "" + eo + "" "" + nez + "" "" + neo);

        int level = 0;
        while(que.size() > 0){
            for(int s = que.size() - 1;s >= 0;s--) {
                String[] rem = que.remove().split("" "");
                int v1 = Integer.parseInt(rem[0]);
                int v2 = Integer.parseInt(rem[1]);
                int v3 = Integer.parseInt(rem[2]);
                int v4 = Integer.parseInt(rem[3]);

                if (v3 == 0 && v4 == 0) {
                    System.out.println(level);
                    return;
                }

                String first = (v4) + "" "" + (v3 + 1) + "" "" + (v2 - 1) + "" "" + (v1);
                if (vis.add(first)) que.add(first);

                String second = (v4 - 1) + "" "" + (v3) + "" "" + (v2) + "" "" + (v1 + 1);
                if (vis.add(second)) que.add(second);
            }
            level++;
        }

        System.out.println(-1);
    }

    public static void main(String[] args) throws Exception {
        int tests = Integer.parseInt(br.readLine());
        for (int test = 1; test <= tests; test++) {
            solve();
        }
    }

//    public static ArrayList<Integer> primes;
//    public static void seive(int n){
//        primes = new ArrayList<>();
//        boolean[] arr = new boolean[n + 1];
//        Arrays.fill(arr,true);
//
//        for(int i = 2;i * i <= n;i++){
//            if(arr[i]) {
//                for (int j = i * i; j <= n; j += i) {
//                    arr[j] = false;
//                }
//            }
//        }
//        for(int i = 2;i <= n;i++) if(arr[i]) primes.add(i);
//    }


//    public static void sort(int[] arr){
//        ArrayList<Integer> temp = new ArrayList<>();
//        for(int val : arr) temp.add(val);
//
//        Collections.sort(temp);
//
//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
//    }

//    public static void sort(long[] arr){
//        ArrayList<Long> temp = new ArrayList<>();
//        for(long val : arr) temp.add(val);
//
//        Collections.sort(temp);
//
//        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
//    }
//
//    public static long power(long a,long b,long mod){
//        if(b == 0) return 1;
//
//        long p = power(a,b / 2,mod);
//        p = (p * p) % mod;
//
//        if(b % 2 == 1) return (p * a) % mod;
//        return p;
//    }
//    public static long modDivide(long a,long b,long mod){
//        return ((a % mod) * (power(b,mod - 2,mod) % mod)) % mod;
//    }
//
//    public static int GCD(int a,int b){
//        return b == 0 ? a : GCD(b,a % b);
//    }
//    public static long GCD(long a,long b){
//        return b == 0 ? a : GCD(b,a % b);
//    }
//
//    public static int LCM(int a,int b){
//        return a * b / GCD(a,b);
//    }
//    public static long LCM(long a,long b){
//        return a * b / GCD(a,b);
//    }
}
",0,Non-plagiarised
a4ec80a0,d314aa92,"import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Armchairs {

	static List<Integer> zpos ;
	static List<Integer> opos ;
	static long[][] dp ;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		zpos = new ArrayList<Integer>();
		opos = new ArrayList<Integer>();
		for (int i = 0; i < n; i++) {
			int x = sc.nextInt();
			if (x == 1) opos.add(i);
			else zpos.add(i);
		}
		dp = new long[5001][5001];
		for (int i = 0; i < 5001; i++) Arrays.fill(dp[i], -1);
		System.out.println(dp(0, 0, opos.size(), zpos.size(), opos.size()));
	}

	private static long dp(int i, int j, int m, int n, int cnt) {
		// TODO Auto-generated method stub
		if (cnt == 0) return 0;
		if (i >= m || j >= n) return Integer.MAX_VALUE;
		if (dp[i][j] != -1) return dp[i][j];
		long dns = dp(i, j + 1, m, n, cnt);
		long s = Math.abs(zpos.get(j) - opos.get(i)) + dp(i + 1, j + 1, m, n, cnt - 1);
		return dp[i][j] = Math.min(dns, s);
	}

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

public class Codeforces {

    


    static FastReader f = new FastReader();
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb = new StringBuilder("""");
    private static int m = (int) 1e9 + 7;

    static int[] inputArray(int n) throws IOException {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = f.nextInt();
        }
        return a;
    }

    

    

    

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

//        System.out.println(gcd(11, 3));

        int t = 1;
        while(t-- != 0) {
            int N = f.nextInt();
            int a[] = inputArray(N);
            ArrayList<Integer> space = new ArrayList<>();
            ArrayList<Integer> fill = new ArrayList<>();
            for(int i = 0 ; i < N;  i++) {
                if(a[i] == 0) {
                    space.add(i);
                }
                else {
                    fill.add(i);
                }
            }
            int n = fill.size(), m = space.size();
            int[][] dp = new int[n+1][m+1];
            // i - no of filled
            // j is no of space
            Arrays.fill(dp[0], 0);
            for(int i = 1 ; i <= n ; i++) {
                dp[i][0] = -1;
            }
            for(int i = 1 ; i <= n ; i++) {
                for(int j = 1 ; j <= m ; j++) {
                    if(i > j) {
                        dp[i][j] = -1;
                        continue;
                    }
                    dp[i][j] = Integer.MAX_VALUE;
                    if(dp[i-1][j-1] != -1) {
                        dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1]) + Math.abs(fill.get(i-1) - space.get(j-1));
                    }
                    if(dp[i][j-1] != -1) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][j-1]);
                    }
                }
            }

            System.out.println(dp[n][m]);

        }

        System.out.println(sb);

    }

}
",0,Non-plagiarised
4da08761,d6fb3b9e,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Solution {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Main solver = new Main();
        boolean multipleTC = true;
        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
        for (int i = 1; i <= testCount; i++)
            solver.solve(in, out, i);
        out.close();
    }
    static class Main {
        PrintWriter out;
        InputReader in;

        public void solve(InputReader in, PrintWriter out, int test) {
            this.out = out;
            this.in = in;
            int n = ni();
            String[] arr = new String[n];
            int[][] freq = new int[n][5];
            int[][] rem = new int[n][5];
            for(int i = 0; i < n; i++){
                arr[i] = n();
                for(int j = 0; j < arr[i].length(); j++)
                    freq[i][arr[i].charAt(j) - 'a']++;
                for(int j = 0; j < 5; j++)
                    rem[i][j] = arr[i].length() - freq[i][j];
            }
            int ans = 0;
            for(int i = 0; i < 5; i++){
                int[] vals = new int[n];
                for(int j = 0; j < n; j++)
                    vals[j] = freq[j][i] - rem[j][i];
                Arrays.sort(vals);
                int sum = 0, x = 0;
                for(int j = n - 1; j >= 0; j--){
                    if(sum + vals[j] > 0){
                        x++;
                        sum += vals[j];
                    } else {
                        break;
                    }
                }
                if(x > ans) {
                    ans = x;
                }
            }
            System.out.println(ans);
        }

        


        String n(){
            return in.next();
        }

        int ni() {
            return in.nextInt();
        }

        


        

    }

    
}
","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
63bfa731,9fc811f7,"import java.util.*;
import java.io.*;

public class D {
    static ArrayList<Integer> adj[] = new ArrayList[(int)1e5+7];
    static int diameter = 0;
    static int[] depth = new int[(int)1e5 + 7];
    public static void main(String[] args) {
        FastReader in = new FastReader();
        int t = in.nextInt();
        while(t-- > 0){
            int n = in.nextInt();
            int a = in.nextInt(), b = in.nextInt(), da = in.nextInt(), db = in.nextInt();
            for(int i = 1; i <= n; i++){
                adj[i] = new ArrayList<>();
            }
            for(int i = 1; i <=n; i++){
                adj[i].clear();
            }
            for(int i = 0; i < n- 1; i++){
                int u = in.nextInt();
                int v = in.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            diameter = 0;
            depth[a] = 0;
            dfs(a, -1);
            System.out.println(2 * da >= Math.min(diameter, db) || depth[b] <= da ? ""Alice"" : ""Bob"");
        }
    }
    static int dfs(int node, int parent){
        int len = 0;
        for(int x : adj[node]){
            if(x != parent){
                depth[x] = depth[node] + 1;
                int cur = 1 + dfs(x, node);
                diameter = Math.max(diameter, cur + len);
                len = Math.max(len, cur);
//                System.out.print(""x "" + x + "" node "" + node + "" par "" + parent);
//                System.out.println("" cur "" + cur + "" len "" + len + "" diam "" + diameter);
            }
        }
        return len;
    }
    

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

        }

    }

    
}
",1,Plagiarised
392218ef,f0ede32a,"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"");
	    }
	    
	}
}
","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
873828f7,ac8acb97,"import java.util.Scanner;

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[] c=new int[n];
			for(int i=0;i<n;i++)
				c[i]=sc.nextInt();
			int[] mn= {Integer.MAX_VALUE,Integer.MAX_VALUE};
			long[] rem= {(long)n,(long)n};
			long sum=0;
			long ans=Long.MAX_VALUE;
			for(int i=0;i<n;i++)
			{
				mn[i%2]=Math.min(mn[i%2], c[i]);
				rem[i%2]--;
				sum+=c[i];
				if(i>0)
				{
					long cur=sum+rem[0]*mn[0]+rem[1]*mn[1];
					ans=Math.min(ans, cur);
				}
			}
			System.out.println(ans);
		}
	}
}
","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
26e699de,fcc7e8fa,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

        Scanner sc= new Scanner(System.in);
        int numberTest=sc.nextInt();
        while(numberTest-->0){
            int n=sc.nextInt();
            char[] s=new char[n+5];
            char[] t=new char[n+5];
            String ss=sc.next();
            String tt=sc.next();
            s=ss.toCharArray();
            t=tt.toCharArray();
            int cntax = 0, cntbx = 0, same = 0;
            int ans=MOD9;
            for(int i=0; i<n; i++){
                if(s[i]=='1')cntax++;
                if(t[i]=='1')cntbx++;
                if(s[i]==t[i])same++;
            }
            if(same==n){
                System.out.println(0);
                continue;
            }
            else if (cntax==0){
                System.out.println(-1);
                continue;
            }
            if(cntax==cntbx){
                ans=Math.min(ans,n-same);
            }
            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
            if(ans<MOD9) System.out.println(ans);
            else System.out.println(-1);



        }

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

public class Main {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        int t;
        t = in.nextInt();
        //t = 1;
        while (t > 0) {
            solver.call(in,out);
            t--;
        }
        out.close();
    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            int n, _00 = 0, _01 = 0, _11 = 0, _10 = 0;
            n = in.nextInt();
            char[] s = in.next().toCharArray();
            char[] s1 = in.next().toCharArray();

            for (int i = 0; i < n; i++) {
                if(s[i]==s1[i]){
                    if(s[i]=='0'){
                        _00++;
                    }
                    else{
                        _11++;
                    }
                }
                else{
                    if(s[i]=='0'){
                        _01++;
                    }
                    else{
                        _10++;
                    }
                }
            }
            int ans = Integer.MAX_VALUE;

            if(_10 ==_01){
                ans = 2*_01;
            }
            if(_11 == _00 + 1){
                ans = Math.min(ans, 2*_00 + 1);
            }

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

    

    

    

    

    

    

    static final Random random=new Random();

    

    
}
",0,Non-plagiarised
4e28b45e,fc1771af,"import java.util.*;
import java.io.*;
public class C {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt();
			char[] s = new char[n];
			char[] t = new char[n];
			s = sc.next().toCharArray();
			t = sc.next().toCharArray();
			int a = 0, b = 0, c = 0, d = 0;
			for(int i = 0; i < n; i++) {
				if(s[i] == '0' && t[i] == '0') a++;
				if(s[i] == '1' && t[i] == '0') b++;
				if(s[i] == '0' && t[i] == '1') c++;
				if(s[i] == '1' && t[i] == '1') d++;
			}
			int res = Integer.MAX_VALUE;
			if(b == c || b+1 == c) {
				if((b + c) % 2 == 0) {
					res = Math.min(res, b + c);
				}
			}
			if(a == d || a+1 == d) {
				if((a + d) % 2 == 1) {
					res = Math.min(res, a + d);
				}
			}
			if(res == Integer.MAX_VALUE) System.out.println(-1);
			else System.out.println(res);
		}
	}
	
	

}
","import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
import java.text.DecimalFormat;

public final class Solution {

    static int inf = Integer.MAX_VALUE;
    static long mod = 1000000000 + 7;
    
 static void ne(Scanner sc, BufferedWriter op) throws Exception {
            int n=sc.nextInt();
     String one=sc.next();
     String two=sc.next();
     int _10=0;
     int _00=0;
     int _11=0;
     int _01=0;
   for(int i=0;i<n;i++){
       int c1=one.charAt(i)-'0';
       int c2=two.charAt(i)-'0';
       if(c1==0 && c2==0){
           _00++;
       }
       if(c1==1 && c2==0){
           _10++;
       }
       if(c1==1 && c2==1){
           _11++;
       }
       if(c1==0 && c2==1){
           _01++;
       }
   }
   int same=_00+_11;
   int diff=_01+_10;
   if(same==n){
      op.write(""0\n"");
      return;
   }
   if(same==1 && _11==1){
       op.write(""1\n"");
       return;
   }
//    if(diff==n){
//        if(diff%2==0){
//            op.write(n+""\n"");
 
//        }else{
//            op.write(""-1\n"");
//        }
//        return;
//    }
   int ans=inf;
    
    if(_11-_00==1 && _00!=0 && _11!=0){
        // print(""here"");
        ans=Math.min(ans,same);
     }
     if(_10 ==_01 && _10!=0 && _01!=0){
        ans=Math.min(ans,diff);
     }
    
    if(ans==inf){
        op.write(""-1\n"");
    }else{
        op.write(ans+""\n"");
    }

 }
 
  
  
  

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

    
    

    
       

}



// return -1 to put no ahed in array










 
",0,Non-plagiarised
11c2ab99,4f7af821,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		for (int tt=0; tt<T; tt++) {
			int n=fs.nextInt(), k=fs.nextInt();
			int[] positions=fs.readArray(k), temps=fs.readArray(k);
			int[] forced=new int[n];
			Arrays.fill(forced, Integer.MAX_VALUE/2);
			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
			for (int i=1; i<n; i++)
				forced[i]=Math.min(forced[i], forced[i-1]+1);
			for (int i=n-2; i>=0; i--)
				forced[i]=Math.min(forced[i], forced[i+1]+1);
			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
			out.println();
			
		}
		out.close();
	}

	
	
	

	
}
","import java.util.*;

public class contestA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        int inf = 1000300300;
        while (t-->0){
            int n = scanner.nextInt();
            int k = scanner.nextInt();
            int[] c = new int[n];
            Arrays.fill(c,inf);
            int[] a = new int[k];
            int[] b = new int[k];
            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
            for(int i=0;i<k;++i) c[a[i]] = b[i];
            for(int i=1;i<n;++i){
                c[i] = Math.min(c[i],c[i-1]+1);
            }
            for(int i=n-2;i>=0;--i){
                c[i] = Math.min(c[i],c[i+1]+1);
            }
            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
            System.out.println();
        }
    }
}
",1,Plagiarised
1097b326,a60fba84,"import java.util.Scanner;

public class Main {

    

    

    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 void main(String[] args) {
        solution3();
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	static PrintWriter out;
	static FastReader scan;

    /*-------- I/O using short named function ---------*/
	
	public static int ni(){return scan.nextInt();}
	public static long nl(){return scan.nextLong();}
	
	
	
	
    /*-------- for output of an array ---------------------*/
     
	
	
	
    /*-------------- for input in an array ---------------------*/
	
	static void lIA(long arr[]){
	     for(int i=0; i<arr.length; i++)arr[i] = nl(); 
	}
	
	
	/*------------ for taking input faster ----------------*/
     

	// Method to check if x is power of 2
    
    //Method to return lcm of two numbers
    
    //Method to count digit of a number
    

    //Method for sorting
	
	//Method for checking if a number is prime or not
	 

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

			}
			System.out.println(ans);
        }
        out.flush();
		out.close();
	}
	
}
",0,Non-plagiarised
1be078c4,bb0949b3,"import java.util.*;
import java.io.*;

public class E_1547 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt(), k = sc.nextInt();
			int[] a = sc.nextIntArray(k);
			int[] t = sc.nextIntArray(k);
			
			int[] array = new int[n];
			Arrays.fill(array, Integer.MAX_VALUE);
			for(int i = 0; i < k; i++)
				array[a[i] - 1] = t[i];
			
			int[] pre = new int[n];
			int[] post = new int[n];
			
			int prev = (int)2e9;
			for(int i = 0; i < n; i++)
				prev = pre[i] = Math.min(prev + 1, array[i]);
			
			prev = (int)2e9;
			for(int i = n - 1; i >= 0; i--)
				prev = post[i] = Math.min(prev + 1, array[i]);
			
			for(int i = 0; i < n; i++)
				array[i] = Math.min(pre[i], post[i]);
			
			for(int i = 0; i < n; i++)
				pw.print(array[i] + (i == n - 1 ? ""\n"" : "" ""));
		}
		
		pw.flush();
	}

	
}
","import java.util.*;

public class file
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t!=0)
        {
            sc.nextLine();
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] position = new int[k];
            for(int i = 0;i < k;i++)
            {
                position[i] = sc.nextInt();
            }
            int[] temprature = new int[k];
            for(int i = 0;i < k;i++)
            {
                temprature[i] = sc.nextInt();
            }
            int[] left = new int[n];
            int[] right = new int[n];
            int c[] = new int[n];
            Arrays.fill(c, Integer.MAX_VALUE);
            for(int i = 0;i < k;i++)
            {
                c[position[i]-1] = temprature[i];
            }
            long min = Integer.MAX_VALUE - 1;
            for(int i = 0;i < n;i++)
            {
                min = Math.min(min+1, c[i]);
                left[i] = (int)min;

            }
            min = Integer.MAX_VALUE - 1;
            for(int i = n-1;i >= 0;i--)
            {
                min = Math.min(min+1, c[i]);
                right[i] = (int)min;
            }
            for(int i = 0;i < n;i++)
            {
                System.out.print(Math.min(left[i], right[i])+"" "");
            }
            System.out.println();
            t--;
        }
    }
}
",0,Non-plagiarised
6f393cfe,f38ae053,"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.io.*;
public class Fixed_Points 
{
	
	public static void process()throws IOException
	{
		int n=I();
	    String s[]=new String[n];
	    for(int i=0;i<n;i++)
	    {
	    	s[i]=S();
	    }
	    int max=0;
		for(char ch='a';ch<='e';ch++)
		{
			int t=0;
			ArrayList<Integer> po=new ArrayList<Integer>();
			ArrayList<Integer> ne=new ArrayList<Integer>();
			for(int j=0;j<n;j++)
			{
				int f1=0;int f2=0;
				
			    for(int k=0;k<s[j].length();k++)
			    {
			    	if(s[j].charAt(k)==ch)
			    	{
			    		f1++;
			    	}
			    	else
			    	{
			    		f2++;
			    	}
			    }
			    if(f1>f2)
			   po.add(f1-f2);
			    else
			    ne.add(f1-f2);
			}
			Collections.sort(po);
			Collections.reverse(po);
			Collections.sort(ne);
			Collections.reverse(ne);
			int sum=0;
			for(int i=0;i<po.size();i++)
			{
				sum=sum+po.get(i);
			}
			int tp=0;
			for(int i=0;i<ne.size();i++)
			{
				if(ne.get(i)+sum>0)
				{
				sum=sum+ne.get(i);
				tp++;
				}
			}
			t=tp+po.size();
			max=Math.max(max, t);
		}
		pn(max);
		
    }
	static Scanner sc = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static void pn(Object o){out.println(o);out.flush();}
	
	
	static int I() throws IOException{return sc.nextInt();}
	static long L() throws IOException{return sc.nextLong();}
	
	static String S() throws IOException{return sc.next();}
	
	
	
	
	
	
//	*--------------------------------------------------------------------------------------------------------------------------------*//
	
	public static void main(String[] args)throws IOException{try{boolean oj=true;if(oj==true)
	{AnotherReader sk=new AnotherReader();PrintWriter out=new PrintWriter(System.out);}
	else
	{AnotherReader sk=new AnotherReader(100);out=new PrintWriter(""output.txt"");}
	long T=L();while(T-->0)
	{process();}out.flush();out.close();}catch(Exception e){return;}}}
",0,Non-plagiarised
22dff786,624529000,"import java.util.*;

public class Solution {

    public static void main(String args[])

    {   Scanner s = new Scanner(System.in);

        int t = s.nextInt();

        while(t-- > 0){
        	
        	int n= s.nextInt();
        	
        	long [] time= new long [n];
        	
        	long [] health= new long [n];
        	
        	for(int i=0; i<n; i++)
        		
        		time[i]= s.nextLong();
        	
        	for(int i=0; i<n; i++)
        		
        		health[i]= s.nextLong();
        	
        	long currhealth= health[n-1];
        	
        	long currtime= time[n-1];
        	
        	long ans=0;
        	
        	for(int i= n-2; i>=0; i--)
        	
        	{   if(currtime-time[i]>= currhealth)
        		
        	    {  ans+= (currhealth*(currhealth+1))/2;
        	    
        	       currhealth= health[i];
        	       
        	       currtime= time[i];
        		
        	    }
        	
        	    else if(currtime-time[i]>currhealth-health[i])
        	    	
        	    	currhealth+= (currtime-time[i]-currhealth+health[i]);
        		
        	}
        	
        	ans+= (currhealth*(currhealth+1))/2;
        	
        	System.out.println(ans);

        }
        
        s.close();

    }
    
}
","import java.util.*;
import java.io.*;
import java.lang.*;
public class Main
{
	public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	int t=sc.nextInt();
	while(t-->0){
	    int n=sc.nextInt();
	    long k[]=new long[n];
	    long h[]=new long[n];
	    for(int i=0;i<n;i++){
	        k[i]=sc.nextInt();
	    }
	    for(int i=0;i<n;i++){
	        h[i]=sc.nextInt();
	    }
	    long length=h[n-1];
	    long curr=0;
	    long ans=0;
	    for(int i=n-1;i>=1;i--){
	        if(k[i]-k[i-1]>=length){
	            curr=curr+length;
	            ans=ans+(curr*(curr+1))/2;
	            length=h[i-1];
	            curr=0;
	        }
	        else{
	            length=Math.max(length-(k[i]-k[i-1]),h[i-1]);
	            curr=curr+k[i]-k[i-1];
	        }
	    }
	    curr=curr+length;
	    ans=ans+(curr*(curr+1))/2;
	    System.out.println(ans);
	 }
	}
}
",0,Non-plagiarised
0ea5a836,3c74c140,"import java.util.*;
import java.io.*;
public class Solution
{
    
    //static final long mod=(long)1e9+7;
    static final long mod=998244353L;
    
    
    /*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; 
        }
    }*/
    
    
    
    
    
    
    public static void main(String args[])throws Exception
    {
        FastReader fs=new FastReader();
        PrintWriter pw=new PrintWriter(System.out);
        int tc=fs.nextInt();
        while(tc-->0)
        {
            int n=fs.nextInt();
            char[][] c=new char[n][];
            for(int i=0;i<n;i++)
            c[i]=fs.nextLine().toCharArray();
            ArrayList<Integer> list[]=new ArrayList[5];
            for(int i=0;i<5;i++)
            list[i]=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                int cnt[]=new int[5];
                for(int j=0;j<c[i].length;j++)
                cnt[c[i][j]-'a']++;
                for(int j=0;j<5;j++)
                list[j].add(2*cnt[j]-c[i].length);
            }
            for(int i=0;i<5;i++)
            Collections.sort(list[i]);
            int ans=0;
            for(int i=0;i<5;i++)
            {
                int s=0;
                for(int j=n-1;j>=0;j--)
                {
                    ans=Math.max(ans,n-1-j);
                    s+=list[i].get(j);
                    if(s<=0)
                    break;
                }
                if(s>0)
                ans=n;
            }
            pw.println(ans);
        }
        pw.flush();
        pw.close();
    }
}
","import  java.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;
    }




    
    

    

    


    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
    
    // int arr input
    

    



}
",0,Non-plagiarised
bf85ab7b,e48933fa,"import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.io.DataInputStream;
import java.io.FileInputStream;

import java.io.IOException;

public class ParsasHumongousTree {

    public static void main(String args[]) throws IOException {
        Reader scan = new Reader();
        StringBuilder sb = new StringBuilder();

        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            int[] l = new int[n + 1];
            int[] r = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                l[i] = scan.nextInt();
                r[i] = scan.nextInt();
            }
            Graph g = new Graph(n);
            for (int i = 0; i < n - 1; i++) {
                g.addEdge(scan.nextInt(), scan.nextInt());
            }
            sb.append(g.dfs(l, r) + ""\n"");
        }
        System.out.println(sb);
    }
}

class Graph {

    ArrayList<Integer>[] node;
    int n;
    int c = 0;
    boolean[] vis;

    Graph(int s) {
        n = s + 1;
        vis = new boolean[n + 1];
        node = new ArrayList[n + 1];
        for (int i = 0; i < n + 1; i++) {
            node[i] = new ArrayList<>();
        }
    }

    void addEdge(int u, int v) {

        node[u].add(v);
        node[v].add(u);
        if (node[u].size() == 1) {
            c = u;
        }
        if (node[v].size() == 1) {
            c = v;
        }
    }

    void cleanVisArray() {
        for (int i = 0; i < n + 1; i++) {
            vis[i] = false;
        }
    }

    long dfs(int[] l, int[] r) {
        cleanVisArray();

        long[][] dp = new long[n][2];
        dfsMain(1, dp, l, r);
        return Math.max(dp[1][0], dp[1][1]);
    }

    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
        vis[v] = true;
        for (int i : node[v]) {
            if (!vis[i]) {
                dfsMain(i, dp, l, r);
                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
            }
        }
    }

}


","import java.io.*;




import java.util.*;
/*
 


 */





 
 
 
 
 public class C {
    static FastReader sc=null;
   
	public static void main(String[] args) {
		sc=new FastReader();
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt();
			Node nodes[]=new Node[n];
			for(int i=0;i<n;i++)nodes[i]=new Node(i,sc.nextInt(),sc.nextInt());
			for(int i=0;i+1<n;i++) {
				int v=sc.nextInt()-1,w=sc.nextInt()-1;
				nodes[v].adj.add(nodes[w]);
				nodes[w].adj.add(nodes[v]);
			}
			
			dfs(nodes[0],null);
			System.out.println(Math.max(nodes[0].right,nodes[0].left));
		}
		
		
		
	}
	static void dfs(Node v,Node par) {
		for(Node nn:v.adj) {
			if(nn!=par) {
				dfs(nn,v);
				v.right+=Math.max(nn.right+Math.abs(v.r-nn.r), 
						nn.left+Math.abs(v.r-nn.l));
				v.left+=Math.max(nn.right+Math.abs(v.l-nn.r), 
						nn.left+Math.abs(v.l-nn.l));
			}
		}
	}
	static class Node{
		int id;
		long right=0,left=0;
		int l,r;
		ArrayList<Node> adj=new ArrayList<>();
		
		Node(int id,int l,int r){
			this.id=id;
			this.l=l;
			this.r=r;
		}
	}
	
	
	
    
    
    
    
    
    
   
 
      
      
        
 
    
    
    
    
    
    
    
    
    
    
     
}
",0,Non-plagiarised
1dab88fb,99ccaa44,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.util.*;
 
public class Main
{
	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in); 
		int tc = sc.nextInt();
		while(tc>0)
		{
		    tc--;
		    int ans = 0;
		    int n = sc.nextInt();
		    int in[] = new int[n];
		    int wx[] = new int[n-1];
		    int wy[] = new int[n-1];
		    ArrayList<ArrayList<Integer>> arr = new ArrayList<ArrayList<Integer>>();
		    HashMap<String,Integer> h = new HashMap<String,Integer>();
		    HashSet<Integer> h2 = new HashSet<Integer>();
		    for(int i=0;i<n;i++)
		    {
		        arr.add(new ArrayList<Integer>());
		    }
		    for(int i=0;i<n-1;i++)
		    {
		        int x = sc.nextInt();
		        int y = sc.nextInt();
		        x--;
		        y--;
		        in[x]++;
		        in[y]++;
		        if(in[x]>2 || in[y]>2)
		        {
		            ans = -1;
		        }
		        else if(ans!=-1)
		        {
		            arr.get(x).add(y);
		            arr.get(y).add(x);
		            wx[i] = x;
		            wy[i] = y;
		        }
		        
		    }
		    if(ans == -1)
		    {
		        System.out.println(""-1"");
		    }
		    else
		    {
		        int vis[] = new int[n];
		        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
		        q.add(0);
		        vis[0] = 1;
		        while(q.size()>0)
		        {
		            int x = q.removeFirst();
		            for(int i=0;i<arr.get(x).size();i++)
		            {
		                int y = arr.get(x).get(i);
		                String temp  =String.valueOf(x);
		                if(vis[y] == 0)
		                {
		                    vis[y] = 1;
		                    if(h2.contains(y) || h2.contains(x))
		                    {
		                        String s1 = temp+""_""+String.valueOf(y);
		                        String s2 = String.valueOf(y)+""_""+temp;
		                        h.put(s1,11);
		                        h.put(s2,11);
		                        
		                    }
		                    else
		                    {
		                        String s1 = temp+""_""+String.valueOf(y);
		                        String s2 = String.valueOf(y)+""_""+temp;
		                        h.put(s1,2);
		                        h.put(s2,2);
		                        h2.add(x);
		                        h2.add(y);
		                    }
		                    q.add(y);
		                }
		            }
		        }
		        for(int i=0;i<wx.length;i++)
		        {
		            String s1 = String.valueOf(wx[i])+""_""+String.valueOf(wy[i]);
		            System.out.print(h.get(s1)+"" "");
		        }
		        System.out.println();
		    }
		}
	}
}
",0,Non-plagiarised
29cf2e70,72d9eb5b,"import java.util.*;
import java.io.*;
 
public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();
 
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }
 
            Collections.sort(blue);
            Collections.sort(red);
 
            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
","import java.util.*;
import java.io.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();

            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }

            Collections.sort(blue);
            Collections.sort(red);

            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
",1,Plagiarised
a3e272af,d1cd194e,"import java.io.*;
import java.util.*;

public class Asd {

    static PrintWriter w = new PrintWriter(System.out);
    static FastScanner s = new FastScanner();
    static boolean sd = false;
  
    public static void main(String[] args) {

       int t = s.nextInt();
        //int t=1;
        while (t-- > 0) {
            solve();
        }
        w.close();

    }
  public static class Student {
    public int i1;
    public int value;
          
    // A parameterized student constructor
    public Student(int i1,int i2) {
      
        this.i1 = i1;
        this.value=i2;
    }
      
    public int getkey() {
        return i1;
    } 
    public int getValue() {
        return value;
    } 
}
   static class StudentComparator implements Comparator<Student>{
              
            // Overriding compare()method of Comparator 
                        // for descending order of cgpa
        
        }
    
    /* 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();
       
    }

    

    

    

    

    

    

}
","import java.util.*;

import java.lang.*;
import java.io.*;

public class Template {
	
	
	
//	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;
		}
		
		
		
	}
	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
3380fa52,8a39dbf5,"import java.util.*;
import java.io.*;
import java.math.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Coder {
  static int n, k;
  static long a[];
  static int pos[];
  static int temp[];
  static StringBuilder str = new StringBuilder("""");
  static int cnt[][] = new int[(int)1e5+5][2];
  static void solve() {
    long []l = new long[n];
    long []r = new long[n];
    long p = Integer.MAX_VALUE;
    for(int i=0;i<n;i++){
        p = Math.min(p+1, a[i]);
        l[i] = p;
    }
    p=Integer.MAX_VALUE;
    for(int i=n-1;i>=0;i--){
     p = Math.min(p+1, a[i]);
     r[i] = p;
    }
    for(int i=0;i<n;i++){
        str.append(Math.min(l[i],r[i])).append("" "");
    }
    str.append(""\n"");
  }

  public static void main(String[] args) throws java.lang.Exception {
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(bf.readLine().trim());
    while (t-- > 0) {
      bf.readLine();
      String s[] = bf.readLine().trim().split(""\\s+"");
      n = Integer.parseInt(s[0]);
      k = Integer.parseInt(s[1]);
      s = bf.readLine().trim().split(""\\s+"");
      pos = new int[k];
      temp = new int[k];
      a = new long[n];
      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
      s = bf.readLine().trim().split(""\\s+"");
      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
      Arrays.fill(a, Integer.MAX_VALUE);
      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
      solve();
    }
    System.out.print(str);
  }
}
","import java.util.*;
import java.lang.*;
import java.io.*;
 
/* Name of the class has to be ""Main"" only if the class is public. */
public class Codeforces {
    public static void main(String[] args) throws java.lang.Exception {
        /* your code goes here */
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
       int t = Integer.parseInt(buf.readLine());
        StringBuilder sb = new StringBuilder();
       for (int i = 0; i < t; i++) {
           String st=buf.readLine();
          String st1[]=(buf.readLine()).split("" "");
          int n=Integer.parseInt(st1[0]);
          int k=Integer.parseInt(st1[1]);
          int a[]=new int[k];
          int temp[]=new int[k];
          long arr[]=new long[n];
          String st2[]=(buf.readLine()).split("" "");
           String st3[]=(buf.readLine()).split("" "");
           for(int j=0;j<k;j++)
           {
               a[j]=Integer.parseInt(st2[j]);
               temp[j]=Integer.parseInt(st3[j]);
           }
          for(int j=0;j<k;j++)
          {
              arr[a[j]-1]=temp[j];
          }
          long min=Integer.MAX_VALUE;
          long left[]=new long[n];
          long right[]=new long[n];
          if(arr[0]==0)
              left[0]=min;
          else
              left[0]=arr[0];
          for(int j=1;j<n;j++)
          {
              if(arr[j]==0)
              {
                  left[j]=left[j-1]+1;
              }
              else
              {
                  left[j]=Math.min(left[j-1]+1,arr[j]);
              }
          }
          if(arr[n-1]==0)
              right[n-1]=min;
          else
              right[n-1]=arr[n-1];
          for(int j=n-2;j>=0;j--)
          {
              if(arr[j]==0)
              {
                  right[j]=right[j+1]+1;
              }
              else
              {
                  right[j]=Math.min(right[j+1]+1,arr[j]);
              }
          }
          for(int j=0;j<n;j++)
          {
              arr[j]=Math.min(left[j],right[j]);
              sb.append(arr[j]+"" "");
          }
          sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
",0,Non-plagiarised
4b398e3e,94690b36,"import java.io.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.StringTokenizer;

public class codeforces_750_D {
    private static void solve(FastReader io) {
        int n = io.nextInt();
        int[] a = io.readArray(n);

        if (n % 2 == 0) {
            for (int i = 0; i < n; i += 2) {
                io.out.print(a[i + 1] + "" "");
                io.out.print(-a[i] + "" "");
            }
        } else {
            for (int i = 0; i < n - 3; i += 2) {
                io.out.print(a[i + 1] + "" "");
                io.out.print(-a[i] + "" "");
            }
            if (a[n - 3] + a[n - 2] != 0) {
                io.out.print(-a[n - 1] + "" "");
                io.out.print(-a[n - 1] + "" "");
                io.out.print(a[n - 3] + a[n - 2] + "" "");
            } else if (a[n - 3] + a[n - 1] != 0) {
                io.out.print(-a[n - 2] + "" "");
                io.out.print(a[n - 3] + a[n - 1] + "" "");
                io.out.print(-a[n - 2] + "" "");
            } else {
                io.out.print(a[n - 2] + a[n - 1] + "" "");
                io.out.print(-a[n - 3] + "" "");
                io.out.print(-a[n - 3] + "" "");
            }
        }
        io.out.println();
    }

    public static void main(String[] args) throws Exception {
        try (FastReader ioAdapter = new FastReader()) {
            int count = 1;
            count = ioAdapter.nextInt();
            while (count-- > 0) {
                solve(ioAdapter);
            }
        }
    }

    
}
","import java.util.Scanner;

public class VupsenPupsenand0 {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = scan.nextInt();
            }
            if (n % 2 == 0) {
                for (int i = 0; i < n; i += 2) {
                    System.out.print(a[i + 1] + "" "" + -a[i] + "" "");
                }
                System.out.println();
            } else {
                for (int i = 0; i < n - 3; i += 2) {
                    System.out.print(a[i + 1] + "" "" + -a[i] + "" "");
                }
                int x = a[n - 3];
                int y = a[n - 2];
                int z = a[n - 1];
                if (x + y != 0) {
                    System.out.println(-z + "" "" + (-z) + "" "" + (x + y));
                } else if (y + z != 0) {
                    System.out.println((y + z) + "" "" + (-x) + "" "" + (-x));
                } else {
                    System.out.println(-y + "" "" + (x + z) + "" "" + (-y));
                }
            }
        }
    }

}
",1,Plagiarised
829d2024,8a20e743,"import java.util.*;
import java.io.*;


public class Main{
    public static class Element implements Comparable<Element>{
        public int key;
        public int value;
        Element(int k, int v)
        {
            key=k;
            value=v;
        }

        
    }
    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();
        }
    }
}
","import java.io.*;
import java.util.*;
public class C
{ 
	static class Pair{
		int h,in;
		Pair(){}
		Pair(int in,int h){
			this.in=in;
			this.h=h;
		}
	}
	static class customSort implements Comparator<Pair>{
		
	}
    public static void main(String[] args) 
	{ 
		FastReader sc=new FastReader(); 
		StringBuffer ans=new StringBuffer();
		int test=sc.nextInt();
		while(test-->0)
		{
			
			int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt();
			
			int arr[]=new int[n];
			int res[]=new int[n];
			
			int sum =0;
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextInt();sum+=arr[i];
			}
			
			PriorityQueue<Pair> pq=new PriorityQueue<>(new customSort());
			
			for(int i=1;i<=m;i++) {
				pq.add(new Pair(i,0));
			}
			
			ans.append(""YES\n"");
			for(int a:arr) {
				Pair xx=pq.poll();
				ans.append(xx.in+"" "");
				xx.h+=a;
				pq.add(xx);
			}
			ans.append(""\n"");
			
			
		}
	    System.out.print(ans);
	} 
    
 
    
    
    static final Random random=new Random();
    
	
	
	
	
	 


}
",1,Plagiarised
51e5a1a5,960a4c0f,"import java.io.*;
import java.util.*;
public class A {
    static FastScanner fs;
    public static void main(String[] args) {
        fs=new FastScanner();
        int t = fs.nextInt();
        while (t-->0)
            solve();
    }
    public static void solve() {
        int n = fs.nextInt();
        int[] c = fs.readArray(n);
        long sumEven = c[0];
        long minEven = c[0];
        long sumOdd = c[1];
        long minOdd = c[1];
        long ans = n*minOdd+n*minEven;
        for (int i=2; i<n; i++) {
            if (i%2==0) {
                sumEven+=c[i];
                minEven = Math.min(minEven, c[i]);
            }
            else {
                sumOdd+=c[i];
                minOdd = Math.min(minOdd, c[i]);
            }
            ans = Math.min(ans, sumEven+(n-i/2-1)*minEven+sumOdd+(n-(i+1)/2)*minOdd);
        }
        System.out.println(ans);
    }
    
    static final Random random =new Random();
    

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

    
}
",0,Non-plagiarised
5db541bd,5e3089fa,"import java.io.*;

import java.util.*;
/*




*/

 
 public class C{
	static FastReader sc=null;
	
	public static void main(String[] args) {
		sc=new FastReader();
		int t=sc.nextInt();
		
		for(int tt=0;tt<t;tt++) {
			int n=sc.nextInt();
			long k=sc.nextLong();
			int a[]=sc.readArray(n);
			ruffleSort(a);
			
			long sum=0;
			for(int e:a)sum+=e;
			
			if(sum<=k) {
				System.out.println(0);
				continue;
			}
			long l=-1,r=sum-k+1;
			while(l+1<r) {
				long mid=(l+r)/2;
				if(pos(mid,k,a,sum))r=mid;
				else l=mid;
			}
			
			System.out.println(r);
		}
	}
	
	static boolean pos(long m,long k,int a[],long sum) {
		int n=a.length;
		
		//we set the largest of them to be equal val
		long min=sum-m,suf=sum-a[0],moves=m;
		
		for(int i=n-1;i>0;i--) {
			moves--;
			if(moves<0)break;
			long val=a[0]-moves;
			suf-=a[i];
			long tot=suf+val*(n-i+1);
			min=Math.min(min, tot);
		}
		
		return min<=k;
	}
	
	static int[] ruffleSort(int a[]) {
		ArrayList<Integer> al=new ArrayList<>();
		for(int i:a)al.add(i);
		Collections.sort(al);
		for(int i=0;i<a.length;i++)a[i]=al.get(i);
		return a;
	}
	
	
	
	
	
	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SetOrDecrease {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while(t>0){
            String []nk=br.readLine().split("" "");
            int n=Integer.parseInt(nk[0]);
            long k=Long.parseLong(nk[1]);
            String []str=br.readLine().split("" "");
            List<Integer> list=new ArrayList<>();
            for(int i=0;i<n;i++)
                list.add(Integer.parseInt(str[i]));
            Collections.sort(list);
            long sum=0;
            for(int i=0;i<n;i++)
                sum+=list.get(i);
            if(sum<=k)
                System.out.println(0);
            else {
                long minSteps = sum - k;
                long drop=0;
                long targetDrop = sum-k;
                for (int i = n - 1; i > 0; i--) {
                    //assignment at ith element
                    drop += list.get(i) - list.get(0);
                    if (drop >= targetDrop) {
                        if (minSteps > n - i)
                            minSteps = n - i;
                    } else {
                        long diff = targetDrop - drop;
                        long div = diff / (n - i + 1);
                        long rem = diff % (n - i + 1);
                        long steps = rem > 0 ? (div + 1) + n - i : div + n - i;
                        if (minSteps > steps)
                            minSteps = steps;

                    }
                }
                System.out.println(minSteps);
            }
            t--;
        }
    }
}
",0,Non-plagiarised
6f02c6d9,d3a96420,"import java.io.*;
import java.util.*;

public class Main {


    static long mod = 1000000007;

    

    

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

    

    

    

}
","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
20166f71,a98d56f9,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.File;
import java.io.FileInputStream;
import java.util.*;

public class Main {

    // static final File ip = new File(""input.txt"");
    // static final File op = new File(""output.txt"");
    // static {
    // try {
    // System.setOut(new PrintStream(op));
    // System.setIn(new FileInputStream(ip));
    // } catch (Exception e) {
    // }
    // }
    private static final PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int test = 1;
        test = sc.nextInt();
        while (test-- > 0) {
            int n = sc.nextInt();
            long k = sc.nextLong();
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = sc.nextLong();
            }
            sortL(a);
            long[] pref = new long[n + 1];
            for (int i = 0; i < n; i++) {
                pref[i + 1] = pref[i] + a[i];
            }
            long ans = (long) 9e18;
            for (int t = 0; t <= n - 1; t++) {
                long sum = pref[n - t] + a[0] * t;
                long cur = t;
                if (sum > k) {
                    long diff = sum - k;
                    cur += (diff + t) / (t + 1);
                }
                ans = Math.min(ans, cur);
            }
            out.println(ans);
        }
        out.close();
    }

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    static void sortL(long[] arr) {
        int n = arr.length;
        Random rnd = new Random();
        for (int i = 0; i < n; ++i) {
            long tmp = arr[i];
            int randomPos = i + rnd.nextInt(n - i);
            arr[i] = arr[randomPos];
            arr[randomPos] = tmp;
        }
        Arrays.sort(arr);
    }

    ////////////////////////////////// DSU START ///////////////////////////

    

    ////////////////////////////////// DSU END /////////////////////////////

    
}
","import java.util.*;
import java.io.*;
import java.math.*;
 
public class Test{
 
 //Global declarations
 final static Random random = new Random();
 final static FastReader in = new FastReader();
 final static PrintWriter out = new PrintWriter(System.out);
  
  
  
 public static long helperFunction(long x, long y) {
	  //Long range is -10^18 to 10^18 and is 64 bit (8 bytes)
	  //Integer range is ~~ -2 * 10^9(-2^31) to 2 * 10^9(2^31 - 1) and is 32 bit (4 bytes)  
	
	  if(x>=0)
	  return x/y;
	  

	  //for ceiling negative numbers (integers)
	  return (x-y+1)/y;	
 }
	  	
 public static void ruffleLong(long a[]) {
	  
		//shuffle, then sort
		
		int i,j,n=a.length;
		long temp; 
		
		for (i=0; i<n; i++) {
			j = random.nextInt(n);
			
			temp = a[i];
			
			a[i] = a[j]; 
			
			a[j] = temp;
		}
		
		Arrays.sort(a);	
 }
 
 
 
 
  
 public static void main(String ... args) throws IOException {
	// << --> multiply
	// >> --> divide
	
	//variable_name <<= 1 --> (variable)multiply by 2
	//variable_name >>= 1 --> (variable)divide by 2
	
	//2<<3 --> (multiply)2 * 2^3 --> 16;
	//6>>1 --> (divide)6 / 2^1 --> 3;
  
	/**
	  
	int n = in.nextInt(),a,b;
	in.nextLine();
	while(n-->0){
	 a = in.nextInt();
	 b = in.nextInt();
	 out.println(a+b);
	 if(n>0)
	 in.nextLine();
	}	
	out.close();
	
	
	int tt = in.nextInt();
	while(tt-->0){
		out.println(helperFunction());
	}
	
	//out.println(helperFunction());
	
	**/
	
	
	//it returns the remaining length (+ve) so bigger so swap
	//System.out.println(""h"".compareTo(""ha""));
	
	/*
	Problem 13 - Large sum
	  
	String s = ""37107287533902102798797998220837590246510135740250463769376774900097126481248969700780504170182605387432498619952474105947423330951305812372661730962991942213363574161572522430563301811072406154908250230675882075393461711719803104210475137780632466768926167069662363382013637841838368417873436172675728112879812849979408065481931592621691275889832738442742289174325203219235894228767964876702721893184745144573600130643909116721685684458871160315327670386486105843025439939619828917593665686757934951621764571418565606295021572231965867550793241933316490635246274190492910143244581382266334794475817892575867718337217661963751590579239728245598838407582035653253593990084026335689488301894586282278288018119938482628201427819413994056758715117009439035398664372827112653829987240784473053190104293586865155060062958648615320752733719591914205172558297169388870771546649911559348760353292171497005693854370070576826684624621495650076471787294438377604532826541087568284431911906346940378552177792951453612327252500029607107508256381565671088525835072145876576172410976447339110607218265236877223636045174237069058518606604482076212098132878607339694128114266041808683061932846081119106155694051268969251934325451728388641918047049293215058642563049483624672216484350762017279180399446930047329563406911573244438690812579451408905770622942919710792820955037687525678773091862540744969844508330393682126183363848253301546861961243487676812975343759465158038628759287849020152168555482871720121925776695478182833757993103614740356856449095527097864797581167263201004368978425535399209318374414978068609844840309812907779179908821879532736447567559084803087086987551392711854517078544161852424320693150332599594068957565367821070749269665376763262354472106979395067965269474259770973916669376304263398708541052684708299085211399427365734116182760315001271653786073615010808570091499395125570281987460043753582903531743471732693212357815498262974255273730794953759765105305946966067683156574377167401875275889028025717332296191766687138199318110487701902712526768027607800301367868099252546340106163286652636270218540497705585629946580636237993140746255962240744869082311749777923654662572469233228109171419143028819710328859780666976089293863828502533340334413065578016127815921815005561868836468420090470230530811728164304876237919698424872550366387845831148769693215490281042402013833512446218144177347063783299490636259666498587618221225225512486764533677201869716985443124195724099139590089523100588229554825530026352078153229679624948164195386821877476085327132285723110424803456124867697064507995236377742425354112916842768655389262050249103265729672370191327572567528565324825826546309220705859652229798860272258331913126375147341994889534765745501184957014548792889848568277260777137214037988797153829820378303147352772158034814451349137322665138134829543829199918180278916522431027392251122869539409579530664052326325380441000596549391598795936352974615218550237130764225512118369380358038858490341698116222072977186158236678424689157993532961922624679571944012690438771072750481023908955235974572318970677254791506150550495392297953090112996751986188088225875314529584099251203829009407770775672113067397083047244838165338735023408456470580773088295917476714036319800818712901187549131054712658197623331044818386269515456334926366572897563400500428462801835170705278318394258821455212272512503275512160354698120058176216521282765275169129689778932238195734329339946437501907836945765883352399886755061649651847751807381688378610915273579297013376217784275219262340194239963916804498399317331273132924185707147349566916674687634660915035914677504995186714302352196288948901024233251169136196266227326746080059154747183079839286853520694694454072476841822524674417161514036427982273348055556214818971426179103425986472045168939894221798260880768528778364618279934631376775430780936333301898264209010848802521674670883215120185883543223812876952786713296124747824645386369930090493103636197638780396218407357239979422340623539380833965132740801111666627891981488087797941876876144230030984490851411606618262936828367647447792391803351109890697907148578694408955299065364044742557608365997664579509666024396409905389607120198219976047599490197230297649139826800329731560371200413779037855660850892521673093931987275027546890690370753941304265231501194809377245048795150954100921645863754710598436791786391670211874924319957006419179697775990283006991536871371193661495281130587638027841075444973307840789923115535562561142322423255033685442488917353448899115014406480203690680639606723221932041495354150312888033953605329934036800697771065056663195481234880673210146739058568557934581403627822703280826165707739483275922328459417065250945123252306082291880205877731971983945018088807242966198081119777158542502016545090413245809786882778948721859617721078384350691861554356628840622574736922845095162084960398013400172393067166682355524525280460972253503534226472524250874054075591789781264330331690"";
	StringBuilder st = new StringBuilder("""");
	int i,ct=0,p=0;
	BigInteger res = BigInteger.valueOf(0);
	String a[] = new String[100];
	for(i=0;i<5000;++i){
		
		st.append(s.charAt(i));
		++ct;
		
		if(ct == 50){
			a[p] = st.toString();
			ct=0;
			++p;
			st.setLength(0);
		}
		
	}
	//out.println(Arrays.toString(a));
	
	for(String val: a){
		res = res.add(new BigInteger(val));
	}
	
	out.println(res.toString());*/
	
	//out.println(helperFunction());
	
	
	//String airports[] = {""AAA"", ""AAAA""};
	
	//int i,n=airports.length;
	
	
	
	
	/*
	Maximum number of unique values in the array after performing given operations
 
	int a[] = {1,2,4,4};
	int i,n = a.length,res=0;
	
	int mp[] = new int[n+2];
	
	Arrays.sort(a);
	
	for(i=0;i<n;++i){
		
		if(mp[a[i]] == 0)
		++mp[a[i]];
		
		else if(mp[a[i]+1] == 0)
			++mp[a[i]+1];
			
		else if(mp[a[i]-1] == 0)
			++mp[a[i]-1];
	}
	
	for(int val: mp){
		if(val > 0)
			++res;
	}
	
	out.println(res);*/
	
	
	int tt = in.nextInt();
	
	while(tt-->0){
		
		int n = in.nextInt();
		long k = in.nextLong();
		
		
		int i,y;
		long a[] = new long[n];
		long pref[] = new long[n];
		
		long x,res=Long.MAX_VALUE;
		
		for(i=0;i<n;++i)
			a[i] = in.nextLong();
			
		
		ruffleLong(a);
		
		pref[0] = a[0];
			
		for(i=1;i<n;++i)
		pref[i] = pref[i-1]+a[i];
			
		//out.println(Arrays.toString(pref));
		
		//we have to minimize (x+y)
		//x --> decrease/minimize the smallest value (a[0]) by x
		//y --> no.of times settting largest values to the smallest value in (descending order)
		
		for(y=0;y<n;++y){
			
			// x cannot be negative
			x = Math.max(0,a[0] - (helperFunction((k-pref[n-1-y]+pref[0]),y+1)));
			
			res = Math.min(res,y+x);
			
			//out.println(y+"" ""+x);
				
		}
		
		out.println(res);
	}
		
	
	out.close();
}
 
 
 }
",0,Non-plagiarised
2f8c3bf3,a3abac01,"import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
		    int n=sc.nextInt();
		    int k=sc.nextInt();
		    
		    int idx[]=new int[k];
		    
		    for(int i=0;i<k;i++){
		        idx[i]=sc.nextInt();
		    }
		    
		    long arr[]=new long[n];
		    Arrays.fill(arr,Integer.MAX_VALUE);
		    for(int i=0;i<k;i++){
		        long temp=sc.nextLong();
		        arr[idx[i]-1]=temp;
		    }
		    
		    long left[]=new long[n];
		    long right[]=new long[n];
		    
		    Arrays.fill(left,Integer.MAX_VALUE);
		    Arrays.fill(right,Integer.MAX_VALUE);
		    
		    
		    left[0]=arr[0];
		    
		    for(int i=1;i<n;i++){
		       left[i]=Math.min(left[i-1]+1,arr[i]);
		    }
		    
		    right[arr.length-1]=arr[arr.length-1];
		    
		    for(int i=n-2;i>=0;i--){
		        right[i]=Math.min(right[i+1]+1,arr[i]);
		    }
		    
		    for(int i=0;i<n;i++){
		      //  System.out.print(left[i]+""--""+right[i]+""\\"");
		       
		       
		       System.out.print(Math.min(left[i],right[i])+"" "");
		    }
		    System.out.println();
		  
		}
	}
}
","import  java.math.*;
import java.util.*;
import java.lang.*;
import java.io.*;



public final class Main {

    FastReader s;


    public static void main (String[] args) throws java.lang.Exception
    {

        new Main().run();

    }
    void run()
    {
        s = new FastReader();
        solve();
    }
   StringBuffer sb;
    void solve()
    {
         sb = new StringBuffer();
        for(int T = s.nextInt();T > 0;T--)
            start();
       // System.out.print(sb);

    }


    void start()
    {
        int n = s.nextInt();
        int m = s.nextInt();
        long arr[] = longArr(m);
        long arr2[] = longArr(m);
        long ans [] = new long[n];
        Arrays.fill(ans,Integer.MAX_VALUE);
        for(int i = 0; i<m; i++)
        {
            ans[(int)arr[i]-1] = arr2[i];
        }
        long left [] = new long[n];
        long right [] = new long[n];
        left[0] = ans[0];
        for(int i = 1; i<n; i++)
        {
            left[i] = Math.min(ans[i], left[i-1]+1);
        }
        right[n-1] = ans[n-1];
        for(int i = n-2; i>=0; i--)
        {
            right[i] = Math.min(right[i+1]+1, ans[i]);
        }
        StringBuffer x = new StringBuffer();
        for(int i =0; i<n; i++)
        {
            long p = Math.min(left[i],right[i]);
            x.append(p+"" "");
        }
        System.out.println(x);

    }
    
    
    

    

    


    
    
    

    //long 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
    

    

}
",1,Plagiarised
680ba922,6d7d5dd7,"import java.util.*;
import java.io.*;

public class Solution
{
    
    
   
  
  
  
  
  
  
  
 
  
    // 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.
    
    
    
   

static int dp[][];



    public static void main(String []args) throws IOException
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-- > 0)
        {
            int n = sc.nextInt();
            sc.nextLine();
            String a = sc.nextLine();
            String b = sc.nextLine();
            int same = 0 , zo = 0 , oz = 0 , oo = 0 , zz = 0;
            for(int i = 0 ; i < n ; i++)
            {
                if(a.charAt(i) == '0' && b.charAt(i) == '1')
                oz++;
                
                else if(a.charAt(i) == '1' && b.charAt(i) == '0')
                zo++;
                
                else if(a.charAt(i) == '1' && b.charAt(i) == '1')
                oo++;
                
                else
                zz++;
            }
            
            if(oz == zo || (zz == oo-1))
            {
                int mx = Integer.MAX_VALUE;
                if(oz == zo)
                mx = Math.min(mx,2*oz);
                
                if(oo-1 == zz)
                mx = Math.min(mx,zz+oo);
                
                System.out.println(mx);
            }
            
            else
            {
                System.out.println(-1);
            }
        }
    }
}
","import java.util.Scanner;

public class Menorah {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        k:
        while (t-- > 0) {
            int n = scan.nextInt();
            String a = scan.next();
            String b = scan.next();
            int zo = 0;
            int oz = 0;
            int ind = -1;
            for (int i = 0; i < n; i++) {
                if (a.charAt(i) == '0' && b.charAt(i) == '1') {
                    ++zo;
                } else if (a.charAt(i) == '1' && b.charAt(i) == '0') {
                    ++oz;
                } else if (a.charAt(i) == '1' && b.charAt(i) == '1') {
                    ind = i;
                }
            }
            int res = 1000000000;
            int res2 = 1000000000;
            if (zo == oz) {
                res = zo + oz;
            }
            if (ind != -1) {
                char[] s = a.toCharArray();
                for (int i = 0; i < n; i++) {
                    if (i == ind) {
                        continue;
                    }
                    if (s[i] == '0') {
                        s[i] = '1';
                    } else {
                        s[i] = '0';
                    }
                }

                zo = 0;
                oz = 0;

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

                    if (s[i] == '0' && b.charAt(i) == '1') {
                        ++zo;
                    } else if (s[i] == '1' && b.charAt(i) == '0') {
                        ++oz;
                    }
                }

                if (zo == oz) {
                    res2 = zo + oz + 1;
                }

            }
            if (res == 1000000000 && res2 == 1000000000) {
                System.out.println(""-1"");
            } else {
                System.out.println(Math.min(res, res2));
            }

        }
    }
}
",0,Non-plagiarised
4ea10951,66e74577,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static String f1(String s, int index) {
        StringBuffer sb = new StringBuffer();
        for(int i =0;i<s.length();i++){
            if( i == index) sb.append(s.charAt(i));
            else if (s.charAt(i) == '0') sb.append('1');
            else sb.append('0');
        }
        return sb.toString();
    }
    static long solve(String s1, String s2) {
        if(s1.equals(s2)) return 0;
        int o1 = 0, o2 = 0, diff = 0;
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) == '1') o1++;
            if (s2.charAt(i) == '1') o2++;
            if (s1.charAt(i) != s2.charAt(i)) diff++;
        }
        return o1 == o2? diff : Integer.MAX_VALUE;
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            String s1 = br.readLine();
            String s2 = br.readLine();
            long res = solve(s1, s2);
            for(int i=0;i<s1.length();i++) {
                if(s1.charAt(i) == '1' && s2.charAt(i) == '1') {
                    res = Math.min(res, 1 + solve(f1(s1, i), s2));
                    break;
                }
            }
            for(int i=0;i<s1.length();i++) {
                if(s1.charAt(i) == '1' && s2.charAt(i) == '0') {
                    res = Math.min(res,1 + solve(f1(s1, i), s2));
                    break;
                }
            }
            if(res == Integer.MAX_VALUE) System.out.println(""-1"");
            else System.out.println(res);
        }
    }
}
","import java.io.*;
import java.util.*;

public class Menorah {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			String original = in.next();
			String target = in.next();
			int numDiff = 0;
			int original1 = 0;
			int target1 = 0;
			for (int i=0; i<n; i++) {
				if (original.charAt(i)!=target.charAt(i)) {
					numDiff++;
				}
				if (original.charAt(i)=='1') original1++;
				if (target.charAt(i)=='1') target1++;
			}
			int evenAns = Integer.MAX_VALUE;
			int oddAns = Integer.MAX_VALUE;
			if (original1==target1) {
				evenAns = numDiff;
			}
			for (int i=0; i<n; i++) {
				if (original.charAt(i)=='1' && target.charAt(i)=='1') {
					int ones = (n-original1)+1;
					if (ones==target1) {
						oddAns = n-numDiff;
					}
					break;
				}
			}
			for (int i=0; i<n; i++) {
				if (original.charAt(i)=='1' && target.charAt(i)=='0') {
					int ones = (n-original1)+1;
					if (ones==target1) {
						oddAns = Math.min(n-numDiff+1, oddAns);
					}
					break;
				}
			}
			int ans = Math.min(evenAns, oddAns);
			if (ans==Integer.MAX_VALUE) System.out.println(-1);
			else System.out.println(ans);
		}
	}
	
}
",0,Non-plagiarised
90f01508,ec8566b8,"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 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.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;
        }

        

        
    }

    

    

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

    

    
}
",0,Non-plagiarised
26e699de,402aff07,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

        Scanner sc= new Scanner(System.in);
        int numberTest=sc.nextInt();
        while(numberTest-->0){
            int n=sc.nextInt();
            char[] s=new char[n+5];
            char[] t=new char[n+5];
            String ss=sc.next();
            String tt=sc.next();
            s=ss.toCharArray();
            t=tt.toCharArray();
            int cntax = 0, cntbx = 0, same = 0;
            int ans=MOD9;
            for(int i=0; i<n; i++){
                if(s[i]=='1')cntax++;
                if(t[i]=='1')cntbx++;
                if(s[i]==t[i])same++;
            }
            if(same==n){
                System.out.println(0);
                continue;
            }
            else if (cntax==0){
                System.out.println(-1);
                continue;
            }
            if(cntax==cntbx){
                ans=Math.min(ans,n-same);
            }
            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
            if(ans<MOD9) System.out.println(ans);
            else System.out.println(-1);



        }

    }
}
","import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t-- > 0){
            int n = s.nextInt();
            String a = s.next();
            String b = s.next();
            int a1 = 0, b1 = 0;
            for (char c: a.toCharArray()){
                if (c == '1') a1++;
            }
            for (char c: b.toCharArray()){
                if (c == '1') b1++;
            }
            int ans = Integer.MAX_VALUE;
            int res = 0;
            for (int i = 0; i < n; i++) {
                if (a.charAt(i) != b.charAt(i)) res++;
            }
            if (a1 == b1) ans = Math.min(ans, res);
            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
            if (ans == Integer.MAX_VALUE){
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
    }
}
",0,Non-plagiarised
71c7ac71,8f778337,"import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class E{
	public static void main(String[] args) throws IOException {
		// br = new BufferedReader(new FileReader("".in""));
		// out = new PrintWriter(new FileWriter("".out""));
		//new Thread(null, new (), ""peepee"", 1<<28).start();
		
		int q =readInt();
		while(q-->0) {
			br.readLine();
			int n =readInt();
			int k =readInt();
			int[] ans = new int[n];
			Arrays.fill(ans, (int)2e9+1);
			int[] a = new int[k];
			int[] t = new int[k];
			int mini = 0, maxi = 0;
			for (int i = 0 ;i  <k; i+=1) {
				a[i]=readInt()-1;
				if (a[i] < a[mini]) mini = i;
				if (a[i] > a[maxi]) maxi = i;
			}
			for (int j = 0; j  <k; j++) t[j]=readInt();
			for (int i = 0; i < k; i++) ans[a[i]]=t[i];
			int[] l = new int[n];
			int[] r = new int[n];
			Arrays.fill(l, (int)2e9);
			Arrays.fill(r, (int)2e9);
			int temp = t[mini];
			for (int i = a[mini]; i < n; i++) {
				l[i] = temp = min(temp+1, ans[i]);
			}
			temp = t[maxi];
			for (int i = a[maxi]; i >= 0; i--) {
				r[i] = temp = min(temp+1,ans[i]);
			}
			
			for (int i = 0; i < n; i++) out.print(min(l[i],r[i]) + "" "");
			out.println();
		}
		
		out.close();
	}
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	static StringTokenizer st = new StringTokenizer("""");
	static String read() throws IOException{return st.hasMoreTokens() ? st.nextToken():(st = new StringTokenizer(br.readLine())).nextToken();}
	static int readInt() throws IOException{return Integer.parseInt(read());}
	
	
	
}
","import java.util.*;
import java.io.*;
public class AirConditioner{
    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){
            br.readLine();
            StringTokenizer st=null;
            st=new StringTokenizer(br.readLine());
            int n=Integer.parseInt(st.nextToken());
            int k=Integer.parseInt(st.nextToken());
            int[] idx=new int[k];
            int[] temp=new int[k];
            st=new StringTokenizer(br.readLine());
            for(int i=0;i<k;i++){
                idx[i]=Integer.parseInt(st.nextToken());
            }
            st=new StringTokenizer(br.readLine());
            for(int i=0;i<k;i++){
                temp[i]=Integer.parseInt(st.nextToken());
            }
            int[] arr=new int[n];
            Arrays.fill(arr,Integer.MAX_VALUE-1);
            for(int i=0;i<k;i++){
                arr[idx[i]-1]=temp[i];
            }
            int[] left=new int[n];
            int[] right=new int[n];
            left[0]=Math.min(Integer.MAX_VALUE,arr[0]);
            for(int i=1;i<n;i++){
                left[i]=Math.min(left[i-1]+1,arr[i]);
            }
            right[n-1]=Math.min(Integer.MAX_VALUE,arr[n-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++){
                arr[i]=Math.min(left[i],right[i]);
            }
            for(int tp:arr)
                System.out.print(tp+"" "");
            System.out.println();

        }
    }
}
",0,Non-plagiarised
949502c2,e647bef7,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class Template {

	static int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int yo = sc.nextInt();
		while (yo-- > 0) {
			int n = sc.nextInt();
            int a = sc.nextInt()-1;
            int b = sc.nextInt()-1;
            int da = sc.nextInt();
            int db = sc.nextInt();
            
            List<List<Integer>> list = new ArrayList<>();
            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
            
            for(int i = 0; i < n-1; i++){
                int x = sc.nextInt()-1;
                int y = sc.nextInt()-1;
                list.get(x).add(y);
                list.get(y).add(x);
            }
            
            for(int i = 0; i <= n; i++) depth[i] = 0;
            diam = 0;
            dfs(a,-1,list);
            
            if(2 * da >= min(diam, db) || depth[b] <= da){
                out.println(""Alice"");
            }
            else {
                out.println(""Bob"");
            }
            
		}
	}
    
    static int[] depth = new int[200001];
    static int diam = 0;
    static int dfs(int x, int p, List<List<Integer>> list) {
        int len = 0;
        List<Integer> ne = list.get(x);
        for(int y : ne) {
            if(y != p) {
                depth[y] = depth[x] + 1;
                int cur = 1 + dfs(y, x,list);
                diam = max(diam, cur + len);
                len = max(len, cur);
            }
        }
        return len;
    }
   

	

	

	

	

	

	

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
","import java.io.*;
import java.util.*;

public class Main {
    private static final boolean N_CASE = true;
    private List<List<Integer>> g;
    private int a;
    private int b;
    private int da;
    private int db;
    private int max;
    private int ab;

    private int dfs(int u, int fa, int depth) {
        if (u == a) {
            ab = depth;
        }

        int m1 = 0, m2 = 0;
        for (int v : g.get(u)) {
            if (v != fa) {
                int m = dfs(v, u, depth + 1) + 1;
                if (m > m1) { m2 = m1; m1 = m; }
                else if (m > m2) { m2 = m; }
            }
        }
        max = Math.max(max, m1 + m2);
        int cmax = Math.max(m1, m2);
        max = Math.max(max, cmax + depth);
        return cmax;
    }

    private void solve() {
        int n = sc.nextInt();
        a = sc.nextInt() - 1; b = sc.nextInt() - 1;
        da = sc.nextInt(); db = sc.nextInt();

        g = createGraph(n);
        for (int i = 0; i < n - 1; ++i) {
            int u = sc.nextInt() - 1, v = sc.nextInt() - 1;
            g.get(u).add(v);
            g.get(v).add(u);
        }
        max = 0;
        dfs(b, -1, 0);
        db = Math.min(max, db);

        boolean win = true;
        if (ab > da) {
            if (db > da * 2) {
                win = false;
            }
        }

        out.println(win ? ""Alice"" : ""Bob"");
    }

    private void run() {
        int T = N_CASE ? sc.nextInt() : 1;
        for (int t = 0; t < T; ++t) {
            solve();
        }
    }

    private static MyWriter out;
    private static MyScanner sc;

    

    private static class MyWriter extends PrintWriter {
        private MyWriter(OutputStream outputStream) {
            super(outputStream);
        }

        

        

        void println(int[] a) {
            for (int v : a) {
                println(v);
            }
        }

        

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

    

    

    public static void main(String[] args) {
        out = new MyWriter(new BufferedOutputStream(System.out));
        sc = new MyScanner();
        new Main().run();
        out.close();
    }
}
",0,Non-plagiarised
8a39dbf5,ff3283cf,"import java.util.*;
import java.lang.*;
import java.io.*;
 
/* Name of the class has to be ""Main"" only if the class is public. */
public class Codeforces {
    public static void main(String[] args) throws java.lang.Exception {
        /* your code goes here */
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
       int t = Integer.parseInt(buf.readLine());
        StringBuilder sb = new StringBuilder();
       for (int i = 0; i < t; i++) {
           String st=buf.readLine();
          String st1[]=(buf.readLine()).split("" "");
          int n=Integer.parseInt(st1[0]);
          int k=Integer.parseInt(st1[1]);
          int a[]=new int[k];
          int temp[]=new int[k];
          long arr[]=new long[n];
          String st2[]=(buf.readLine()).split("" "");
           String st3[]=(buf.readLine()).split("" "");
           for(int j=0;j<k;j++)
           {
               a[j]=Integer.parseInt(st2[j]);
               temp[j]=Integer.parseInt(st3[j]);
           }
          for(int j=0;j<k;j++)
          {
              arr[a[j]-1]=temp[j];
          }
          long min=Integer.MAX_VALUE;
          long left[]=new long[n];
          long right[]=new long[n];
          if(arr[0]==0)
              left[0]=min;
          else
              left[0]=arr[0];
          for(int j=1;j<n;j++)
          {
              if(arr[j]==0)
              {
                  left[j]=left[j-1]+1;
              }
              else
              {
                  left[j]=Math.min(left[j-1]+1,arr[j]);
              }
          }
          if(arr[n-1]==0)
              right[n-1]=min;
          else
              right[n-1]=arr[n-1];
          for(int j=n-2;j>=0;j--)
          {
              if(arr[j]==0)
              {
                  right[j]=right[j+1]+1;
              }
              else
              {
                  right[j]=Math.min(right[j+1]+1,arr[j]);
              }
          }
          for(int j=0;j<n;j++)
          {
              arr[j]=Math.min(left[j],right[j]);
              sb.append(arr[j]+"" "");
          }
          sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codeforces {
    public static void main(String[] args) throws java.lang.Exception {
        /* your code goes here */
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
       int t = Integer.parseInt(buf.readLine());
        StringBuilder sb = new StringBuilder();
       for (int i = 0; i < t; i++) {
           String st=buf.readLine();
          String st1[]=(buf.readLine()).split("" "");
          int n=Integer.parseInt(st1[0]);
          int k=Integer.parseInt(st1[1]);
          int a[]=new int[k];
          int temp[]=new int[k];
          long arr[]=new long[n];
          String st2[]=(buf.readLine()).split("" "");
           String st3[]=(buf.readLine()).split("" "");
           for(int j=0;j<k;j++)
           {
               a[j]=Integer.parseInt(st2[j]);
               temp[j]=Integer.parseInt(st3[j]);
           }
          for(int j=0;j<k;j++)
          {
              arr[a[j]-1]=temp[j];
          }
          long min=Integer.MAX_VALUE;
          long left[]=new long[n];
          long right[]=new long[n];
          if(arr[0]==0)
              left[0]=min;
          else
              left[0]=arr[0];
          for(int j=1;j<n;j++)
          {
              if(arr[j]==0)
              {
                  left[j]=left[j-1]+1;
              }
              else
              {
                  left[j]=Math.min(left[j-1]+1,arr[j]);
              }
          }
          if(arr[n-1]==0)
              right[n-1]=min;
          else
              right[n-1]=arr[n-1];
          for(int j=n-2;j>=0;j--)
          {
              if(arr[j]==0)
              {
                  right[j]=right[j+1]+1;
              }
              else
              {
                  right[j]=Math.min(right[j+1]+1,arr[j]);
              }
          }
          for(int j=0;j<n;j++)
          {
              arr[j]=Math.min(left[j],right[j]);
              sb.append(arr[j]+"" "");
          }
          sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
",1,Plagiarised
0922b7e7,c34bb733,"import java.io.*;
import java.util.*;

public class PhoenixAndTowers {
	public static void main(String[] args) throws IOException {
		// BufferedReader in = new BufferedReader(new FileReader(""PhoenixAndTowers.in""));
		// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(""PhoenixAndTowers.out"")));
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);

		int T = Integer.parseInt(in.readLine());
		for (int i = 0; i < T; i++) {
			StringTokenizer st = new StringTokenizer(in.readLine());
			int N = Integer.parseInt(st.nextToken());
			int M = Integer.parseInt(st.nextToken());
			int X = Integer.parseInt(st.nextToken());
			PriorityQueue<Tower> towers = new PriorityQueue<Tower>();
			for (int j = 1; j <= M; j++) towers.add(new Tower(j, 0));
			out.println(""YES"");
			st = new StringTokenizer(in.readLine());
			for (int j = 0; j < N; j++) {
				Tower t = towers.remove();
				t.size += Integer.parseInt(st.nextToken());
				towers.add(t);
				out.print(t.idx + "" "");
			}
			out.println();
		}

		out.close();
		in.close();
	}
	
	public static class Tower implements Comparable<Tower> {
		int idx, size;
		public Tower(int idx, int size) {
			this.idx = idx;
			this.size = size;
		}
		
	}
}
","import java.io.*;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.math.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Vector;
import static java.lang.Math.sqrt;
import static java.lang.Math.floor;






public class topcoder {
   
	


	
	
	
static class pairr implements  Comparable<pairr>{
	Integer value;
	Integer index;
	
	   public pairr(Integer value, Integer index) {
		    this.value = value;
		    this.index = index;
	   }
	   
}



	 
	
	
	 
	 
	 
	 
	 
	 
	 
		     
		     
		     
		     
			  
			  
			  
			      
			    // Prints all prime numbers smaller than 'n'
			
			    
			    
			    
			 
               
            
			  public static int add(long n, long num, long a, int i) {
				//System.out.println(num);
				  if(num > n)return -1;
				
				  if(num == n) {
					  
					  return i;
				  }
				  
				if(a < 2050)return -1;
				  
				
				 
				  long temp = num+a;
				  
				  if(temp <= n) {
				return	  add(n,temp,a,i+1);
				  }else if(temp > n){
					  a /= 10;
					  return add(n,num,a,i);
				  }
				  
			      return -1;
				  }
			
				   
		
		
		
		
		
		
		
		
		
		  
		  

		    
		    
		    
		    
		    
		
		
			
	    
	   
	  
			
	    public static void main(String args[])throws IOException{
			 
	    	//	 System.setIn(new FileInputStream(""Case.txt""));
	    		 BufferedReader ob = new BufferedReader(new InputStreamReader(System.in));
	    	    
	    		 
	    		 int t = Integer.parseInt(ob.readLine());
	    		 
	    		 
	    		 while( t--> 0) {
	    		
	    		StringTokenizer	 st = new StringTokenizer(ob.readLine());
	    			 int n = Integer.parseInt(st.nextToken());
	    			 int m = Integer.parseInt(st.nextToken());
	    			 int x = Integer.parseInt(st.nextToken());
	    			 
	    			 int []ar = new int[n];
	    			 st = new StringTokenizer(ob.readLine());
	    			 PriorityQueue<Integer>pq = new PriorityQueue<>();
	    			 
	    			 for(int i = 0; i < n; i++) {
	    				 ar[i] = Integer.parseInt(st.nextToken());
	    				 pq.add(ar[i]);
	    			 }
	    			 
	    			 
	    	PriorityQueue<pairr>p = new PriorityQueue<>();
	    	for(int i =0; i < n; i++) {
	    		p.add(new pairr(ar[i],i));
	    	}
	    	int []ans = new int[n];
	    	
	    	
	    	for(int i = 0; i < n; i++) {
	    	pairr a = p.poll();
	    	ans[a.index] = (i%m)+1;
	    	}
	    	
	    	System.out.println(""YES"");
	    	for(int i = 0; i < n; i++ ) {
	    		System.out.print(ans[i]+"" "");
	    	}
	    	System.out.println();
	    		 }
	    }
}
",0,Non-plagiarised
c57997b6,ff10b574,"import java.io.*;
import java.util.*;
import java.util.Map.Entry;

public class AMain {
	
	public static void main(String[] args) {
		FastReader in = new FastReader(System.in);
		
		try(PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));)
		{
			new AMain().solve(in, out);
		}
	}
	
	public void solve(FastReader in, PrintWriter out)
	{
		int t = in.nextInt();
		while(t-->0)
		{
			int n = in.nextInt();
			int[] a= in.nextInts(n);
			char[] clr = in.next().toCharArray();
			
			ArrayList<ArrayList<Integer> > rgh = new ArrayList<>();
			for(int i=0;i<n;i++)
				rgh.add(new ArrayList<>());
			
			boolean ok = true;
			
			for(int i=0;i<n;i++)
				if(clr[i] == 'B')
				{
					if(a[i]<1)
						ok = false;
					else
						rgh.get(0).add(a[i]-1);
				}
				else
				{
					if(a[i]>n)
						ok = false;
					else
						rgh.get(Math.max(0, a[i]-1)).add(n-1);
				}
			
			
			TreeMap<Integer, Integer> q = new TreeMap<>();
			for(int i=0;i<n;i++)
			{
				for(int j: rgh.get(i))
					q.put(j, q.getOrDefault(j, 0)+1);
				if(q.isEmpty() || q.firstKey() < i)
				{
					ok = false;
					break;
				}
				Entry<Integer, Integer> cur = q.firstEntry();
				
				if(cur.getValue() == 1)
					q.remove(cur.getKey());
				else
					q.put(cur.getKey(), cur.getValue()-1);
			}
			out.println(ok? ""YES"":""NO"");
			out.flush();
		}
	
	}

}

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

public class Main {
    public static void main(String[] args) throws IOException {
        int t = nextInt();
        while (t-- != 0) {
            int n = nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            String s = nextToken();
            ArrayList<Integer> r = new ArrayList<>();
            ArrayList<Integer> b = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (s.charAt(i) == 'B') b.add(a[i]);
                else r.add(a[i]);
            }
            Collections.sort(b);
            Collections.sort(r);
            int y = 1;
            boolean e = true;
            for (int i = 0; i < b.size(); i++) {
                if (b.get(i) < y) {
                    e = false;
                    break;
                }
                y++;
            }
            for (int i = 0; i < r.size(); i++) {
                if (r.get(i) > y) {
                    e = false;
                    break;
                }
                y++;
            }
            if(e)out.println(""YES"");
            else out.println(""NO"");
        }
        out.close();
    }

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(System.out);
    static StringTokenizer in = new StringTokenizer("""");


    

    public static String nextToken() throws IOException {
        while (!in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }

    public static int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    

    
}
",0,Non-plagiarised
829d2024,9852706b,"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;
        }

        
    }
    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();
        }
    }
}
","import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
    static int modulo=998244353;
    public static void main(String[] args) {
       
        FastScanner in = new FastScanner();
        int test=in.nextInt();
        while(test-->0){
            int n=in.nextInt();
            int m=in.nextInt();
            int x=in.nextInt();
             PriorityQueue<pair> pq=new PriorityQueue<>();
            int arr[]=new int[n];
            for(int i=1;i<=m;i++){
                pq.add(new pair(i,0));
            }
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                pair p=pq.poll();
                int a=in.nextInt();
                p.y+=a;
                pq.add(p);
                System.out.print(p.x+"" "");
            }
            
            
            
            System.out.println();
        }
        
        
       
        
        
//        int sum=in.nextInt();
//        
//        boolean dp[][]=new boolean[n+1][sum+1];
//        
//        for(int i=0;i<=n;i++){
//            for(int j=0;j<=sum;j++){
//                if(i==0)
//                    dp[i][j]=false;
//                if(j==0)
//                    dp[i][j]=true;
//                    
//            }
//        }
//        
//        for(int i=1;i<=n;i++){
//            for(int j=1;j<=sum;j++){
//                if(arr[i-1]<=j)
//                    dp[i][j]=(dp[i-1][j])||(dp[i-1][j-arr[i-1]]);
//                else
//                    dp[i][j]=dp[i-1][j];
//                
//            }
//        }
//         boolean flag=false;
//        for(int i=0;i<=n;i++){
//            if(dp[i][sum]==true){
//                flag=true;
//                System.out.println(1);
//                break;
//            }
//            
//        }
//        if(!flag)
//            System.out.println(0);
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
}

class pair implements Comparable<pair>
	    {
	        int x;
	        int y;
 
	        pair(int x, int y) {
	            this.x = x;
	            this.y = y;
	        }
	        
}
",1,Plagiarised
213340b3,35f0c004,"import java.util.*;
import java.io.*;
public class Solution {
    
    
    
    
    

    static int mod = (int)1e9+7;
    static int INF = Integer.MAX_VALUE;
    static PrintWriter out;
    static FastReader sc ;
    public static void main(String[] args) throws IOException {
        sc = new FastReader();
        out = new PrintWriter(System.out);
        // primes();
        // ================================ //
        int test = sc.nextInt();
        while (test-- > 0) {
            int n = sc.nextInt();
            String s = sc.nextLine();
            String t = sc.nextLine();
            solver(s,t, n);
        }
        // ================================ //
        // int n = sc.nextInt();
        // solver();
        // ================================ //
        out.flush();
    }

    public static void solver(String s, String t, int n) {
        int diff = 0;
        int one = 0;
        int zero = 0;
        for(int i=0;i<n;i++){
            if(s.charAt(i)!=t.charAt(i)){
                diff++;
                if(s.charAt(i)=='1')one++;
            }
            else{
                if(s.charAt(i)=='1')zero++;
            }
        }
        if(diff==0){
            out.println(0);
            return;
        }
        int res = INF;
        if(diff%2==0 && one==(diff-one)){
            res = diff;
        }
        if(n-diff-1>=0 && (n-diff-1)%2==0 && zero>0 && (n-diff-zero)==zero-1){
            res = Math.min(res, (n-diff-1)+1);
        }
        out.println(res==INF?-1:res);
    }
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            String a=input.next();
            String b=input.next();
            int same1=0,same0=0,opp1=0,opp0=0;
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)==b.charAt(i))
                {
                    if(a.charAt(i)=='1') same1++;
                    else same0++;
                }
                else
                {
                    if(a.charAt(i)=='1') opp1++;
                    else opp0++;
                }
            }
            if(same0+same1==n)
            {
                out.println(0);
            }
            else
            {
                int x=same1+opp1;
                int y=same1+opp0;
                int z=same0+opp0;
                if(x==y || (z+1)==y)
                {
                    int min=Integer.MAX_VALUE;
                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
                    {
                        min=Math.min(min,same0+same1);
                    }
                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
                    {
                        min=Math.min(min,opp0+opp1);
                    }
                    out.println(min);
                }
                else
                {
                    out.println(-1);
                }
            }
        }
        out.close();
    }
    
}
",0,Non-plagiarised
169e34bf,d9199dfd,"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.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
39210347,68dff461,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
            }
            int b[]=new int[n];
            if(n%2==0)
            {
                for(int i=0;i<n;i+=2)
                {
                    int v1=Math.abs(a[i]),v2=Math.abs(a[i+1]);
                    int l=lcm(v1,v2);
                    int x=l/v1,y=l/v2;
                    if((a[i]>=0 && a[i+1]<0) || (a[i]<0 && a[i+1]>=0))
                    {
                        b[i]=x;
                        b[i+1]=y;
                    }
                    else
                    {
                        b[i]=x;
                        b[i+1]=-y;
                    }
                }
                for(int i=0;i<n;i++)
                {
                    out.print(b[i]+"" "");
                }
                out.println();
            }
            else
            {
                for(int i=0;i<n-3;i+=2)
                {
                    int v1=Math.abs(a[i]),v2=Math.abs(a[i+1]);
                    int l=lcm(v1,v2);
                    int x=l/v1,y=l/v2;
                    if((a[i]>=0 && a[i+1]<0) || (a[i]<0 && a[i+1]>=0))
                    {
                        b[i]=x;
                        b[i+1]=y;
                    }
                    else
                    {
                        b[i]=x;
                        b[i+1]=-y;
                    }
                }
                int l1=lcm(Math.abs(a[n-3]),Math.abs(a[n-2]));
                int x=l1/Math.abs(a[n-3]),y=l1/Math.abs(a[n-2]);
                int l2=lcm(Math.abs(a[n-3]),Math.abs(a[n-1]));
                int z=l2/Math.abs(a[n-3]);
                if((a[n-3]>=0 && a[n-2]<0) || (a[n-3]<0 && a[n-2]>=0))
                {

                }
                else
                {
                    y=-y;
                }
                x+=z;
                int sum=a[n-3]*x+a[n-2]*y;
                sum=-sum;
                z=sum/a[n-1];
                b[n-3]=x;
                b[n-2]=y;
                b[n-1]=z;
                for(int i=0;i<n;i++)
                {
                    out.print(b[i]+"" "");
                }
                out.println();
            }
        }
        out.close();
    }
    public static int gcd(int a, int b)
    {
        if(a==0)
        {
            return b;
        }
        else
        {
            return gcd(b%a,a);
        }
    }
    public static int lcm(int a, int b)
    {
        return (a/gcd(a,b))*b;
    }
    
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
            }
            int b[]=new int[n];
            if(n%2==0)
            {
                for(int i=0;i<n;i+=2)
                {
                    int v1=Math.abs(a[i]),v2=Math.abs(a[i+1]);
                    int l=lcm(v1,v2);
                    int x=l/v1,y=l/v2;
                    if((a[i]>=0 && a[i+1]<0) || (a[i]<0 && a[i+1]>=0))
                    {
                        b[i]=x;
                        b[i+1]=y;
                    }
                    else
                    {
                        b[i]=x;
                        b[i+1]=-y;
                    }
                }
                for(int i=0;i<n;i++)
                {
                    out.print(b[i]+"" "");
                }
                out.println();
            }
            else
            {
                for(int i=0;i<n-3;i+=2)
                {
                    int v1=Math.abs(a[i]),v2=Math.abs(a[i+1]);
                    int l=lcm(v1,v2);
                    int x=l/v1,y=l/v2;
                    if((a[i]>=0 && a[i+1]<0) || (a[i]<0 && a[i+1]>=0))
                    {
                        b[i]=x;
                        b[i+1]=y;
                    }
                    else
                    {
                        b[i]=x;
                        b[i+1]=-y;
                    }
                }
                int l1=lcm(Math.abs(a[n-3]),Math.abs(a[n-2]));
                int x=l1/Math.abs(a[n-3]),y=l1/Math.abs(a[n-2]);
                int l2=lcm(Math.abs(a[n-3]),Math.abs(a[n-1]));
                int z=l2/Math.abs(a[n-3]);
                if((a[n-3]>=0 && a[n-2]<0) || (a[n-3]<0 && a[n-2]>=0))
                {

                }
                else
                {
                    y=-y;
                }
                x+=z;
                int sum=a[n-3]*x+a[n-2]*y;
                sum=-sum;
                z=sum/a[n-1];
                b[n-3]=x;
                b[n-2]=y;
                b[n-1]=z;
                for(int i=0;i<n;i++)
                {
                    out.print(b[i]+"" "");
                }
                out.println();
            }
        }
        out.close();
    }
    public static int gcd(int a, int b)
    {
        if(a==0)
        {
            return b;
        }
        else
        {
            return gcd(b%a,a);
        }
    }
    public static int lcm(int a, int b)
    {
        return (a/gcd(a,b))*b;
    }
    
}
",1,Plagiarised
7c11511f,ca8f11a4,"import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws Exception {
        int tc = io.nextInt();
        for (int i = 0; i < tc; i++) {
            solve();
        }
        io.close();
    }

    private static void solve() throws Exception {
        int n = io.nextInt();
        String a = io.next();
        String b = io.next();
        int zz = 0;
        int zo = 0;
        int oo = 0;
        int oz = 0;
        for (int i = 0; i < a.length(); i++) {
            if (a.charAt(i) == '1' && b.charAt(i) == '0') {
                oz++;
            }
            if (a.charAt(i) == '0' && b.charAt(i) == '0') {
                zz++;
            }
            if (a.charAt(i) == '1' && b.charAt(i) == '1') {
                oo++;
            }
            if (a.charAt(i) == '0' && b.charAt(i) == '1') {
                zo++;
            }
        }
        int ans = Integer.MAX_VALUE;
        if (oz == zo) {
            ans = Math.min(ans, oz + zo);
        }
        if (oo - 1 == zz) {
            ans = Math.min(ans, oo + zz);
        }
        if (ans == Integer.MAX_VALUE) {
            ans = -1;
        }
        io.println(ans);
    }

    

    //-----------PrintWriter for faster output---------------------------------
    public static FastIO io = new FastIO();

    //-----------MyScanner class for faster input----------
    
    //--------------------------------------------------------
}
","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 void solve(int t) throws IOException {
    	int n=sc.nextInt();
    	String a=sc.next();
    	String b=sc.next();
    	
    	int _00=0;
    	int _01=0;
    	int _10=0;
    	int _11=0;
    	
    	for(int i=0;i<n;i++) {
    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
    	}
    	
    	int ans=Integer.MAX_VALUE;
    	
    	
    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
    	if(_01==_10) {
    		ans=Math.min(ans, _10*2);
    	}
    	// By performing one operation, we get _01==_10 and then even operations can be done.
    	// Possible when _11=_00 and one additional _11 for odd operation
    	if(_00+1==_11) {
    		ans=Math.min(ans, (_11-1)*2+1);
    	}
    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
    	else sb.append(ans).append('\n');
    }
    
	public static void main(String[] args) throws IOException {
		sb = new StringBuilder("""");
		sc = new FastScanner();
		int t=sc.nextInt();
		for(int i=1;i<=t;i++){
			solve(i);
		}
		System.out.println(sb);
	}
	
	
}
",1,Plagiarised
c4ca2ff3,d83f74f7,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		while(t-->0) {
		    int n=sc.nextInt();
		    int freq[][]=new int[n][5];
		    int rem[][]=new int[n][5];
		    for(int i=0;i<n;i++) {
		        String str=sc.next();
		        
		        for(int j=0;j<str.length();j++) {
		            freq[i][str.charAt(j)-'a']++;
		        }
		        for(int k=0;k<5;k++) {
		            rem[i][k]=str.length()-freq[i][k];
		        }
		    }
		    
		    int ans=0;
		    for(int i=0;i<5;i++) {
		        int arr[]=new int[n];
		        for(int j=0;j<n;j++)
		        arr[j]=freq[j][i]-rem[j][i];
		        
		        Arrays.sort(arr);
		        int total=0;
		        int sum=0;
		        for(int k=n-1;k>=0;k--) {
		            if(sum+arr[k]>0) {
		                sum=sum+arr[k];
		                total++;
		            }
		            else {
		                break;
		            }
		        }
		        ans=Math.max(ans,total);
		    }
		    out.println(ans);
		    
		}
		out.flush();
		out.close();
	}
}
","import java.util.*;

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


public class A		
{ 
			 static FastReader sc=new FastReader(); 
			 static long ans;
			 static HashMap<Integer,Integer> map;
			
				
		     public static void main(String[] args)
		    {
		    	//CHECK FOR N=1
		        	//CHECK FOR N=1
			  PrintWriter out=new PrintWriter(System.out);
			  StringBuffer sb=new StringBuffer("""");
			 
		  int ttt=1;
		     ttt =i();
		   
		    outer :while (ttt-- > 0) 
			{	
		    	int n=i();
		    	String A[]=inputS(n);
		    	Pair P[]=new Pair[n];
		    	int B[][]=new int[n][5];
		    	for(int i=0;i<n;i++) {
		    		for(int j=0;j<A[i].length();j++) {
		    			B[i][A[i].charAt(j)-'a']++;
		    		}
		    	}
		    	int ans=Integer.MAX_VALUE;
		    	for(int k=0;k<5;k++) {
		    		int s1=0;
		    		int s2=0;
		    	for(int i=0;i<n;i++) {
		    		int a=B[i][k];
		    		int b=A[i].length()-a;
		    		s1+=a;
		    		s2+=b;
		    		P[i]=new Pair(a, b);
		    	}
		    	Arrays.sort(P);
		    	int res=go(P,s1,s2);
		    	ans=Math.min(ans,res);
		    	
		    	}
		    	System.out.println(n-ans);
		    	
		    			
		    	
		    	
			}
		   out.close();
		  // System.out.println(sb.toString());
		   
		   
		   //CHECK FOR N=1                    //CHECK FOR M=0
		    //CHECK FOR N=1                    //CHECK FOR M=0
		   
    }
		 static int go(Pair P[],int a,int b) {
			 int i=0;
			 int ans=0;
			 while(a<=b&& i<P.length) {
				 a-=P[i].x;
				 b-=P[i].y;
				 ans++;
				 i++;
			 }
			 return ans;
		 }


static class Pair implements Comparable<Pair>
     {
    	 int x;
    	 int y;
    	 Pair(int x,int y){
    		 this.x=x;
    		 this.y=y;
    		 
    	 }
		
		
		/* FOR TREE MAP PAIR USE */
		
//		public int compareTo(Pair o) {
// 			if (x > o.x) {
// 				return 1;
// 			}
// 			if (x < o.x) {
// 				return -1;
// 			}
// 			if (y > o.y) {
// 				return 1;
// 			}
// 			if (y < o.y) {
// 				return -1;
// 			}
// 			return 0;
// 		}
//		public int hashCode() 
//		{ 
//			final int temp = 14; 
//			int ans = 1; 
//			ans =x*31+y*13; 
//			return ans; 
//		} 
//  
//		// Equal objects must produce the same 
//		// hash code as long as they are equal 
//		@Override
//		public boolean equals(Object o) 
//		{ 
//			if (this == o) { 
//				return true; 
//			} 
//			if (o == null) { 
//				return false; 
//			} 
//			if (this.getClass() != o.getClass()) { 
//				return false; 
//			} 
//			Pair other = (Pair)o; 
//			if (this.x != other.x || this.y!=other.y) { 
//				return false; 
//			} 
//			return true; 
//		} 	
		
     }
//FRENWICK TREE



//END






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 i() {
    	 return sc.nextInt();
     }
     
  
      
      
      
      
     
        
     
}
",0,Non-plagiarised
1a400c1b,b505f95e,"import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.Math.*;

public class cp{
    static BufferedReader br;
    static StringTokenizer st;

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

        br = new BufferedReader(new InputStreamReader(System.in));
        List<int[]> answer = new ArrayList<int[]>();

        for(int t=Integer.parseInt(br.readLine()); t>0; t--){

            st = readLine();
            st = readLine();
            int n = tokenInt();
            int k = tokenInt();

            st = readLine();
            int[] posArr = readIntArray(k);
            st = readLine();
            int[] tempArr = readIntArray(k);

            answer.add(new Solver().solve(n, k, posArr, tempArr));

        }

        ListIterator<int[]> it = answer.listIterator();
        while (it.hasNext())
            printArr(it.next());

    }

    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
    
    
    
    static int[] readIntArray(int n) {
        int[] a=new int[n];
        for (int i=0; i<n; i++) a[i]=tokenInt();
        return a;
    }

    
    

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

}


class Solver{
    public int[] solve(int n, int k, int[] posArr, int[] tempArr) throws IOException{

        // System.out.println(n);
        // System.out.println(k);
        int[] answer = new int[n];
        for(int i=0; i<n; i++)
            answer[i] = Integer.MAX_VALUE / 2;
        for(int i=0; i<k; i++)
            answer[posArr[i]-1] = tempArr[i];

        for (int i=1; i<n; i++)
            answer[i] = min(answer[i-1]+1, answer[i]);

        for (int j=n-2; j>=0; j--)
            answer[j] = min(answer[j+1]+1, answer[j]);

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

public class E {
    public static void main(String[] args) throws IOException {
        setIO();

        int INF = 2000000000;

        int Q = ni();
        while (Q-- > 0) {
        	rl();
        	st = nl();
        	int N = ni(st), K = ni(st);
        	int[] P = nia(K);
        	int[] T = nia(K);
        	int[] A = new int[N];
        	Arrays.fill(A, INF);
        	for (int i = 0; i < K; i++) {
        		A[P[i]-1] = T[i];
			}

        	int[] R = new int[N];
        	R[N-1] = A[N-1];
        	for (int i = N-2; i >= 0; i--) {
				R[i] = Math.min(R[i+1] + 1, A[i]);
			}

        	int[] L = new int[N];
        	L[0] = A[0];
        	for (int i = 1; i < N; i++) {
        		L[i] = Math.min(L[i-1] + 1, A[i]);
			}

        	for (int i = 0; i < N; i++) {
        		out.print(Math.min(L[i], R[i]) + "" "");
			}
        	out.println();
		}

        f.close();
        out.close();
    }

    static BufferedReader f;
    static PrintWriter out;
    static StringTokenizer st;

    static String rl() throws IOException {
        return f.readLine();
    }

    static int ni(StringTokenizer st) {
        return Integer.parseInt(st.nextToken());
    }

    

    static int ni() throws IOException {
        return Integer.parseInt(rl());
    }

    

    static StringTokenizer nl() throws IOException {
        return new StringTokenizer(rl());
    }

    static int[] nia(int N) throws IOException {
        StringTokenizer st = nl();
        int[] A = new int[N];
        for (int i = 0; i < N; i++)
            A[i] = ni(st);
        return A;
    }


    static void setIn() {
        f = new BufferedReader(new InputStreamReader(System.in));
    }

    static void setOut() {
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    }


    

    static void setIO() {
        setIn();
        setOut();
    }
}
",0,Non-plagiarised
b2590225,f7fc2e94,"import java.util.*;

public class P3 {
    public static class tower implements Comparable<tower>{
        ArrayList<Integer> index;
        int size;
        tower(){
            size = 0;
            index = new ArrayList<>();
        }
        
    }

    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.*;
public class codefor 
{
	static class height implements Comparable<height>
	{
		int h,index;
		height(int hi,int i)
		{
			h=hi;
			index=i;
		}
		
		
	}
	 
	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
0017d438,9852706b,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class A {
    static List<Integer> [] adj;
    static ArrayList<Integer> temp;
    static int mod = (int) 1e9+7;
    static boolean[] vis = new boolean[(int)1e5];
    static List<Integer> l = new ArrayList<>();
    static final Reader s = new Reader();

    public static void main(String[] args) throws IOException {
        int t = s.nextInt();
//        int t=1;
       while(t-->0) {
           int n = s.nextInt();
           int m = s.nextInt();
           int d = s.nextInt();
           System.out.println(""YES"");
           PriorityQueue<Pair> pq = new PriorityQueue<>();
            for(int i=1;i<=m;i++){
               pq.add(new Pair(i));
            }
            for(int i=0;i<n;i++){
                int v = s.nextInt();
                Pair p = pq.poll();
                p.sum+=v;
                pq.add(p);
                System.out.print(p.id+"" "");
            }
           System.out.println();
       }
    }
    static class Pair implements Comparable<Pair> {
        int id;
        long sum=0;
        public Pair(int id) {
            this.id=id;
        }
        
    }
    //Important
    //Dont't stick on same approach
    //Check long
    

    

    

    

    

    

    

}
","import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
    static int modulo=998244353;
    public static void main(String[] args) {
       
        FastScanner in = new FastScanner();
        int test=in.nextInt();
        while(test-->0){
            int n=in.nextInt();
            int m=in.nextInt();
            int x=in.nextInt();
             PriorityQueue<pair> pq=new PriorityQueue<>();
            int arr[]=new int[n];
            for(int i=1;i<=m;i++){
                pq.add(new pair(i,0));
            }
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                pair p=pq.poll();
                int a=in.nextInt();
                p.y+=a;
                pq.add(p);
                System.out.print(p.x+"" "");
            }
            
            
            
            System.out.println();
        }
        
        
       
        
        
//        int sum=in.nextInt();
//        
//        boolean dp[][]=new boolean[n+1][sum+1];
//        
//        for(int i=0;i<=n;i++){
//            for(int j=0;j<=sum;j++){
//                if(i==0)
//                    dp[i][j]=false;
//                if(j==0)
//                    dp[i][j]=true;
//                    
//            }
//        }
//        
//        for(int i=1;i<=n;i++){
//            for(int j=1;j<=sum;j++){
//                if(arr[i-1]<=j)
//                    dp[i][j]=(dp[i-1][j])||(dp[i-1][j-arr[i-1]]);
//                else
//                    dp[i][j]=dp[i-1][j];
//                
//            }
//        }
//         boolean flag=false;
//        for(int i=0;i<=n;i++){
//            if(dp[i][sum]==true){
//                flag=true;
//                System.out.println(1);
//                break;
//            }
//            
//        }
//        if(!flag)
//            System.out.println(0);
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
}

class pair implements Comparable<pair>
	    {
	        int x;
	        int y;
 
	        pair(int x, int y) {
	            this.x = x;
	            this.y = y;
	        }
	        
}
",1,Plagiarised
48c5f745,4d25818e,"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();
	}
	
	

}
","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 k= sc.nextInt();
			int ac[] = new int[k];
			int temp[] = new int[k];
			int ans[] = new int[n+1];
			for(int i=0;i<k;i++)
				ac[i] = sc.nextInt();
			for(int i=0;i<k;i++)
				temp[i] = sc.nextInt();
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++)
				ans[ac[i]] = temp[i];

			for(int i=2;i<n+1;i++)
				ans[i]=Math.min(ans[i],ans[i-1]==Integer.MAX_VALUE ? ans[i-1] : ans[i-1]+1);

			for(int i=n-1;i>0;i--)
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			
			for(int i=1;i<n+1;i++)
				System.out.print(ans[i]+"" "");
		
			System.out.println("" "");
		}	
    }
}
",1,Plagiarised
4.4428E+067,c850e422,"import java.util.*;
import java.io.*;

public class C_Minimum_Grid_Path{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
       int n=s.nextInt();
       int array[]= new int[n];
       long sumodd[]= new long[n];
       long sumeven []= new long[n];
       long minodd[]= new long[n];
       long mineven[]= new long[n];
       long sume=0;
       long sumo=0;
       for(int i=0;i<n;i++){
           array[i]=s.nextInt();
           if(i%2==0){
               sume+=array[i];
               sumeven[i]=sume;
               if(i==0){
                   mineven[i]=array[i];
               }
               else{
                   mineven[i]=Math.min(array[i],mineven[i-2]);
               }
           }
           else{
               sumo+=array[i];
               sumodd[i]=sumo;
               if(i==1){
                minodd[i]=array[i];
            }
            else{
                minodd[i]=Math.min(array[i],minodd[i-2]);
            }
           }
       }
       long ans=Long.MAX_VALUE;
       for(int i=1;i<n;i++){
           long temp=0;
           if(i%2==0){
               int num=i/2;
              temp=(mineven[i]*(n-num))+(sumeven[i]-mineven[i])+(minodd[i-1]*(n-(num-1)))+(sumodd[i-1]-minodd[i-1]);
              ans=Math.min(ans,temp);
           }
           else{
               int num=i/2;
               temp=(minodd[i]*(n-num))+(sumodd[i]-minodd[i])+(mineven[i-1]*(n-num))+(sumeven[i-1]-mineven[i-1]);
               ans=Math.min(ans,temp);
           }
       }
       res.append(ans+""\n"");
       p++;
    }
    System.out.println(res);



    }
    




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

public class Code {

  public static void main(String[] args) {
    FastReader in = new FastReader();
    PrintWriter out = new PrintWriter(System.out);

    int t = in.nextInt();
    while (t-- > 0) {
      int n = in.nextInt();
      long a[] = new long[n];
      for (int i = 0; i < n; i++) {
        a[i] = in.nextLong();
      }
      long result = Long.MAX_VALUE;
      for (int i = 0; i < 2; i++) {
        long x = 0;
        long y = 0;
        long minX = Long.MAX_VALUE;
        long minY = Long.MAX_VALUE;
        long prefix = 0;
        for (int j = 0; j < n; j++) {
          if (j % 2 == i) {
            if (j > 0) {
              result = Math.min(result, (n - x) * a[j] + (n - y) * minY + prefix);
            }
            ++x;
            prefix += a[j];
            minX = Math.min(minX, a[j]);
          } else {
            if (j > 0) {
              result = Math.min(result, (n - y) * a[j] + (n - x) * minX + prefix);
            }
            ++y;
            prefix += a[j];
            minY = Math.min(minY, a[j]);
          }
        }
      }
      out.println(result);
    }

    out.close();
  }

  

  

  

  
}
",0,Non-plagiarised
3e93b259,a60fba84,"import java.util.*;
import java.io.*;
public class Main
{
    
    
    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.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	static PrintWriter out;
	static FastReader scan;

    /*-------- I/O using short named function ---------*/
	
	public static int ni(){return scan.nextInt();}
	public static long nl(){return scan.nextLong();}
	
	
	
	
    /*-------- for output of an array ---------------------*/
     
	
	
	
    /*-------------- for input in an array ---------------------*/
	
	static void lIA(long arr[]){
	     for(int i=0; i<arr.length; i++)arr[i] = nl(); 
	}
	
	
	/*------------ for taking input faster ----------------*/
     

	// Method to check if x is power of 2
    
    //Method to return lcm of two numbers
    
    //Method to count digit of a number
    

    //Method for sorting
	
	//Method for checking if a number is prime or not
	 

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

			}
			System.out.println(ans);
        }
        out.flush();
		out.close();
	}
	
}
",1,Plagiarised
68cdd55d,c18048bf,"import java.io.*;
import java.util.*;

public class Main {
    static PrintWriter out;
    static FastReader sc;

    public static void main(String[] args) throws FileNotFoundException {
        boolean t = true;
        boolean f = false;
        if (f) {
            out = new PrintWriter(""output.txt"");
            sc = new FastReader(""input.txt"");
        } else {
            out = new PrintWriter((System.out));
            sc = new FastReader();
        }

        int tt = 1;
        tt = sc.nextInt();
        while (tt-- > 0) {
            solve();
        }
        out.flush();
        out.close();
    }
 
    static boolean flag = false;
    static List<int[]>[] ans;
    public static void dfs(int index, boolean[] visited, int parent, int val, List<Integer>[] ll){
        if(visited[index]){
            return;
        }

        List<Integer> l1 = ll[index];
        // out.println("" == "" + l1 + "" "" + index);
        if(l1.size() > 2){
            flag = true;
            return;
        }

        visited[index] = true;

        for(int k: l1){
            if(visited[k] == false){
                // out.println(visited[k] + "" "" + index + "" "" + k + "" "" + val);
                ans[index].add(new int[]{k, val});
                ans[k].add(new int[]{index, val});
                dfs(k, visited, index, (val == 2) ? 5 : 2, ll);
            }
        }
    }
    public static void solve() {
        int n = sc.nextInt();
        List<Integer>[] ll = new List[n + 1];

        // out.println("" mm "" + n);
        for (int i = 0; i <= n; i++) {
            ll[i] = new ArrayList<>();  
        }
        int[][] store = new int[n][2];
        for (int i = 0; i < n - 1; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            store[i][0] = u;
            store[i][1] = v;
            // out.println("" === "" + u + "" "" + v);
            int mm = Math.min(u, v);
            int mx = Math.max(u, v);
            // out.println("" u "" + v + "" "" + u);
            ll[mm].add(mx);
            ll[mx].add(mm);
            // ll[v].add(u)
        }

        int two = 2;
        int prime = 5;
        flag = false;
        ans = new List[n+1];
        
        int[] arr = new int[n + 1];


        for(int i = 0; i <= n; i++){
            ans[i] = new ArrayList<>();
        }
    
        boolean[] visited = new boolean[n+1];
        List<Integer> one = ll[1];
        if(one.size() > 2){
            out.println(-1);
            return;
        }

        // out.println("" -- "" + one);
        visited[1] = true;
        for(int i = 0; i < one.size(); i++){
            if(i == 0){
                ans[1].add(new int[]{one.get(i), 2});
                ans[one.get(i)].add(new int[]{1, 2});
                dfs(one.get(i), visited, -1, 5, ll);
            }else{
                ans[1].add(new int[]{one.get(i), 5});
                ans[one.get(i)].add(new int[]{1, 5});
                dfs(one.get(i), visited, -1, 2, ll);
            }
        }
        if (flag) {
            out.println(-1);
            return;
        }

       for(int i = 0; i < n-1; i++){
        //    out.println("" -- "");
         int u = store[i][0];
         int v = store[i][1];

        //  out.println("" uu "" + u + "" "" + v);
         if(u == 0 || v == 0){
             continue;
         }
         int mm = Math.min(u, v);
         int mx = Math.max(u, v);
         List<int[]> vv = ans[mm];
        //  for(int[] ii:vv){
        //      out.println(Arrays.toString(ii));
        //  }
         if(vv == null){
             continue;
         }
         for(int[] j: vv){
             if(j[0] == mx){
                 out.print(j[1]+ "" "");
                 break;
             }
         }
       }
        out.println();
    }

    

    

    

    

    

}
","import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{ 
//    static int mod = 998244353 ;
//    static int N = 200005;
//    static long factorial_num_inv[] = new long[N+1];
//    static long natual_num_inv[] = new long[N+1];
//    static long fact[] = new long[N+1];
//    static void InverseofNumber() 
//{ 
//    natual_num_inv[0] = 1;
//    natual_num_inv[1] = 1; 
//    for (int i = 2; i <= N; i++) 
//        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
//} 
//static void InverseofFactorial() 
//{ 
//    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
  
//    for (int i = 2; i <= N; i++) 
//        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
//} 
//static long nCrModP(long N, long R) 
//{ 
//    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
//    return ans%mod; 
//}
    //static boolean prime[];
    //static void sieveOfEratosthenes(int n)
    //{
    //    prime = new boolean[n+1];
        
    //    for (int i = 0; i <= n; i++)
    //        prime[i] = true;
 
    //    for (int p = 2; p * p <= n; p++)
    //    {
    //        // If prime[p] is not changed, then it is a
    //        // prime
    //        if (prime[p] == true)
    //        {
    //            // Update all multiples of p
    //            for (int i = p * p; i <= n; i += p)
    //                prime[i] = false;
    //        }
    //    }
 
        
    //}
    static int visited[];
    static HashMap<Pair,Integer> hm;
	public static void main (String[] args) throws java.lang.Exception
	{
    //    InverseofNumber();
    //    InverseofFactorial();
    //   fact[0] = 1; 
    //   for (long i = 1; i <= 2*100000; i++)
    //   { 
    //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
    //   }
    
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int t = scan.nextInt();
        while(t-->0){
            int n =  scan.nextInt();
            List<List<Integer>> a = new ArrayList<List<Integer>>();
            for(int i=0;i<=n;i++){
                a.add(new ArrayList<Integer>());
            }
            Pair edge[] = new Pair[n-1];
            for(int i=0;i<n-1;i++){
                int x = scan.nextInt();
                int y = scan.nextInt();
                edge[i] = new Pair(x,y);
                a.get(x).add(y);
                a.get(y).add(x);
            }
            int flag=0;
            int start = -1;
            for(int i=1;i<=n;i++){
                if(a.get(i).size()>2)
                flag = 1;
                if(a.get(i).size()==1)
                start = i;
            }
            if(flag==1)
            pw.println(-1);
            else{
                visited = new int[n+1];
                 hm = new HashMap<Pair,Integer>();
                dfs(a,start,2);
                for(int i=0;i<n-1;i++){
                    int x = edge[i].x;
                    int y = edge[i].y;
                   pw.print(hm.get(new Pair(x,y))+"" "");
                }
                pw.println();
            }
            pw.flush();
        }
           
             
    }
    static void dfs(List<List<Integer>> a,int start,int parent){
        if(visited[start]==0){
            visited[start] = 1;
        List<Integer> temp = a.get(start);
        int len = temp.size();
        for(int i=0;i<len;i++){
            int end = temp.get(i);
            if(parent==2){
             hm.put(new Pair(start,end),3);
             hm.put(new Pair(end,start),3);
            dfs(a,end,3);
        }
            else{
            hm.put(new Pair(start,end),2);
            hm.put(new Pair(end,start),2);
            dfs(a,end,2);
            }
        }
    }
    }
     
        //static long bin_exp_mod(long a,long n){
            
        //    long res = 1;
            
        //    if(a==0)
        //    return 0;
        //    while(n!=0){
        //        if(n%2==1){
        //            res = ((res)*(a));
        //        }
        //           n = n/2;
        //            a = ((a)*(a));
        //    }
           
        //    return res;
        //}
    //static long bin_exp_mod(long a,long n){
	//    long mod = 1000000007;
	//    long res = 1;
	//    a = a%mod;
	//    if(a==0)
	//    return 0;
	//    while(n!=0){
	//        if(n%2==1){
	//            res = ((res%mod)*(a%mod))%mod;
	//        }
	//           n = n/2;
	//            a = ((a%mod)*(a%mod))%mod;
	//    }
	//    res = res%mod;
	//    return res;
	//}
//   static long gcd(long a,long b){
//       if(a==0)
//       return b;
//       return gcd(b%a,a);
//   }
//   static long lcm(long a,long b){
//       return (a/gcd(a,b))*b;
//   }
}
class Pair{
    Integer x,y;
    Pair(int x,int y){
        this.x = x;
        this.y = y;
    }

    

    
}
",0,Non-plagiarised
115c99cb,548ffb07,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	
	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;
		}
		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;
	}
	
	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;
		}
		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
6946f466,ce7027ee,"import java.util.*;

public class A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int testCases = sc.nextInt();

        for (int t = 0; t < testCases; t++) {
            int n = sc.nextInt();
            int m = sc.nextInt();

            char c[][] = new char[n][m];

            for (int i = 0; i < n; i++) {
                String str = sc.next();
                c[i] = str.toCharArray();
            }

            int count = 0;
            StringBuilder ans = new StringBuilder();

            for (int i = 0; i < m - 2; i++) {
                for (int j = 0; j < n; j++) {

                    if (c[j][i] == '0') {
                        continue;
                    }
                    count++;

                    if (j == n - 1) {

                        c[j][i] = '0';
                        c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
                        c[j - 1][i + 1] = (c[j - 1][i + 1] == '0' ? '1' : '0');

                        ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j) + "" "" + (i + 2))
                                .append(""\n"");
                        continue;
                    }

                    c[j][i] = '0';
                    c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
                    c[j + 1][i + 1] = (c[j + 1][i + 1] == '0' ? '1' : '0');

                    ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2) + "" "" + (i + 2))
                            .append(""\n"");

                }
            }

            for (int i = 0; i < n - 2; i++) {
                for (int j = m - 2; j < m; j++) {
                    if (c[i][j] == '0') {
                        continue;
                    }
                    count++;

                    if (j == m - 1) {
                        c[i][j] = '0';
                        c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
                        c[i + 1][j - 1] = (c[i + 1][j - 1] == '0' ? '1' : '0');

                        ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j))
                                .append(""\n"");

                        continue;
                    }

                    c[i][j] = '0';
                    c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
                    c[i + 1][j + 1] = (c[i + 1][j + 1] == '0' ? '1' : '0');

                    ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2))
                            .append(""\n"");
                }
            }

            ArrayList<String> al = new ArrayList<>();

            int count_one = 0;

            for (int i = n - 2; i < n; i++) {
                for (int j = m - 2; j < m; j++) {

                    if (c[i][j] == '0') {
                        al.add((i + 1) + "" "" + (j + 1));
                    } else {
                        count_one++;
                        al.add(0, (i + 1) + "" "" + (j + 1));
                    }

                }
            }

            if (count_one == 0) {
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }

            if (count_one == 1) {
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");

                count = count + 3;

                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }

            if (count_one == 2) {
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");

                count = count + 2;
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }

            if (count_one == 3) {
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");

                count = count + 1;
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }

            if (count_one == 4) {
                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");

                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");

                count = count + 4;

                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;

            }

        }

        System.out.print(sb);
    }
}
","import java.util.*;
 
public class A {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int testCases = sc.nextInt();
 
        for (int t = 0; t < testCases; t++) {
            int n = sc.nextInt();
            int m = sc.nextInt();
 
            char c[][] = new char[n][m];
 
            for (int i = 0; i < n; i++) {
                String str = sc.next();
                c[i] = str.toCharArray();
            }
 
            int count = 0;
            StringBuilder ans = new StringBuilder();
 
            for (int i = 0; i < m - 2; i++) {
                for (int j = 0; j < n; j++) {
 
                    if (c[j][i] == '0') {
                        continue;
                    }
                    count++;
 
                    if (j == n - 1) {
 
                        c[j][i] = '0';
                        c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
                        c[j - 1][i + 1] = (c[j - 1][i + 1] == '0' ? '1' : '0');
 
                        ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j) + "" "" + (i + 2))
                                .append(""\n"");
                        continue;
                    }
 
                    c[j][i] = '0';
                    c[j][i + 1] = (c[j][i + 1] == '0' ? '1' : '0');
                    c[j + 1][i + 1] = (c[j + 1][i + 1] == '0' ? '1' : '0');
 
                    ans.append((j + 1) + "" "" + (i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2) + "" "" + (i + 2))
                            .append(""\n"");
 
                }
            }
 
            for (int i = 0; i < n - 2; i++) {
                for (int j = m - 2; j < m; j++) {
                    if (c[i][j] == '0') {
                        continue;
                    }
                    count++;
 
                    if (j == m - 1) {
                        c[i][j] = '0';
                        c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
                        c[i + 1][j - 1] = (c[i + 1][j - 1] == '0' ? '1' : '0');
 
                        ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j))
                                .append(""\n"");
 
                        continue;
                    }
 
                    c[i][j] = '0';
                    c[i + 1][j] = (c[i + 1][j] == '0' ? '1' : '0');
                    c[i + 1][j + 1] = (c[i + 1][j + 1] == '0' ? '1' : '0');
 
                    ans.append((i + 1) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 1) + "" "" + (i + 2) + "" "" + (j + 2))
                            .append(""\n"");
                }
            }
 
            ArrayList<String> al = new ArrayList<>();
 
            int count_one = 0;
 
            for (int i = n - 2; i < n; i++) {
                for (int j = m - 2; j < m; j++) {
 
                    if (c[i][j] == '0') {
                        al.add((i + 1) + "" "" + (j + 1));
                    } else {
                        count_one++;
                        al.add(0, (i + 1) + "" "" + (j + 1));
                    }
 
                }
            }
 
            if (count_one == 0) {
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }
 
            if (count_one == 1) {
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
 
                count = count + 3;
 
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }
 
            if (count_one == 2) {
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
 
                count = count + 2;
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }
 
            if (count_one == 3) {
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
 
                count = count + 1;
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
            }
 
            if (count_one == 4) {
                ans.append(al.get(1) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
 
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(2)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(2) + "" "" + al.get(3)).append(""\n"");
                ans.append(al.get(0) + "" "" + al.get(1) + "" "" + al.get(3)).append(""\n"");
 
                count = count + 4;
 
                sb.append(count).append(""\n"");
                sb.append(ans).append(""\n"");
                continue;
 
            }
 
        }
 
        System.out.print(sb);
    }
//
}
",1,Plagiarised
3cf63146,bdfe8110,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.time.LocalDateTime;
import java.util.*;

public class B {
	static int tree[];
	static int up[];
	static int n;
	static int mod =1000000007; 
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
	    FastScanner fs=new FastScanner();
	    int t=fs.nextInt();
	   outer: while(t-->0) {
		    n=fs.nextInt();
		    int k=fs.nextInt();
		   int ac[]=fs.readArray(k);
		   int temp[]=fs.readArray(k);
		   int arr[]=new int[n];
		   Arrays.fill(arr, Integer.MAX_VALUE/2);
		   for(int i=0;i<k;i++) {
			   int ind = ac[i]-1;
			   arr[ind]=temp[i];
		   }
		   int ans[]=new int[n];
		   int left[]=new int[n];
		   Arrays.fill(left, Integer.MAX_VALUE/2);
//		   int right[]=new int[n];
		   left[0]=arr[0];
//		   Arrays.fill(right, Integer.MAX_VALUE/2);
		   
//		   right[n-1]=arr[n-1];
		   for(int i=1;i<n;i++) {
			   left[i]=Math.min(arr[i], left[i-1]+1);
		   }
		   ans[n-1]=Math.min(left[n-1],arr[n-1]);
		   for(int i=n-2;i>=0;i--) {
			   ans[i]=Math.min(Math.min(arr[i],left[i]),ans[i+1]+1);
		   }
//		   for(int i=0;i<n;i++) ans[i]=Math.min(left[i], right[i]);
		   for(int i=0;i<n;i++) out.print(ans[i]+"" "");
		   out.println();
	   }
	    out.close();
	}
	
	
	
	
	
	
	
	
	
	// Use this to input code since it is faster than a Scanner
	
 
}
","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();
	}

	
	
	

	
}
",0,Non-plagiarised
8aadde13,fb20d298,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class A {
    public static void main(String args[]) throws Exception {
        FastScanner sc = new FastScanner();
        int T = 1;
        T = sc.nextInt();
        PrintWriter pw = new PrintWriter(System.out);
        while (T-- > 0) {
            solve(sc, pw);
        }
        pw.close();
    }

    public static void solve(FastScanner sc, PrintWriter pw) throws Exception {
        int n = sc.nextInt();
        int[] arr = new int[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        if(check(arr)) pw.println(""YES"");
        else pw.println(""NO"");
    }

    public static boolean check(int[] arr){
        int n=arr.length;
        TreeSet<Integer> S = new TreeSet<>();
        S.add(arr[0]);
        for(int i=1;i<n;i++) {
            S.add(arr[i]);
            if (arr[i] == arr[i - 1]) continue;
            Integer lb = S.lower(arr[i]);
            if (lb != null && lb == arr[i - 1]) continue;
            Integer ub = S.higher(arr[i]);
            if (ub != null && ub == arr[i - 1]) continue;
            return false;
        }
        return true;
    }

    
}
","import java.io.*;
import java.util.*;
public class Main {
	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
//		int t=1;	
		int t=sc.nextInt();
//		outer:	
		while(t-- >0) {
			int n = sc.nextInt();
			int b[] = sc.readArray(n);
			TreeSet<Integer> set = new TreeSet<>();
			boolean f = true;
			set.add(b[0]);
			for(int i=1 ; i<n ; i++) {
				set.add(b[i]);
				if(b[i-1]==b[i]) {
					continue;
				}
				Integer find = set.lower(b[i]);
				if(find!=null && find==b[i-1]) {
					continue;
				}
				find = set.higher(b[i]);
				if(find!=null && find==b[i-1]) {
					continue;
				}
				f = false;
				break;
			}
			if(f == false) {
				out.println(""NO"");
			}
			else out.println(""YES"");
		}
		out.flush();
		out.close();
	}
	
}
",1,Plagiarised
27ec4acc,ddcadc64,"import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.BitSet;
import java.util.function.BinaryOperator;

public class D {
    

    static 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 int ri() {
        return s.nextInt();
    }

    

    


    

    static int MOD=(int)1e9+7;

    

    
    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
        int t = ri();
//        int t=1;
        while(t-- >0)
        {
            int n=ri();
            int[] arr=rai(n);
            int[] res = new int[n];
            if(n%2==0)
            {

                for(int i=0;i<n;i+=2)
                {
                    res[i] = -arr[i+1];
                    res[i+1]=arr[i];
                }


            }
            else {
                for(int i=0;i<n-3;i+=2)
                {
                    res[i] = -arr[i+1];
                    res[i+1]=arr[i];
                }

                int val = arr[n-1]+arr[n-2];
                if(val!=0) {
                    res[n - 3] = -val;
                    res[n - 2] = arr[n - 3];
                    res[n - 1] = arr[n - 3];
                }
                else
                {
                    val = arr[n-1]+arr[n-3];
                    if(val!=0) {
                        res[n - 2] = -val;
                        res[n - 1] = arr[n - 2];
                        res[n - 3] = arr[n - 2];
                    }
                    else
                    {
                        val = arr[n-2]+arr[n-3];
                        res[n-1] = -val;
                        res[n-2]=arr[n-1];
                        res[n-3]=arr[n-1];
                    }
                }

            }

            for(int i:res)
            {
                ans.append(i).append("" "");
            }
            ans.append(""\n"");

//            int sum=0;
//            for(int i=0;i<n;i++)
//            {
//                sum+=arr[i]*res[i];
//            }
//            System.out.println(sum);

        }
        out.print(ans.toString());
        out.flush();
    }
}
","import java.util.Scanner;

public class D {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int t = scn.nextInt();
        StringBuilder sb = new StringBuilder();
        while (t-- > 0) {
            int n = scn.nextInt();
            int[] arr = new int[n];
            int[] ans = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scn.nextInt();
            }
            if (n % 2 != 0) {
                if (arr[n - 2] + arr[n - 3] == 0) {
                    ans[n - 3] = -2 * arr[n - 1];
                    ans[n - 2] = -arr[n - 1];
                    ans[n - 1] = arr[n - 2] + arr[n - 3] * 2;
                } else {
                    ans[n - 3] = -arr[n - 1];
                    ans[n - 2] = -arr[n - 1];
                    ans[n - 1] = arr[n - 2] + arr[n - 3];
                }
                n -= 3;
            }
            for (int i = 0; i < n; i += 2) {
                int div = 1;
                if (arr[i] % 2 == 0 && arr[i + 1] % 2 == 0)
                    div = 2;
                ans[i] = arr[i + 1] / div;
                ans[i + 1] = -arr[i] / div;
            }
            for (int v : ans) {
                sb.append(v);
                sb.append("" "");
            }
            sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
",0,Non-plagiarised
0889dcfb,22138fad,"import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class C{
	
	static class Event implements Comparable<Event>{
		long i;
		int index;
		boolean start; 
		public Event(long a,int c, boolean b) {
			i=a;
			index = c;
			start=b;
		}
		
	}
	
	public static void main(String[] args) throws IOException{
		// br = new BufferedReader(new FileReader("".in""));
		// out = new PrintWriter(new FileWriter("".out""));
		// new Thread(null, new (), ""fisa balls"", 1<<28).start();
		
		int t= readInt();
		while(t-->0) {
			int n =readInt();
			long[] k = new long[n], h = new long[n];
			for (int i = 0; i < n; i++) k[i]=readInt();
			for (int i = 0; i < n; i++) h[i]=readInt();
			List<Event> e = new ArrayList<Event>();
			for (int i = 0 ; i <n; i++) {
				Event e1 = new Event(k[i]-h[i]+1, i, true);
				Event e2 = new Event(k[i], i, false);
				e.add(e1);
				e.add(e2);
			}
			Collections.sort(e);
			long ans = 0;
			long start = Long.MAX_VALUE;
			long end = 0;
			int stackSize = 0;
			for (Event ev: e) {
				if (ev.start) {
					start = min(start, ev.i);
					end = max(end, k[ev.index]);
					stackSize++;
				}
				else {
					end = max(end, ev.i);
					stackSize--;
					if (stackSize == 0) {
						long diff = end-start+1;
					//	System.out.println(""YOYO "" + diff);
						ans += diff*(diff+1)/2;
						
						
						start = Long.MAX_VALUE;
						end = 0;
					}
				}
			}
			out.println(ans);
		}
		
		out.close();
	}
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	static StringTokenizer st = new StringTokenizer("""");
	static String read() throws IOException{
		while (!st.hasMoreElements()) st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	public static int readInt() throws IOException{return Integer.parseInt(read());}
	
}
","import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class MonstersAndSpells {
	
	static long rangeSum(long l, long r) {
		return ((r*(r+1))/2) - ((l*(l-1))/2);
	}
	
	static class Event implements Comparable<Event> {
		
		int time;
		int monsterNum;
		boolean isMonster;
		
		public Event(int time, int monsterNum, boolean isMonster) {
			this.time = time; this.monsterNum = monsterNum; this.isMonster = isMonster;
		}
		
		
		
	}
	
	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		int t = Integer.parseInt(st.nextToken());
		
		for(int test = 0; test < t; test++) {
			
			st = new StringTokenizer(br.readLine());
			
			int n = Integer.parseInt(st.nextToken());
			
			int[] k = new int[n];
			int[] h = new int[n];
			
			st = new StringTokenizer(br.readLine());
			for(int i = 0; i < n; i++)
				k[i] = Integer.parseInt(st.nextToken());
			
			st = new StringTokenizer(br.readLine());
			for(int i = 0; i < n; i++)
				h[i] = Integer.parseInt(st.nextToken());
			
			int[] latestStart = new int[n];
			
			for(int i = 0; i < n; i++) {
				latestStart[i] = k[i] - h[i] + 1;
			}
			
			
			
			PriorityQueue<Event> pq = new PriorityQueue<Event>();
			for(int i = 0; i < n; i++) {
				pq.add(new Event(k[i],i,true));
				pq.add(new Event(latestStart[i],i,false));
			}
			
			long manaUsed = 0;
			int lastEvent = 0;
			
			HashMap<Integer, Event> waiting = new HashMap<Integer, Event>();
			
			long currentSpell = 1;
			
			//pw.println(""NEW GAME"");
			
			while(!pq.isEmpty()) {
				
				Event nextEvent = pq.poll();
				
				if(!waiting.isEmpty() && nextEvent.time > lastEvent) {
					manaUsed += rangeSum(currentSpell+1, currentSpell + nextEvent.time - lastEvent);
					currentSpell = currentSpell + nextEvent.time - lastEvent;
				}
				if(waiting.isEmpty()) {
					currentSpell = 1;
					manaUsed++;
				}
				
				//pw.println(manaUsed + "" "" + currentSpell + "" "" + nextEvent.monsterNum + "" "" + nextEvent.isMonster);
				
				if(nextEvent.isMonster) {
					waiting.remove(nextEvent.monsterNum);
					
				}
				
				if(!nextEvent.isMonster) {
					waiting.put(nextEvent.monsterNum,nextEvent);
				}
				
				lastEvent = nextEvent.time;
					
			}
			
			pw.println(manaUsed);
			
		}
		
		pw.close();
		
	}

}
",0,Non-plagiarised
d5dc6626,f59d9b6e,"import java.util.*;
import java.io.*;

public class Main {
    // For fast input output
    

    // 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();
            int nodes[] = new int[n];
            int edges[][] = new int[n-1][2];
            ArrayList<Pair> graph[] = new ArrayList[n];
            for(int i=0; i<n; i++){
                graph[i] = new ArrayList<>();
            }
            for(int i=0; i<n-1; i++){
                int a = reader.nextInt()-1;
                int b = reader.nextInt()-1;
                graph[a].add(new Pair(b, i));
                graph[b].add(new Pair(a, i));
                nodes[a]++;
                nodes[b]++;
            }
            boolean possible = true;
            for(int i=0; i<n; i++){
                if(nodes[i]>2){
                    possible = false;
                }
            }
            Arrays.fill(nodes, 0);
            int first = 2;
            int second = 5;
            
            if(possible){
                int fill_ans[] = new int[n-1];
                find(0, -1, graph, fill_ans, n, first, second, true);
                for(int i=0; i<n-1; i++){
                    sb.append(fill_ans[i]+"" "");
                }
            }else{
                sb.append(""-1"");
            }
            sb.append(""\n"");
        }
        System.out.println(sb);
    }

    static void find(int node, int par, ArrayList<Pair> graph[], int fill_ans[], int n, int first, int second, boolean first_fill){

        for(Pair p: graph[node]){
            if(p.a==par){
                continue;
            }
            if(first_fill){
                fill_ans[p.b] = first;
            }else{
                fill_ans[p.b] = second;
            }
            find(p.a, node, graph, fill_ans, n, first, second, !first_fill);
            first_fill = !first_fill;
        }

    }

    static class Pair{
        int a, b;
        Pair(int x, int y){
            a = x;
            b = y;
        }
    }
}
","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
04ed33a5,7ea34254,"import java.util.Scanner;

public class Subsequence {
	private static Scanner sc = new Scanner(System.in);
	
	public static void main(String args[]) {
		int t = sc.nextInt();
		
		while(t-->0) {
			int n = sc.nextInt();
			
			int a[] = new int[n];
			int b[] =  new int[n];
			
			for(int i=0;i<n;i++) {
				a[i]= sc.nextInt();
				
			}
			
			if(n%2==0) {
				calculateB(a,b,n);
			}
			else {
				calculateB(a,b,n-3);
				if (a[n - 2] + a[n - 3] != 0) {
					b[n - 3] = -a[n - 1];
					b[n - 2] = -a[n - 1];
					b[n - 1] = a[n - 2] + a[n - 3];
				} else if (a[n - 2] + a[n - 1] != 0) {
					b[n - 3] = a[n - 2] + a[n - 1];
					b[n - 2] = -a[n - 3];
					b[n - 1] = -a[n - 3];
				} else {
					b[n - 3] = -a[n - 2];
					b[n - 2] = a[n - 3] + a[n - 1];
					b[n - 1] = -a[n - 2];
				}
			}
			
			for(int i=0;i<n;i++) {
				System.out.print(b[i] + "" "");
			}
			System.out.println();
		}

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
","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 int mod = 998244353 ;
//    static int N = 200005;
//    static long factorial_num_inv[] = new long[N+1];
//    static long natual_num_inv[] = new long[N+1];
//    static long fact[] = new long[N+1];
//    static void InverseofNumber() 
//{ 
//    natual_num_inv[0] = 1;
//    natual_num_inv[1] = 1; 
//    for (int i = 2; i <= N; i++) 
//        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
//} 
//static void InverseofFactorial() 
//{ 
//    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
  
//    for (int i = 2; i <= N; i++) 
//        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
//} 
//static long nCrModP(long N, long R) 
//{ 
//    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
//    return ans%mod; 
//}
    //static boolean prime[];
    //static void sieveOfEratosthenes(int n)
    //{
    //    prime = new boolean[n+1];
        
    //    for (int i = 0; i <= n; i++)
    //        prime[i] = true;
 
    //    for (int p = 2; p * p <= n; p++)
    //    {
    //        // If prime[p] is not changed, then it is a
    //        // prime
    //        if (prime[p] == true)
    //        {
    //            // Update all multiples of p
    //            for (int i = p * p; i <= n; i += p)
    //                prime[i] = false;
    //        }
    //    }
 
        
    //}
    
	public static void main (String[] args) throws java.lang.Exception
	{
    //    InverseofNumber();
    //    InverseofFactorial();
    //   fact[0] = 1; 
    //   for (long i = 1; i <= 2*100000; i++)
    //   { 
    //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
    //   }
    
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int t = scan.nextInt();
        while(t-->0){
         int n= scan.nextInt();
         long a[] = new long[n];
         for(int i=0;i<n;i++){
             a[i] = scan.nextLong();
         }
         long b[] = new long[n];
         int i=0;
         if(n%2==1){
           if(a[0]+a[1]!=0){
           b[0] = -1*a[2];
           b[1] = -1*a[2];
           b[2] = a[0]+a[1];}
           else if(a[0]+a[2]!=0){
            b[0] = -1*a[1];
            b[2] = -1*a[1];
            b[1] = a[0]+a[2];
           }
           else{
            b[2] = -1*a[0];
            b[1] = -1*a[0];
            b[0] = a[2]+a[1]; 
           }
           i = 3;
         }
         else{
             b[0] = -a[1];
             b[1] = a[0];
             i=2;
         }
         while(i<n-1){
             b[i] = -a[i+1];
             b[i+1] = a[i];
             i = i+2;
         }
         for(int j=0;j<n;j++){
             pw.print(b[j]+"" "");
         }
         pw.println();
         pw.flush();
        }
    
    }
    
//   static long gcd(long a,long b){
//       if(a==0)
//       return b;
//       return gcd(b%a,a);
//   }
//   static long lcm(long a,long b){
//       return (a/gcd(a,b))*b;
//   }
}
",0,Non-plagiarised
2.921E+060,4323e2bd,"import java.util.*;
import java.io.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

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

	private static long[][] dp;
	private static ArrayList<Integer> lis1,lis0;

	public static void process() throws IOException {

		int n = sc.nextInt();
		int arr[] = sc.readArray(n);
		lis1 = new ArrayList<Integer>();
		lis0 = new ArrayList<Integer>();
		for(int i = 0; i<n; i++) {
			if(arr[i] == 1)lis1.add(i+1);
			else lis0.add(i+1);
		}
		Collections.sort(lis0);
		Collections.sort(lis1);
		int n0 = lis0.size();
		int n1 = lis1.size();
		dp = new long[n0+1][n1+1];
		for(int i = 0; i<=n0; i++) {
			Arrays.fill(dp[i], -1);
		}
		long ans = solve(0,0,n0,n1);
		System.out.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 = Math.min(ans,Math.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;

	

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

	

	/////////////////////////////////////////////////////////////////////////////////////////////////////////


	

	

	

	

	


	

	

	


	

	

	

	

	

	

	/////////////////////////////////////////////////////////////////////////////////////////////////////////

	

	

	
}
","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 long min(long a,long b,long c)
	{
		return Math.min(a, Math.min(c, b));
	}

	
	
	
	
	

	
	

	
	
	
	
	
	

	//Debugging Functions Starts

	
	
	
	
	

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	
	static int i()
	{
		return in.nextInt();
	}

	

	static int[] input(int N){
		int A[]=new int[N];
		for(int i=0; i<N; i++)
		{
			A[i]=in.nextInt();
		}
		return A;
	}

	

	//IO FUNCTIONS END

}



//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",0,Non-plagiarised
2af19170,ac8ef97c,"import java.util.*;
import java.io.*;

public class Solution{
	
	static long abs(long a){return Math.abs(a);}
	static long max(long a, long b){return Math.max(a, b);}
	
	static class Graph{
		
		int l[], r[], v;
		ArrayList<Integer> adj[];		
		Graph(int v){
			this.v = v;
			this.l = new int[v];
			this.r = new int[v];
			adj = new ArrayList[v];
			for(int i = 0 ; i < v ; i++){
				adj[i] = new ArrayList<>();
			}
		}
		
		void addEdge(int u, int v){
			this.adj[u].add(v);
			this.adj[v].add(u);
		}
		
		long[] dfs(int u, int parent){
			long left = 0, right = 0;
			int n = adj[u].size();
			for (int i = 0 ; i < n; i ++ ) {
				int child = adj[u].get(i);
				if ( child == parent ) continue;
				long val[] = dfs(child, u);
				left += max(abs(l[child]- l[u])+val[0], abs(r[child] - l[u])+val[1]);
				right += max(abs(l[child]- r[u])+val[0], abs(r[child] - r[u])+val[1]);
			}
			
			return new long[]{left, right};
		}
	}

	public static void main(String args[])throws IOException{
		BufferedReader br = new 
		BufferedReader(new InputStreamReader(System.in));
		
		int tests = Integer.parseInt(br.readLine());
		while( tests --> 0 ){
			int n = Integer.parseInt(br.readLine());
			Graph g = new Graph(n);
			for(int i = 0 ; i < n ; i++ ){
				String line[] = br.readLine().split("" "");
				g.l[i] = Integer.parseInt(line[0]);
				g.r[i] = Integer.parseInt(line[1]);
			}
			
			for(int i = 0 ; i < n - 1 ; i++ ){
				String line[] = br.readLine().split("" "");
				int u = Integer.parseInt(line[0]) - 1;
				int v = Integer.parseInt(line[1]) - 1;			
				g.addEdge(u, v);
			}
			
			long res[] = g.dfs(0, -1);
			System.out.println(max(res[0], res[1]));
		}
	}
}
","import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int t=Integer.parseInt(bu.readLine());
        while(t-->0)
        {
            int n=Integer.parseInt(bu.readLine());
            g=new ArrayList[n];
            int i;
            for(i=0;i<n;i++)
            {
                g[i]=new ArrayList<>();
                String st[]=bu.readLine().split("" "");
                a[i][0]=Integer.parseInt(st[0]); a[i][1]=Integer.parseInt(st[1]);
                s[i][0]=s[i][1]=0;
            }

            for(i=0;i<n-1;i++)
            {
                String st[]=bu.readLine().split("" "");
                int u=Integer.parseInt(st[0])-1,v=Integer.parseInt(st[1])-1;
                g[u].add(v); g[v].add(u);
            }

            dfs(0,-1);
            sb.append(Math.max(s[0][0],s[0][1])+""\n"");
        }
        System.out.print(sb);
    }

    static ArrayList<Integer> g[];
    static int N=100000,a[][]=new int[N][2];
    static long s[][]=new long[N][2];
    static void dfs(int n,int p)
    {
        for(int x:g[n])
        if(x!=p)
        {
            dfs(x,n);
            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
        }
    }
}
",0,Non-plagiarised
3380fa52,489930000000,"import java.util.*;
import java.io.*;
import java.math.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Coder {
  static int n, k;
  static long a[];
  static int pos[];
  static int temp[];
  static StringBuilder str = new StringBuilder("""");
  static int cnt[][] = new int[(int)1e5+5][2];
  static void solve() {
    long []l = new long[n];
    long []r = new long[n];
    long p = Integer.MAX_VALUE;
    for(int i=0;i<n;i++){
        p = Math.min(p+1, a[i]);
        l[i] = p;
    }
    p=Integer.MAX_VALUE;
    for(int i=n-1;i>=0;i--){
     p = Math.min(p+1, a[i]);
     r[i] = p;
    }
    for(int i=0;i<n;i++){
        str.append(Math.min(l[i],r[i])).append("" "");
    }
    str.append(""\n"");
  }

  public static void main(String[] args) throws java.lang.Exception {
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(bf.readLine().trim());
    while (t-- > 0) {
      bf.readLine();
      String s[] = bf.readLine().trim().split(""\\s+"");
      n = Integer.parseInt(s[0]);
      k = Integer.parseInt(s[1]);
      s = bf.readLine().trim().split(""\\s+"");
      pos = new int[k];
      temp = new int[k];
      a = new long[n];
      for(int i=0;i<k;i++) pos[i]=Integer.parseInt(s[i]);
      s = bf.readLine().trim().split(""\\s+"");
      for(int i=0;i<k;i++) temp[i]=Integer.parseInt(s[i]);
      Arrays.fill(a, Integer.MAX_VALUE);
      for(int i=0;i<k;i++) a[pos[i]-1] = temp[i]; 
      solve();
    }
    System.out.print(str);
  }
}
","import java.io.*;
import java.util.*;

public class Codeforce {

    

    static int mod = (int) (1e9 + 7);

    

    

    

    

    

    

    public static void main(String arg[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        while (t-- > 0) {
                                br.readLine();
                        String s[]=br.readLine().split("" "");
                        int n=Integer.parseInt(s[0]);
                        int k=Integer.parseInt(s[1]);
                        long a[]=new long[n];
                        long b[]=new long[n];
                        long c[]=new long[n];
                        Arrays.fill(c,Integer.MAX_VALUE);
                        String s1[]=br.readLine().split("" "");
                        s=br.readLine().split("" "");
                        for(int i=0;i<k;i++)
                            c[Integer.parseInt(s1[i])-1]=Integer.parseInt(s[i]);

                        long p=Integer.MAX_VALUE;
                        for(int i=0;i<n;i++)
                        {
                            p=Math.min(p+1,c[i]);
                            a[i]=p;
                        }
                        p=Integer.MAX_VALUE;
                        for(int i=n-1;i>=0;i--){
                            p=Math.min(p+1,c[i]);
                            b[i]=p;
                        }
                        for(int i=0;i<n;i++)
                            sb.append((Math.min(a[i],b[i]))+"" "");
                        sb.append(""\n"");

                       }
        System.out.println(sb);
    }
}
",1,Plagiarised
c57a973e,fa484fdd,"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();
		}

    }

    
}
","import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class AirConditioners {
    static InputReader inputReader=new InputReader(System.in);
    static void solve()
    {
        int n=inputReader.nextInt();
        int k=inputReader.nextInt();
        int pos[]=inputReader.nextIntArray(k);
        int power[]=inputReader.nextIntArray(k);
        int answer[]=new int[n];
        Arrays.fill(answer,(int)(2e9));
        for (int i=0;i<k;i++)
        {
            answer[pos[i]-1]=power[i];
        }
        for (int i=1;i<n;i++)
        {
            answer[i]=Math.min(answer[i],answer[i-1]+1);
        }
        for (int i=n-2;i>=0;i--)
        {
            answer[i]=Math.min(answer[i],answer[i+1]+1);
        }
        for (int i=0;i<n;i++)
        {
            out.print(answer[i]+"" "");
        }
    }
    static PrintWriter out=new PrintWriter((System.out));
    public static void main(String args[])throws IOException
    {
        int t=inputReader.nextInt();
        while(t-->0)
        {
            solve();
            out.println();
        }
        out.close();
    }
    
}
",1,Plagiarised
23194f89,bcc5473d,"import java.io.*;
import java.util.*;
public class new1{
	
    
    

	
	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();
			int[] ti = new int[n];
			for(int i = 0; i < n; i++) ti[i] = s.nextInt();
			int[] he = new int[n];
			for(int i = 0; i < n; i++) he[i] = s.nextInt();
			long ans = 0;
			int st = ti[n - 1] - he[n - 1] + 1;
			int en = ti[n - 1];
			//System.out.println(st + "" "" + en);
			for(int i = n - 2; i >= 0; i--) {
				int st1 = ti[i] - he[i] + 1;
				int en1 = ti[i];
				if(en1 >= st) {
					st = Math.min(st, st1);
				}
				else {
					long a1 = ((en - st + 1L) *  (en - st + 2L)) / 2;
					ans = ans + a1;
					st = st1; en = en1;
					//System.out.println(a1);
				}

			}
			ans = ans + ((en - st + 1L) *  (en - st + 2L)) / 2;
			System.out.println(ans);
			
			
			
			
			
			
		}
	   //output.flush();
	  }
}


 
	
","import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
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;

public class k
{		//public static int mod=1000000007;
	
	 
	
	 
	    // method to return LCM of two numbers
	    
	 public static HashMap<Integer, Integer> sortByValue(HashMap<Integer, Integer> hm)
	    {
	        // Create a list from elements of HashMap
	        List<Map.Entry<Integer, Integer> > list =
	               new LinkedList<Map.Entry<Integer, Integer> >(hm.entrySet());
	 
	        // Sort the list
	        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer> >() {
	            
	        });
	         
	        // put data from sorted list to hashmap
	        HashMap<Integer, Integer> temp = new LinkedHashMap<Integer, Integer>();
	        for (Map.Entry<Integer, Integer> aa : list) {
	            temp.put(aa.getKey(), aa.getValue());
	        }
	        return temp;
	    }
	 static int sieve =  1000000 ;


	 static boolean[] prime =  new boolean[sieve + 1] ;

	  
	 
	 
	 
	 
	 
	
	//if present - return the first occurrence of the no
	//not present- return the index of next greater value 
	//if greater than all the values return N(taking high=N-1)
	//if smaller than all the values return 0(taking low =0)
	
	//if present - return the index of next greater value
	//not present- return the index of next greater value 
	//if greater than all the values return N(taking high=N-1)
	//if smaller than all the values return 0(taking low =0)\
	
	
	
	
	 
	
	 public static void sortbyColumn(int arr[][], int col)  // send 2d array and col no
	    {
	        Arrays.sort(arr, new Comparator<int[]>() {       
	          
	        });
	    }
	 public static void sortbyColumn1(int arr[][], int col)  // send 2d array and col no
	    {
	        Arrays.sort(arr, new Comparator<int[]>() {       
	          
	        });
	    }
	 
	 
	    
	    
	    
	  
	  
	  
	 
	
	 
 	public static void main(String args[]) throws NumberFormatException, IOException ,java.lang.Exception
	{
		
		Reader reader = new Reader();
 	
			
		//sieveOfEratosthenes();
		//Scanner reader=new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
//		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//		int cases=Integer.parseInt(br.readLine());
//		int cases=1;
		int cases=reader.nextInt();
		
   	while (cases-->0){
//   		long N=reader.nextLong();
   		//long M=reader.nextLong();
   		int N=reader.nextInt();
//   		int P=reader.nextInt();
	
   		
////   		
//   		String[] first=br.readLine().split("" "");
//   		long N=Long.parseLong(first[0]);
//   		long K=Long.parseLong(first[1]);
//   		long X=Long.parseLong(first[2]);
//   		String s2=br.readLine();
//   		String s3=br.readLine();
//   		char[]  s11=s2.toCharArray();
//	  	    char[]  s12=new char[s11.length];
   		
    	//int max=Integer.MIN_VALUE;
//   		int min=Integer.MAX_VALUE;
   		//int mod=1000000007;
 
//   		HashMap<Integer, TreeSet<Integer>> map=new HashMap<Integer,TreeSet<Integer>>();
   		
   		HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
//		HashMap<Long,Long> map=new HashMap<Long,Long>();
//   		HashMap<String,Integer> map1=new HashMap<String,Integer>();
   		//HashMap<Character,Integer> path=new HashMap<Character,Integer>();
   		
   		//TreeMap<Integer,Integer> map=new TreeMap<Integer,Integer>(Collections.reverseOrder());
  		
//   		HashSet<Integer> set =new HashSet<Integer>();
//   		HashSet<Integer> right =new HashSet<Integer>();

   		//   		TreeSet<Integer> a =new TreeSet<Integer>();
   		//TreeSet<Long> b =new TreeSet<Long>();
//   		TreeSet<Integer> map=new TreeSet<Integer>();
   		
//   		long[] arr=new long[N];
//   		int[] odd=new int[100001];
   		
   		int[] sec=new int[N];
   		int[] pow=new int[N];
//   		int[][] arr=new int[N][P];
   		ArrayList<Long> list=new ArrayList<Long>();
//   		ArrayList<Long> list3=new ArrayList<Long>();
//   		ArrayList<Long> list1=new ArrayList<Long>();
//   		ArrayList<Long> bees=new ArrayList<Long>();
   		
//   		boolean[]arr1=new boolean[N];
//   
//   		for(int i=0;i<N;i++)
//   		{
//   	
   		
   		for(int i=0;i<N;i++)
   		
   		{
   			sec[i]=reader.nextInt();
   		}
   		for(int i=0;i<N;i++)
   		{
   			pow[i]=reader.nextInt();
   		}
   		int last=sec[N-1];
   		int ind=sec[N-1]-pow[N-1]+1;
   		long ans=0;
   		int i=N-2;
   		while(i>=0)
   		{
//   			System.out.println(last +"" ""+ind);
   			if(sec[i]>=ind)
   			{
   				if(sec[i]-ind+1<pow[i])
   				{
   					ind=ind-(pow[i]-sec[i]+ind-1);
   				}
   				i--;
   			}
   			else if(sec[i]<ind)
   			{
   				ans=ans+((long)(last-ind+1))*((long)(last-ind+2))/(long)(2);
   				last=sec[i];
   		   		ind=sec[i]-pow[i]+1;
   		   		i--;
   			}
   			
   				
   		}
   		ans=ans+((long)(last-ind+1))*((long)(last-ind+2))/(long)(2);
   		System.out.println(ans);
   		
   	}
//  output.flush(); 
   	
	}
 
}
",0,Non-plagiarised
b7de5c19,bac616ee,"import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        for (int i = 0; i < t; i++) {
            int n = scan.nextInt();
            ArrayList<ArrayList<Pair>> graph = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                graph.add(new ArrayList<>());
            }
            for (int j = 0; j < n - 1; j++) {
                int u;
                int v;
                u = scan.nextInt();
                v = scan.nextInt();
                u--;
                v--;
                graph.get(u).add(new Pair(v, j));
                graph.get(v).add(new Pair(u, j));
            }
            boolean soluble = true;
            int curV = 0;
            int prevV = -1;
            int[] ans = new int[n];
            int prime = 2;
            for (int j = 0; j < n; j++) {
                ArrayList<Pair> list = graph.get(j);
                if (list.size() > 2) {
                    soluble = false;
                } else if (list.size() == 1) {
                    curV = j;
                }
            }
            if (soluble) {
                for (int j = 0; j < n - 1; j++) {
                    ArrayList<Pair> list = graph.get(curV);
                    for (int z = 0; z < list.size(); z++) {
                        if (list.get(z).vertex != prevV) {
                            ans[list.get(z).numberOfEdge] = prime;
                            prime = changePrime(prime);
                            prevV = curV;
                            curV = list.get(z).vertex;
                            break;
                        }
                    }
                }

                for (int j = 0; j < n - 1; j++) {
                    System.out.print(ans[j] + "" "");
                }
                System.out.println();
            } else {
                System.out.println(-1);
            }
        }
    }
    public static int changePrime(int prime) {
        if (prime == 2) {
            prime = 3;
        } else {
            prime = 2;
        }
        return prime;
    }
}

class Pair {
    int vertex;
    int numberOfEdge;

    public Pair(int vertex, int numberOfEdge) {
        this.vertex = vertex;
        this.numberOfEdge = numberOfEdge;
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class NotAssigning {
	
	
	
	static class 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
4851a411,e201bc2e,"import java.util.ArrayList;
import java.util.HashMap;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 17:15:47 15/01/2022
    Custom Competitive programming helper.
*/

public class Main {
	static ArrayList<Integer> adj[];
	static HashMap<Integer, HashMap<Integer, Integer>> mp;
	public static void insert(int i, int j, int v) {
		int a = Math.min(i, j), b = Math.max(i, j);
		if(!mp.containsKey(a)) mp.put(a, new HashMap<>());
		mp.get(a).put(b, v);
	}
	public static int get(int i, int j) {
		int a = Math.min(i, j), b = Math.max(i, j);
		return mp.get(a).get(b);
	}
	public static void dfs(int i, int p, boolean two) {
		
		for(int to : adj[i]) {
			if(to == p) continue;
			insert(i, to, two?2:3);
			dfs(to,i,!two);
			two = !two;
		}
	}
	public static void solve() {
		mp = new HashMap<>();
		int n = in.nextInt();
		adj = new ArrayList[n];
		for(int i = 0; i<n; i++) adj[i] = new ArrayList<>();
		int[][] e = new int[n-1][2];
		int[] deg = new int[n];
		for(int i = 0; i<n-1; i++) {
			e[i] = in.na(2);
			deg[--e[i][0]]++;
			deg[--e[i][1]]++;
			adj[e[i][0]].add(e[i][1]);
			adj[e[i][1]].add(e[i][0]);
		}
		for(int i = 0; i<n; i++) {
			if(deg[i]>=3) {
				out.println(-1);
				return;
			}
		}
		dfs(0,-1,true);
		for(int i = 0; i<n-1; i++) {
			out.print(get(e[i][0], e[i][1])+"" "");
		}
		out.println();
	}
	
	public static void main(String[] args) {
		in = new Reader();
		out = new Writer();
		int t = in.nextInt();
		while(t-->0) solve();
		out.exit();
	}
	static Reader in; static Writer out;






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


public class Solution {
	static int mod=1000000007;;
	
//	 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		System.out.println();

		Scanner sc=new Scanner(System.in);
		int tt=sc.nextInt();
//		
//		
		while(tt-->0){
			int n=sc.nextInt();
			
			int degree[]=new int[n];
			
			Arrays.fill(degree, 0);
			int u[]=new int[n-1];
			int v[]=new int[n-1];
			boolean brea=false;
			HashMap<Integer,LinkedList<Integer>>graph=new HashMap<>();
			for(int i=0;i<n-1;i++) {
				u[i]=sc.nextInt();
				v[i]=sc.nextInt();
				u[i]--;
				v[i]--;
				
				if(graph.containsKey(u[i])) {
					LinkedList<Integer> ll=graph.get(u[i]);
					ll.add(i);
					graph.put(u[i],ll);
				}
				else {
					LinkedList<Integer> ll=new LinkedList<>();
					ll.add(i);
					graph.put(u[i],ll);
				}
				if(graph.containsKey(v[i])) {
					LinkedList<Integer> ll=graph.get(v[i]);
					ll.add(i);
					graph.put(v[i],ll);
				}
				else {
					LinkedList<Integer> ll=new LinkedList<>();
					ll.add(i);
					graph.put(v[i],ll);
				}
				
				
				
				degree[u[i]]++;
				if(degree[u[i]]>2)brea=true;
				degree[v[i]]++;
				if(degree[v[i]]>2)brea=true;
			}
			
			if(brea) {
				System.out.println(-1);
				continue;
			}
			
			
			
			int i;
			for( i=0;i<n;i++) {
				
				if(degree[i]==1)break;
				
			}
//			System.out.println(graph+"" ""+i);
			
			int ans[]=new int[n-1];
			int ind=graph.get(i).get(0);
			ans[ind]=2;
			
			if(u[ind]==i)i=v[ind];
			else i=u[ind];
			
			boolean flip=true;
			
			while(graph.get(i).size()>1) {
				
				if(graph.get(i).get(0)==ind) {
					ind=graph.get(i).get(1);
				}
				else {
					ind=graph.get(i).get(0);
				}
				
				if(flip) {
					ans[ind]=3;
				}else ans[ind]=2;
				
				flip=!flip;
				
				
				if(u[ind]==i)i=v[ind];
				else i=u[ind];
				
			}
			
			
			 
			for(int j:ans)
			 System.out.print(j+"" "");
			 System.out.println();
			
		
			
		}
	}
		
		
	
		
		
	
	
	


}
",0,Non-plagiarised
175201f9,40cc90ae,"import java.util.*;
import java.io.*;
public class Sol{
 
/*   
->check n=1, int overflow , array bounds , all possibilites(dont stuck on 1 approach)
->Problem = Observation(constraints(m<=n/3 or k<=min(100,n)) 
           + Thinking + Technique (seg_tree,binary lift,rmq,bipart,dp,connected comp etc)
->solve or leave it (- tutorial improves you in minimal way -)
*/
 
public static void main (String []args) {
//precomp();
 
int times=ni();while(times-->0){solve();}out.close();}

static void solve(){
 int n=ni();
 int sum[]=new int[5]; 
 PriorityQueue<Integer> p[]=new PriorityQueue[5];for(int i=0;i<5;i++)p[i]=new PriorityQueue<Integer>();
 for(int i=0;i<n;i++){
   char c[]=ns().toCharArray();
   int len=c.length;
   int csum[]=new int[5];
   for(int j=0;j<len;j++){csum[c[j]-'a']++;}
   for(int j=0;j<5;j++){csum[j]=2*csum[j]-len;p[j].offer(csum[j]);sum[j]+=csum[j];}
 }
 int max=0;
 for(int i=0;i<5;i++){
   int cmax=n;
   while(p[i].size()>0 && sum[i]<=0){cmax--;sum[i]-=p[i].poll();}
   max=Math.max(max,cmax);
 }
 out.println(max);
 return;

}

//-----------------Utility--------------------------------------------


 
 

 


 
//----------------------I/O---------------------------------------------
 
static InputStream inputStream = System.in;
static OutputStream outputStream = System.out;
static FastReader in=new FastReader(inputStream);
static PrintWriter out=new PrintWriter(outputStream);
 

/*static int ni() {
        try {
            boolean in = false;
            int res = 0;
            for (;;) {
                int b = System.in.read() - '0';
                if (b >= 0) {
                    in = true;
                    res = 10 * res + b;
                }
                else if (in)
                    return res;
            }
        } catch (IOException e) {
            throw new Error(e);
        }
    }*/
static int ni(){return in.nextInt();}


static String ns(){return in.nextLine();}
}
","import javax.swing.text.html.parser.Entity;
import java.io.*;
import java.util.*;
import java.math.BigInteger;



public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{

        double eps= 0.00000001;
        static final int MAXN = 1010;
        static final int MOD= 1000000007;

        // stores smallest prime factor for every number
        static int spf[] = new int[MAXN];

        static boolean[] prime;

        // Calculating SPF (Smallest Prime Factor) for every
        // number till MAXN.
        // Time Complexity : O(nloglogn)
        

        

        // function to find first index >= x
        
        

        // function to find last index <= y
        
        

        // function to count elements within given range
        

        

        public int add(int a, int b){
            a+=b;
            if(a>=MOD) a-=MOD;
            else if(a<0) a+=MOD;
            return a;
        }

        

        

        int[] fact= new int[MAXN];
        int[] inv= new int[MAXN];

        

        

        

        /**
         * return VALUE of lower bound for unsorted array
         */
        
        /**
         * return VALUE of upper bound for unsorted array
         */
        

        

        

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

        

    }

    



    

    

    // public static class compareL implements Comparator<Tuple>{
    //     @Override
    //     public int compare(Tuple t1, Tuple t2) {
    //         return t2.l - t1.l;
    //     }
    // }

    // fast input reader class;
    
}
",0,Non-plagiarised
ca8f11a4,e19376ca,"import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;

public class GR18_C2 {
	public static FastScanner sc;
	public static StringBuilder sb ;public static int MOD= 1000000007;
	

    public static void solve(int t) throws IOException {
    	int n=sc.nextInt();
    	String a=sc.next();
    	String b=sc.next();
    	
    	int _00=0;
    	int _01=0;
    	int _10=0;
    	int _11=0;
    	
    	for(int i=0;i<n;i++) {
    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
    	}
    	
    	int ans=Integer.MAX_VALUE;
    	
    	
    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
    	if(_01==_10) {
    		ans=Math.min(ans, _10*2);
    	}
    	// By performing one operation, we get _01==_10 and then even operations can be done.
    	// Possible when _11=_00 and one additional _11 for odd operation
    	if(_00+1==_11) {
    		ans=Math.min(ans, (_11-1)*2+1);
    	}
    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
    	else sb.append(ans).append('\n');
    }
    
	public static void main(String[] args) throws IOException {
		sb = new StringBuilder("""");
		sc = new FastScanner();
		int t=sc.nextInt();
		for(int i=1;i<=t;i++){
			solve(i);
		}
		System.out.println(sb);
	}
	
	
}
","import java.io.*;
import java.util.*;

public class new1{

    
    public static int count(int[] arr, int[] dest) {
    	int n = arr.length;
    	int count = 0;
    	for(int i = 0; i < n; i++) {
    		if(arr[i] != dest[i]) count++;
    	}
    	return count;
    }
    
    
    

	
	public static void main(String[] args)  throws IOException{
    	BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		FastReader s = new FastReader();
		int t = s.nextInt();
		
		
    	for(int z = 0; z < t; z++) {
    		int n = s.nextInt();
    		String str1 = s.next();
    		String str2 = s.next();
    		int count1  = 0; int count2 = 0;
    		for(int i = 0; i < n; i++) {
    			if(str1.charAt(i) == '1') count1++;
    			if(str2.charAt(i) == '1') count2++;
    		}
    		if(!(count1 == count2 || n - count1 + 1 == count2)) {
    			System.out.println(-1);
    			continue;
    		}
    		
    		int[] arr = new int[n];
    		int[] dest = new int[n];
    		for(int i = 0; i < n; i++) {
    			arr[i] = str1.charAt(i) - '0';
    			dest[i] = str2.charAt(i) - '0';
    		}
    		int ans1 = count(arr, dest);
    		int ans2 = Integer.MAX_VALUE;
    		int flag = 0;
    		for(int i = 0; i < n; i++) {
    			if(flag == 0 && arr[i] == 1 && dest[i] == 1) {
    				flag = 1;
    			}
    			else {
    				arr[i] = 1 - arr[i];
    			}
    		}
    		//System.out.println(ans1);
    		if(flag == 1) {
    			ans2 = Math.min(ans2, count(arr, dest) + 1);
    		}
    		else {
    			for(int i = 0; i < n; i++) {
    				if(str1.charAt(i) == '1' && flag == 0) {
    					flag = 1; arr[i] = 1;
    					break;	
    				}
    			}
    			
    		}
    		if(flag == 1) ans2 = Math.min(ans2, count(arr, dest) + 1);
    		int ans = Integer.MAX_VALUE;
    		if(count1 == count2) ans = Math.min(ans, ans1);
    		if(n - count1 + 1 == count2) ans = Math.min(ans, ans2);
    		System.out.println(ans);
    		
    		
    		
    	}
    	//output.flush();

    }
}



",0,Non-plagiarised
1f27b677,81fb6415,"import java.util.*;
import java.io.*;

public class Codeforces {

  static long accurateFloor(long a, long b) {
    long val = a/b;
    while(val*b > a) val--;
    return val;
  }

  public static void main(String[] args) throws Exception {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter writer = new PrintWriter(System.out);
      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());
        Long[] a = new Long[n];
        st = new StringTokenizer(br.readLine());
        long[] sum = new long[n];
        for(int i = 0; i < n; i++) {
          a[i] = Long.parseLong(st.nextToken());
        }
        Arrays.sort(a);
        sum[0] = a[0];
        for(int i = 1; i < n; i++) {
          sum[i] += sum[i-1]+a[i];
        }
        long ans = Long.MAX_VALUE;
        for(int y = 0; y < n; y++) {
          // long z = k-sum[n-y-1]+a[0];
          // if(z > 0) z = z/(y+1);
          // else {
          //   if(z%(y+1) == 0) z = z/(y+1);
          //   else {
          //     z = z/(y+1);
          //     z -= 1;
          //   }
          // }
          long x = a[0]-accurateFloor(k-sum[n-y-1]+a[0], y+1);
          x = Math.max(0, x);
          ans = Math.min(ans, y+x);
        }
        writer.println(ans);
      }
      writer.close();
      br.close();
  }

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

}
",0,Non-plagiarised
24044589,e435b1ac,"import java.util.*;
import java.io.*;

public class C_Phoenix_and_Towers{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        int m=s.nextInt();
        int x=s.nextInt();
        int array[]= new int[n];
        HashMap<Integer,Queue<Integer>> indices = new HashMap<Integer,Queue<Integer>>();
        for(int i=0;i<n;i++){
            array[i]=s.nextInt();
            if(indices.containsKey(array[i])){
              indices.get(array[i]).add(i);
            }
            else{
                Queue<Integer> obj = new LinkedList<Integer>();
                obj.add(i);
                indices.put(array[i],obj);
            }
        }
        long tower[]= new long[m];
        int ans[]= new int[n];
        Arrays.sort(array);
        int k=0;
        for(int i=0;i<n;i++){
            tower[k]+=array[i];
            int a=indices.get(array[i]).poll();
            ans[a]=k+1;
            k++;
            if(k==m){
                k=0;
            }

        }
        long max=Long.MIN_VALUE;
        long min=Long.MAX_VALUE;
        for(int i=0;i<m;i++){
            min=Math.min(min,tower[i]);
            max=Math.max(max,tower[i]);
        }
        if(max-min<=x){
            res.append(""YES\n"");
            for(int i=0;i<n;i++){
                res.append(ans[i]+"" "");
            }
            res.append(""\n"");
        }
        else{
            res.append(""NO\n"");
        }
        p++;
    }
    System.out.println(res);

    }
    




}
","import java.util.*;
import java.io.*;
public class C {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		StringBuilder sb = new StringBuilder();
		while(T-->0) {
			int n = sc.nextInt();
			int m = sc.nextInt();
			long x = sc.nextLong();
			long[] arr = new long[n];
			for(int i = 0; i < n; i++) {
				arr[i] = sc.nextLong();
			}
			int[] res = new int[n];
			PriorityQueue<Pair> q = new PriorityQueue<>();
			for(int i = 0; i < m; i++) {
				q.add(new Pair(i+1, 0));
			}
			for(int i = 0; i < n; i++) {
				Pair p = q.poll();
				res[i] = p.i;
				q.add(new Pair(p.i, p.w + arr[i]));
			}
			sb.append(""YES\n"");
			for(int i = 0; i < n; i++) {
				sb.append(res[i]+"" "");
			}
			sb.replace(sb.length()-1, sb.length(), ""\n"");
		}
		PrintWriter pw = new PrintWriter(System.out);
		pw.println(sb.toString().trim());
		pw.flush();

	}
	static class Pair implements Comparable<Pair>{
		int i; long w;
		public Pair(int i, long w) {
			this.i = i; this.w = w;
		}
		public String toString() {
			return i+"" ""+w;
		}
		
	}
	
	

}
",0,Non-plagiarised
2acaa7df,46e9aed4,"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();
    int[] a = new int[n];
    int one = 0;
    int i,j;
    
    for(i=0;i<n;++i)
        {
        a[i] = scan.nextInt();
        one += a[i];
        }
        
    int[] pos = new int[one];
    one = 0;
    for(i=0;i<n;++i)  
        if(a[i] == 1)
            pos[one++] = i;
          
    long[][] dp = new long[one][n];
    
    if(one == 0)
        {
        output.write(""0\n"");
        output.flush();
        return;
        }
        
    if(a[0] == 0)
        dp[0][0] = pos[0];
    else 
        dp[0][0] = Integer.MAX_VALUE;
    for(j=1;j<n;++j)    
        {
        if(a[j] == 1)
            {
            dp[0][j] = dp[0][j-1];
            continue;
            }
            
        dp[0][j] = Math.abs(pos[0] - j);
        dp[0][j] = Math.min(dp[0][j], dp[0][j-1]);    
        }
     
     
    for(i=1;i<one;++i)  
        {
        int cnt = 0;
        for(j=0;j<n;++j)
            {
            if(a[j] == 0)
                ++cnt;
            if(cnt == i + 1)
                break;
             
            dp[i][j] = Integer.MAX_VALUE;
            }
             
        for(;j<n;++j)
            {
            if(a[j] == 1)
                {
                dp[i][j] = dp[i][j-1];
                continue; 
                }    
                
            dp[i][j] = Math.abs(pos[i] - j) + dp[i-1][j-1];
            dp[i][j] = Math.min(dp[i][j], dp[i][j-1]); 
            }
        }  
    
//    for(i=0;i<one;++i)
//        {
//        for(j=0;j<n;++j)
//            output.write(dp[i][j] + "" "");
//        output.write(""\n"");
//        }
    long ans = dp[one-1][n-1];
    output.write(ans + ""\n"");    
    output.flush();
    }
    public static void main(String[] args) throws Exception
    {
    int t = 1;
    //t = scan.nextInt();
    while(t-- > 0)
        tc();
    }
}
","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();
        //   }
         
    }




   
    }


",0,Non-plagiarised
e1c4f3db,e81b2d16,"import java.util.*;

public class BalancedStoneHeaps {

    public static boolean check(int n, int x, int[] h) {
        int[] c_h = new int[n];
        for (int i = 0; i < n; i++)
            c_h[i] = h[i];
        for (int i = n - 1; i >= 2; i--) {
            if (c_h[i] < x)
                return false;
            int d = Math.min(h[i], c_h[i] - x) / 3;
            c_h[i - 1] += d;
            c_h[i - 2] += 2 * d;
        }
        return c_h[0] >= x && c_h[1] >= x;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            int[] h = new int[n];
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < n; i++) {
                h[i] = sc.nextInt();
                if (h[i] > max) {
                    max = h[i];
                }
            }
            int l = 0;
            int r = max;
            while (l < r) {
                int mid = l + (r - l + 1) / 2;
                if (check(n, mid, h)) {
                    l = mid;
                } else {
                    r = mid - 1;
                }
            }
            System.out.println(l);
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class fastTemp {
    

    static 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
3951966f,b842cf12,"import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

public class Armchairs {
    static  ArrayList<Integer> f;
    static ArrayList<Integer> u;
    static int dp[][];
    static int fun(int i, int j){
        if(i == f.size()) return 0;
        if(j == u.size()) return 99999999;
        if(dp[i][j] != -1) return dp[i][j];
        int ans1 = fun(i, j+1);
        int ans2 = fun(i+1, j+1) + Math.abs(f.get(i)-u.get(j));
        return dp[i][j] = Math.min(ans1, ans2);
    }
    private static int solve(int n, int a[]) {
        for (int i = 0; i < n; i++) {
            if (a[i]==0)
                u.add(i);
            else
                f.add(i);
        }

        return fun(0,0);
    }

    public static void main(String[] args)
            throws IOException {
        Scanner s = new Scanner();
        int t = 1;
        StringBuilder ans = new StringBuilder();
        int count = 0;
        while (t-- > 0) {
            int n = s.nextInt();
            int a[] = new int[n];
            dp=new int[n][n];
            for (int i = 0; i < n; i++) {
                a[i]=s.nextInt();
            }
            f=new ArrayList<>();
            u=new ArrayList<>();
            for( int i=0; i<n; i++) Arrays.fill(dp[i],-1);

            ans.append(solve(n, a)).append(""\n"");
        }
        System.out.println(ans.toString());
    }

    

    

    

    

    

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



public class A {

	

	


	static Scanner sc = new Scanner(System.in);
	static StringBuilder out = new StringBuilder();

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

		int t = 1;// sc.nextInt();

		while (t-- > 0) {

			A run = new A();

			run.run();

		}

		System.out.println(out);

	}

	

	public void run() throws IOException {

//	int k = sc.nextInt();

//		if(100%k==0)out.append((100/k)+""\n"");
//		
//		else {
//			out.append(100+""\n"");
//		}

//		int ans=(int)1e9;
//		for(int i=1;i<=k;i++) {
//			
//			
//			if(i*100%k==0) {
//				
//				ans=Math.min(ans,i*)
//				
//				
//			}
//			
//		}

//		
//		int ans = 100 - k;
//		if (k == 100)
//			out.append(1);
//		else {
//			int g = gcd(k, ans);
//			out.append((k / g) + (ans / g));
//		}
//		out.append(""\n"");
//		

//		int n = sc.nextInt();
//		int a[] = new int[n];
//		
//		for(int i=0;i<n;i++)a[i]=sc.nextInt();
//		int min = Integer.MAX_VALUE, mx = Integer.MIN_VALUE;
//		for (int i = 0; i < n; i++) {
//			min = Math.min(min, a[i]);
//			mx = Math.max(mx, a[i]);
//		}
//		int b[] = a.clone();
//		sort(b,n);
//		if (Arrays.equals(a, b)) {
//			out.append(0);
//		} else if (a[0] == min || a[n - 1] == mx) {
//			out.append(1);
//		} else if (a[0] == mx && a[n - 1] == min) {
//			out.append(3);
//		} else {
//			out.append(2);
//		}
//		out.append(""\n"");

		int n = sc.nextInt();

		int a[] = new int[n];

		TreeSet<Integer> ts = new TreeSet<>();

		ArrayList<Integer> a1 = new ArrayList<>();
		ArrayList<Integer> b = new ArrayList<>();
		for (int i = 0; i < n; i++) {

			a[i] = sc.nextInt();
			if (a[i] == 1)
				a1.add(i);
			else
				b.add(i);

		}

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

		memo = new int[n][n];

		for (int tem[] : memo)
			Arrays.fill(tem, -1);

		sum = solve(0, 0, a1, b);
		out.append(sum + ""\n"");
	}

	static int memo[][];

	static int solve(int i, int j, ArrayList<Integer> a, ArrayList<Integer> b) {

		if(i==a.size())return 0;
		if(a.size()-i>b.size()-j)return (int)1e9;
		if(j==b.size())return (int)1e9;
		if(memo[i][j]!=-1)return memo[i][j];
		int ans = (int) 1e9;

		
		
		

			ans = Math.min(solve(i + 1, j+1 , a, b) + Math.abs(a.get(i) - b.get(j)),solve(i,j+1,a,b));
		
		
		return memo[i][j]=ans;

	}

	

	

	

//	static Reader sc = new Reader();

	

}
",0,Non-plagiarised
a368f345,b434c275,"import java.util.*;
import java.io.*;

public class codeforces {
    

    static FastReader fr;
    static StringBuilder res;

    

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

    

    

    
}
","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 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 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 int i()
	{
		return in.nextInt();
	}

	

	

	

	

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


//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",0,Non-plagiarised
0951d079,71a4f6d2,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;

public class D {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(file.readLine());
		int[] heights = new int[n];
		StringTokenizer st = new StringTokenizer(file.readLine());
		for(int i = 0; i < n; i++) {
			heights[i] = Integer.parseInt(st.nextToken());
		}
		int[] dp = new int[n];
		dp[0] = 0;
		Stack<Integer> high = new Stack<>();
		Stack<Integer> low = new Stack<>();
		high.push(0);
		low.push(0);
		for(int i = 1; i < n; i++) {
			dp[i] = dp[i-1]+1;
			while(!high.isEmpty() && heights[high.peek()] < heights[i]) {
				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
				high.pop();
			}
			if(!high.isEmpty()) {
				dp[i] = Math.min(dp[i], dp[high.peek()]+1);
				if(heights[high.peek()] == heights[i])
					high.pop();
			}
			while(!low.isEmpty() && heights[low.peek()] > heights[i]) {
				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
				low.pop();
			}
			if(!low.isEmpty()) {
				dp[i] = Math.min(dp[i], dp[low.peek()]+1);
				if(heights[low.peek()] == heights[i])
					low.pop();
			}
			high.push(i);
			low.push(i);
		}
		System.out.println(dp[n-1]);
	}

}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Vector;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Stack;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DDiscreteCentrifugalJumps solver = new DDiscreteCentrifugalJumps();
        solver.solve(1, in, out);
        out.close();
    }

    static class DDiscreteCentrifugalJumps {
        public void solve(int testNumber, InputReader s, PrintWriter w) {
            int n = s.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = s.nextInt();
            int[] dp = new int[n];
            for (int i = 0; i < n; i++)
                dp[i] = i;
            Stack<Integer> dec = new Stack<>();
            dec.push(0);
            Stack<Integer> inc = new Stack<>();
            inc.push(0);
            for (int i = 1; i < n; i++) {
                while (!dec.isEmpty() && a[dec.peek()] < a[i]) {
                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
                    dec.pop();
                }
                if (!dec.isEmpty()) {
                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
                    if (a[dec.peek()] == a[i])
                        dec.pop();
                }
                dec.push(i);
                while (!inc.isEmpty() && a[inc.peek()] > a[i]) {
                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
                    inc.pop();
                }
                if (!inc.isEmpty()) {
                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
                    if (a[inc.peek()] == a[i])
                        inc.pop();
                }
                inc.push(i);
            }
            w.println(dp[n - 1]);
        }

    }

    
}
",1,Plagiarised
856a8eda,c354b74f,"import java.io.*;
import java.util.*;

public class three{
	public static class Pair implements Comparable<Pair>{
		int min;
		int idx;
		
	}

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 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 + ""]"";
    //     }
    // }
    //--------------------------------------------------------
}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{ 
  static  Reader sc=new Reader();
  // static FastReader sc=new FastReader(System.in);
  static class PairComparator implements Comparator<Pair>{
              
            // Overriding compare()method of Comparator 
                        // for descending order of cgpa
            
        }
 public static void main (String[] args) throws java.lang.Exception
   {
//	try{
	    /*
	        int n=sc.nextInt();
	        ArrayList<Integer> al=new ArrayList<>();
	        ArrayList<Long> al=new ArrayList<>();
	        Set<Integer> set=new HashSet<>();
	        Collections.sort(al,Collections.reverseOrder());
	     
	        long n=sc.nextLong();
	        for(int i=0;i<n;i++) 
	        String s=sc.next();
	        StringBuilder sb=new StringBuilder();
	     */
		  int t = sc.nextInt();
		  while(t-->0)
		    { 
		       int n=sc.nextInt();
		       int m=sc.nextInt();
		       int x=sc.nextInt();
		       PriorityQueue<Pair> pq=new PriorityQueue<>(m, new PairComparator());
		       for(int i=1;i<=m;i++)
		         {
		          Pair p=new Pair(0,i);
		          pq.add(p);
		         }
		       out.println(""YES"");
		       int a[]=new int[n];
		       for(int i=0;i<n;i++)
		         {
		           a[i]=sc.nextInt();
		           Pair shortest=pq.poll();
		           out.print(shortest.y+"" "");
		           Pair update=new Pair(shortest.x+a[i],shortest.y);
		           pq.add(update);
		         }
		      
		      out.println( );
		    }
	     out.flush();
	     out.close();
// 	   }     
// 	catch(Exception e)
// 		 {}
	}
 
 /*
   ...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
 */
 

   
 /*                     
    Map<Long,Long> map=new HashMap<>();
             for(int i=0;i<n;i++)
               {
                  if(!map.containsKey(a[i]))
                   map.put(a[i],1);
                 else
                   map.replace(a[i],map.get(a[i])+1);
               }
     
    Set<Map.Entry<Long,Long>> hmap=map.entrySet();
             for(Map.Entry<Long,Long> data : hmap)
               {
          
               }
       
   Iterator<Integer> it = set.iterator();
          while(it.hasNext()) 
           { 
            int x=it.next();
           }
   */

static void print(int a[])
  {
     int n=a.length;
     for(int i=0;i<n;i++)
       {
          out.print(a[i]+"" "");
       }
     out.println();
     out.flush();
  }
static void print(long a[])
  {
     int n=a.length;
     for(int i=0;i<n;i++)
       {
          out.print(a[i]+"" "");
       }
     out.println();
     out.flush();
  } 


  


 

 
  
static class Pair
   {
      int x,y;
      Pair(int x,int y)
       {
          this.x=x;
          this.y=y;
       }
   }
   



 




 
 
 

   
   
    
  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;
}
",0,Non-plagiarised
c4ca2ff3,ccc8ef27,"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
8782922d,f5f97f19,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Interesting_Story {
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            List<String> l = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                l.add(sc.next());
            }
            int res = 0;
            for (int i = 0; i <= 5; i++) {
                List<Integer> myL = new ArrayList<>();
                for (String s : l) {
                    int count1 = 0, count2 = 0;
                    for (char ch : s.toCharArray()) {
                        if (ch == (char) (i + 97)) {
                            count1++;
                        } else {
                            count2++;
                        }
                    }
                    myL.add(count2 - count1);
                }
                //System.out.println(myL);
                Collections.sort(myL);
                int sum = 0;
                for (int m = 0; m < myL.size(); m++) {
                    sum += myL.get(m);
                    if (sum < 0) {
                        res = Math.max(res, m + 1);
                    }
                }
            }
            System.out.println(res);
        }
    }
}
","import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class One {
    static class Word {
        int a = 0;
        int b = 0;
        int c = 0;
        int d = 0;
        int e = 0;
        int total = 0;
        String s = """";

        
    }

    static class CompA implements Comparator<Word> {
        
    }

    static class CompB implements Comparator<Word> {
        
    }

    static class CompC implements Comparator<Word> {
        
    }

    static class CompD implements Comparator<Word> {
        
    }

    static class CompE implements Comparator<Word> {
        
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();

        while (t != 0) {
            t--;
            int n = scan.nextInt();
            Word[] words = new Word[n];

            for (int i = 0 ; i < n ; i++) {
                String s = scan.next();
                Word word = new Word();
                word.s = s;

                for (int j = 0 ; j < s.length() ; j++) {
                    if (s.charAt(j) == 'a') {
                        word.a++;
                    } else if (s.charAt(j) == 'b') {
                        word.b++;
                    } else if (s.charAt(j) == 'c') {
                        word.c++;
                    } else if (s.charAt(j) == 'd') {
                        word.d++;
                    } else if (s.charAt(j) == 'e') {
                        word.e++;
                    }

                    word.total++;
                }

                words[i] = word;
            }

            int answer = 0;
            int main = 0;
            int other = 0;
            int count = 0;
            Arrays.sort(words, new CompA());

            for (int i = 0 ; i < n ; i++) {
                main += words[i].a;
                other += words[i].total - words[i].a;

                if (main > other) {
                    count++;
                } else {
                    break;
                }
            }

            answer = Math.max(answer, count);
            main = 0;
            other = 0;
            count = 0;
            Arrays.sort(words, new CompB());

            for (int i = 0 ; i < n ; i++) {
                main += words[i].b;
                other += words[i].total - words[i].b;

                if (main > other) {
                    count++;
                } else {
                    break;
                }
            }

            answer = Math.max(answer, count);
            main = 0;
            other = 0;
            count = 0;
            Arrays.sort(words, new CompC());

            for (int i = 0 ; i < n ; i++) {
                main += words[i].c;
                other += words[i].total - words[i].c;

                if (main > other) {
                    count++;
                } else {
                    break;
                }
            }

            answer = Math.max(answer, count);
            main = 0;
            other = 0;
            count = 0;
            Arrays.sort(words, new CompD());

            for (int i = 0 ; i < n ; i++) {
                main += words[i].d;
                other += words[i].total - words[i].d;

                if (main > other) {
                    count++;
                } else {
                    break;
                }
            }

            answer = Math.max(answer, count);
            main = 0;
            other = 0;
            count = 0;
            Arrays.sort(words, new CompE());

            for (int i = 0 ; i < n ; i++) {
                main += words[i].e;
                other += words[i].total - words[i].e;

                if (main > other) {
                    count++;
                } else {
                    break;
                }
            }

            answer = Math.max(answer, count);
            System.out.println(answer);
        }

        scan.close();
    }
}
",0,Non-plagiarised
0b04b41e,c4ca2ff3,"import java.io.BufferedReader;
import java.io.*;
import java.util.*;

public class josph {

static BufferedReader br;


// 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=Math.max(max,cnt);
}
System.out.println(max);
}

}



























public static String cin() throws Exception {
return br.readLine();
}









public static Integer cinI() throws Exception {
return Integer.parseInt(br.readLine());
}













}
","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
2ef4c176,fa1bf524,"import java.io.*;
import java.util.*;

public class Template {

	static int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int yo = sc.nextInt();
		while (yo-- > 0) {
			int n = sc.nextInt();
			
			Map<Integer,Pair> map = new HashMap<>();
			
			for(int i = 0; i < n; i++) {
				map.put(i, new Pair(sc.nextLong(),sc.nextLong()));
			}
			
			List<List<Integer>> list = new ArrayList<>();
			for(int i = 0; i < n; i++) {
				list.add(new ArrayList<>());
			}
			for(int i = 0; i < n-1; i++) {
				int x = sc.nextInt()-1;
				int y = sc.nextInt()-1;
				list.get(x).add(y);
				list.get(y).add(x);
			}
			
			// l -> 0, r -> 1
			
			for(int i = 0; i < 1e5+3; i++) {
				for(int j = 0; j < 2; j++) {
					dp[i][j] = -1;
				}
			}
			long a1 = dfs(map,list,0,0,-1);
			long a2 = dfs(map,list,1,0,-1);
			long ans = Math.max(a1, a2);
			out.println(ans);
		}
		out.close();
	}

//	static Map<String,Long> dp = new HashMap<>();
	static long[][] dp = new long[(int)1e5+10][2];
	private static long dfs(Map<Integer, Pair> map, List<List<Integer>> list, 
							int x, int node, int parent) {
		
		
		if(dp[node][x] != -1) {
			return dp[node][x];
		}

		List<Integer> neighbours = list.get(node);
		
		long ans1 = 0;
		if(x == 0) {
			ans1 = map.get(node).x;
		}
		else {
			ans1 = map.get(node).y;
		}
		
		
		long uAns = 0;
		for(int e : neighbours) {
			if(e == parent) continue;
			long ua1 = dfs(map,list,0,e,node);
			long ua2 = dfs(map,list,1,e,node);
			// consider 0
			long a1 = ua1 + Math.abs(map.get(e).x-ans1);
			// consider 1
			long a2 = ua2 + Math.abs(map.get(e).y-ans1);
			uAns += Math.max(a1, a2);
		}
		
		return dp[node][x] = uAns;
	}

	static class Pair {
		long x;
		long y;

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

	

	

	

	

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
","import java.util.*;
import java.io.*;

public class Solution {

    static LinkedList<Integer> graph[];
    static long key[][];
    static long value[][];

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

        Scanner in = new Scanner(System.in);
        StringBuffer out=new StringBuffer();
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int t=Integer.parseInt(br.readLine());
        String input[];

        OUTER:
        while(t--!=0) {

            int n=Integer.parseInt(br.readLine());

            value=new long[n][2];
            key=new long[n][2];

            for(int i=0; i<n; i++) {
                input= br.readLine().split(""\\s"");
                for(int j=0; j<2; j++) {
                    key[i][j] = Integer.parseInt(input[j]);
                }
            }

            graph=new LinkedList[n];
            for(int i=0; i<n; i++)
                graph[i]=new LinkedList();

            for(int i=1; i<n; i++) {
                input= br.readLine().split(""\\s"");
                int u=Integer.parseInt(input[0])-1, v=Integer.parseInt(input[1])-1;
                graph[u].add(v);
                graph[v].add(u);
            }

            int root=-1;
            for(int i=0; i<n; i++)
                if(graph[i].size()==1) {
                    root=i;
                    break;
                }

            solve(root, -1);

            out.append(Math.max(value[root][0], value[root][1])+""\n"");
        }

        System.out.print(out);
    }

    private static void solve(int vertex, int parent) {

        for(int child: graph[vertex]) {
            if(child!=parent) {
                solve(child, vertex);
                for(int i=0; i<2; i++) {
                    long max=Long.MIN_VALUE;
                    for(int j=0; j<2; j++) {
                        max=Math.max(max, Math.abs(key[vertex][i]-key[child][j])+value[child][j]);
                    }
                    value[vertex][i]+=max;
                }
            }
        }

//        System.out.println(vertex+"" ""+Arrays.toString(key[vertex])+"" ""+Arrays.toString(value[vertex]));
    }
}
",0,Non-plagiarised
40cc90ae,51151974,"import javax.swing.text.html.parser.Entity;
import java.io.*;
import java.util.*;
import java.math.BigInteger;


public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{

        double eps= 0.00000001;
        static final int MAXN = 1010;
        static final int MOD= 1000000007;

        // stores smallest prime factor for every number
        static int spf[] = new int[MAXN];

        static boolean[] prime;

        // Calculating SPF (Smallest Prime Factor) for every
        // number till MAXN.
        // Time Complexity : O(nloglogn)
        

        

        // function to find first index >= x
        
        

        // function to find last index <= y
        
        

        // function to count elements within given range
        

        

        public int add(int a, int b){
            a+=b;
            if(a>=MOD) a-=MOD;
            else if(a<0) a+=MOD;
            return a;
        }

        

        

        int[] fact= new int[MAXN];
        int[] inv= new int[MAXN];

        

        

        

        /**
         * return VALUE of lower bound for unsorted array
         */
        
        /**
         * return VALUE of upper bound for unsorted array
         */
        

        

        

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

        

    }

    



    

    

    // public static class compareL implements Comparator<Tuple>{
    //     @Override
    //     public int compare(Tuple t1, Tuple t2) {
    //         return t2.l - t1.l;
    //     }
    // }

    // fast input reader class;
    
}
","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
    
}
",0,Non-plagiarised
a7e7f371,ad4c7a20,"import java.io.*;
import java.util.*;


public class cp {
	static int mod=(int)1e9+7;
	
//	static  Reader sc=new Reader();
	static FastReader sc=new FastReader(System.in);
	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...
 */
	
	
	
	
	
	
	
	
	
	
	
    
     
	
	
	
          
	
	
	
	
	 
	// Array to store inverse of 1 to N
	 
	// Array to precompute inverse of 1! to N!
	 
	// Array to store factorial of first N numbers
	 
	// Function to precompute inverse of numbers
	
	 
	// Function to precompute inverse of factorials
	
	 
	// Function to calculate factorial of 1 to N
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
	
	
	
		
	


	

	//function to find prime factors of n
	
	

	//fenwick tree implementaion
	

	
	

	
	
	
	//Function to find number of set bits
	
 
	
	
	
	
	
	
	
	
	
	
	
	

	
	
	
	
	
	
	
	  
	
	
	 
	
	
	  
	
	
	
	
	
	
	
	
	
	    // function to find last index <= y
    
    
     
	
	 
	 
	
	 
	 

	 

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


	
	
//	 static long modInverse(long a, long m)
//		    {
//		        long g = gcd(a, m);
//		       
//		          return   power(a, m - 2, m);
//		        
//		    }
	
	
	 
	 

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

}
","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
		protected Pair clone() throws CloneNotSupportedException {
			return new Pair(this.x,this.y);
		}
		
		
	}
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
",1,Plagiarised
0f6ca337,6843cc19,"import java.io.*;
import java.util.*;
 
import java.math.*;
import java.awt.Point;
 
public class Main {
    static final long MOD = 1000000007L;
    //static final long MOD2 = 1000000009L;
    //static final long MOD = 998244353L;
    //static final long INF = 500000000000L;
    static final int INF =   1000000005;
    static final int NINF = -1000000005;
    //static final long INF = 1000000000000000000L;
    static FastScanner sc;
    static PrintWriter pw;
    static final int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
 
    public static void main(String[] args) {
        sc = new FastScanner();
        pw = new PrintWriter(System.out);
 
 
        int Q = sc.ni();
        for (int q = 0; q < Q; q++) {
            int N = sc.ni();
            int[] nums = sc.intArray(N,0);
            Integer[] less = new Integer[N];
            Integer[] more = new Integer[N];
            TreeSet<Integer> ts = new TreeSet<Integer>();
            for (int i = 0; i < N; i++) {
                ts.add(nums[i]);
                less[i] = ts.lower(nums[i]);
                more[i] = ts.higher(nums[i]);
            }
            
            String ans = ""YES"";
            for (int i = 1; i < N; i++) {
                if (nums[i-1]==nums[i]) continue;
                
                if (nums[i-1] < nums[i]) {
                    if (more[i-1]!=null && more[i-1] < nums[i]) {
                        ans = ""NO"";
                        break;
                    }
                } else {
                    if (less[i-1]!=null && less[i-1] > nums[i]) {
                        ans = ""NO"";
                        break;
                    }
                }
            }
            pw.println(ans);
        }
        pw.close(); 
    }
    
 
    
 
    
 
    //Sort an array (immune to quicksort TLE)
    public static void sort(int[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            int[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<int[]>() {
            
        });
    }
    
    public static void sort(long[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            long[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<long[]>() {
            
        });
    }
 
    
}
","import java.io.*;
import java.util.*;
 
import java.math.*;
import java.awt.Point;
 
public class Main {
    static final long MOD = 1000000007L;
    //static final long MOD2 = 1000000009L;
    //static final long MOD = 998244353L;
    //static final long INF = 500000000000L;
    static final int INF =   1000000005;
    static final int NINF = -1000000005;
    //static final long INF = 1000000000000000000L;
    static FastScanner sc;
    static PrintWriter pw;
    static final int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
 
    public static void main(String[] args) {
        sc = new FastScanner();
        pw = new PrintWriter(System.out);
 
 
        int Q = sc.ni();
        for (int q = 0; q < Q; q++) {
            int N = sc.ni();
            int[] nums = sc.intArray(N,0);
            Integer[] less = new Integer[N];
            Integer[] more = new Integer[N];
            TreeSet<Integer> ts = new TreeSet<Integer>();
            for (int i = 0; i < N; i++) {
                ts.add(nums[i]);
                less[i] = ts.lower(nums[i]);
                more[i] = ts.higher(nums[i]);
            }
            
            String ans = ""YES"";
            for (int i = 1; i < N; i++) {
                if (nums[i-1]==nums[i]) continue;
                
                if (nums[i-1] < nums[i]) {
                    if (more[i-1]!=null && more[i-1] < nums[i]) {
                        ans = ""NO"";
                        break;
                    }
                } else {
                    if (less[i-1]!=null && less[i-1] > nums[i]) {
                        ans = ""NO"";
                        break;
                    }
                }
            }
            pw.println(ans);
        }
        pw.close(); 
    }
    
 
    
 
    
 
    //Sort an array (immune to quicksort TLE)
    public static void sort(int[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            int[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<int[]>() {
            
        });
    }
    
    public static void sort(long[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            long[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<long[]>() {
            
        });
    }
 
    
}
",1,Plagiarised
120878da,ac180326,"import java.util.*;
import java.lang.*;
import java.io.*;

public class codeforces
{
    
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		FastReader sc=new FastReader();
		int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		    int m=sc.nextInt();
		    int x=sc.nextInt();
		    PriorityQueue<pair> pq=new PriorityQueue<>(new myComp());
		    myarr a[]=new myarr[n];
		    int b[]=new int[n];
		  //  int c[]=new int[m];
		    for(int i=0;i<n;i++)
		    {
		        a[i]=new myarr(sc.nextInt(),i);
		    }
		    Arrays.sort(a,new mycom());
		    for(int i=0;i<m;i++)
		    {
		        pq.add(new pair(a[i].val,i+1));
		      //  c[i]=a[i].val;
		        b[a[i].ii]=i+1;
		    }
    		StringBuffer sb=new StringBuffer();
		    boolean flag=false;
		    if(m!=1)
		    {
    		    for(int i=m;i<n;i++)
    		    {
    		        pair p=pq.poll();
    		        int g=p.b;
    		        int h=pq.peek().b;
    		        if(Math.abs((g+a[i].val)-h)<=x)
    		        {
    		            b[a[i].ii]=p.t;
    		            pq.add(new pair(g+a[i].val,p.t));
    		        }
    		        else
    		        {
    		            flag=true;
    		            break;
    		        }
    		    }
    		    if(flag)
    		    System.out.println(""NO"");
    		    else
    		    {
    		        System.out.println(""YES"");
    		        for(int i=0;i<n;i++)
    		        {
    		            sb.append(b[i]+"" "");
    		        }
    		        System.out.println(sb.toString());
    		    }
		    }
		    else
		    {
    		    System.out.println(""YES"");
    		    for(int i=0;i<n;i++)
    		    {
    		        sb.append(""1 "");
    		    }
    		    System.out.println(sb.toString());
		    }
		}
	}
	static class pair
	{
	    int b;
	    int t;
	    pair(int b,int t)
	    {
	        this.b=b;
	        this.t=t;
	    }
	}
	static class myComp implements Comparator<pair>
	{
	    
	}
	static class myarr
	{
	    int val,ii;
	    myarr(int val,int ii)
	    {
	        this.val=val;
	        this.ii=ii;
	    }
	}
	static class mycom implements Comparator<myarr>
	{
	    
	}
}
","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;
		}

		

		

	}

	

	
}
",0,Non-plagiarised
1eda0725,80881cae,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int k[]=new int[n];
            int h[]=new int[n];
            for(int i=0;i<n;i++)
            {
                k[i]=input.nextInt();
            }
            for(int i=0;i<n;i++)
            {
                h[i]=input.nextInt();
            }
            ArrayList<int []> list=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                int p=k[i]-h[i]+1;
                if(list.size()==0) list.add(new int[]{p,k[i]});
                else
                {
                    while(list.size()>0)
                    {
                        int j=list.size()-1;
                        int a[]=list.get(j);
                        int l=a[0],r=a[1];
                        int l1=p,r1=k[i];
                        if(l1>r)
                        {
                            list.add(new int[]{l1,r1});
                            break;
                        }
                        else if(l1>=l && l1<=r)
                        {
                            list.remove(j);
                            list.add(new int[]{l,r1});
                            break;
                        }
                        else
                        {
                            list.remove(j);
                        }
                    }
                    if(list.size()==0) list.add(new int[]{p,k[i]});
                }
            }
            long sum=0;
            for(int i=0;i<list.size();i++)
            {
                long d=list.get(i)[1]-list.get(i)[0]+1;
                long val=d*(d+1)/2;
                sum+=val;
            }
            out.println(sum);
        }
        out.close();
    }
    
}
","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);
		}
		
//		public void swap()
//		{
//			this.y=this.y+this.x;
//			this.x=this.y-this.x;
//			this.y=this.y-this.x;			
//		}
	}
}
",0,Non-plagiarised
4548305b,be3b1289,"import java.util.function.Consumer;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.io.*;
import java.lang.Math.*;

 public class KickStart2020{
	
	
	
	
	 
	
	
	
	
	 
	 
	 
	 
		public static void main(String[] args) throws Exception{
			FastReader sc = new FastReader();
			PrintWriter out = new PrintWriter(System.out);
          int t = sc.nextInt();
          while(t-- > 0) {
           int n = sc.nextInt();
           int k = sc.nextInt();
           int arr[] = new int[k];
           int temp[] = new int[k];
           for(int i = 0; i < k; i++) arr[i] = sc.nextInt();
           for(int i = 0; i < k; i++) temp[i] = sc.nextInt();
           long brr[] = new long[n];
           Arrays.fill(brr, Integer.MAX_VALUE);
           for(int i = 0; i < k; i++) brr[arr[i] - 1] = temp[i];
           for(int i = 1; i < n; i++) {
        	   brr[i] = Math.min(brr[i], brr[i - 1] + 1);
           }
           for(int i = n - 2; i >= 0; i--) {
        	   brr[i] = Math.min(brr[i], brr[i + 1] + 1);
           }
           for(long e: brr) out.print(e + "" "");
           out.println();
             
          }
                 out.close();
			}
		}
","import java.util.*;
import java.lang.*;
import java.io.*;


public class cf {
    static PrintWriter out;
    static FastReader scan;

    /*-------- I/O using short named function ---------*/
    

    public static int ni() {
        return scan.nextInt();
    }

    

    

    

    

    

    

    /*-------- for output of an array ---------------------*/
    

    static void lPA(long 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();
    }

    

    

    

    /*------------ for taking input faster ----------------*/
    

    

    // Method to check if x is power of 2
    

    //Method to return lcm of two numbers
    

    //Method to count digit of a number
    

    

    static final Random random = new Random();

    //Method for sorting
    

    

    //Method for checking if a number is prime or not
    

    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
0d4d22e0,d20e861b,"import java.util.*;
public class CodeForces {
	static ArrayList<String>res;
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int test = input.nextInt();
		while(test-->0){
			int n = input.nextInt();
			int m = input.nextInt();
			char arr[][] = new char[n][m];
			res = new ArrayList<>();
			for(int i =0;i<n;i++){
				for(int j =0;j<1;j++){
					arr[i] = input.next().toCharArray();
				}
			}
			for(int i =0;i<n-1;i++){
				for(int j =0;j<m-1;j++){
					int count =0;
					if(arr[i+1][j] == '1')count++;
					if(arr[i][j+1] == '1')count++;
					if(arr[i][j] == '1')count++;
					if(arr[i+1][j+1] == '1')count++;
					if(count == 0)continue;
					if(count == 1)one(arr,i,j);
					if(count == 2)two(arr,i,j);
					if(count == 3)three(arr,i,j);
					if(count == 4)four(arr,i,j);
				}
			}
			System.out.println(res.size());
			for(String it:res)System.out.println(it);
		}	
	}
	public static void one(char arr[][],int i,int j){
		int row = i+2;
		int col = j+2;
		int count =0;
		StringBuilder sb = new StringBuilder();
		for(int x=i;x<row;x++){
			for(int y = j;y<col;y++){
				if(arr[x][y] == '1' ){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '0';
					sb.append("" "");
				}else if(arr[x][y] == '0' && count<2){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '1';
					sb.append("" "");
					count++;
				}
			}
		}
		res.add(sb.toString());
		two(arr,i,j);
	}
	public static void two(char arr[][],int i,int j){
			int row = i+2;
			int col = j+2;
			boolean ok = true;
			StringBuilder sb = new StringBuilder();
			for(int x=i;x<row;x++){
				for(int y = j;y<col;y++){
					if(arr[x][y] == '1' && ok){
						sb.append(x+1);
						sb.append("" "");
						sb.append(y+1);
						arr[x][y] = '0';
						sb.append("" "");
						ok = false;
					}else if(arr[x][y] == '0'){
						sb.append(x+1);
						sb.append("" "");
						sb.append(y+1);
						arr[x][y] = '1';
						sb.append("" "");
					}
				}
			}
			res.add(sb.toString());
			three(arr,i,j);
		}
	public static void three(char arr[][],int i,int j){
		StringBuilder sb = new StringBuilder();
		if(arr[i][j] == '1'){
			sb.append(i+1);
			sb.append("" "");
			sb.append(j+1);
			arr[i][j] = '0';
			sb.append("" "");
		}
		if(arr[i+1][j] == '1'){
			sb.append(i+2);
			sb.append("" "");
			sb.append(j+1);
			arr[i+1][j] = '0';
			sb.append("" "");
		}
		if(arr[i][j+1] == '1'){
			arr[i][j+1] ='0';
			sb.append(i+1);
			sb.append("" "");
			sb.append(j+2);
			sb.append("" "");
		}
		if(arr[i+1][j+1] == '1'){
			arr[i+1][j+1] = '0';
			sb.append(i+2);
			sb.append("" "");
			sb.append(j+2);
		}
		res.add(sb.toString());
	}
	public static void four(char arr[][],int i,int j){
		int row = i+2;
		int col = j+2;
		int count =0;
		StringBuilder sb = new StringBuilder();
		for(int x=i;x<row;x++){
			for(int y = j;y<col;y++){
				if(count<3){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '0';
					sb.append("" "");
					count++;
				}
			}
		}
		res.add(sb.toString());
		one(arr,i,j);
	}
}
","import java.util.*;

public class CodeForces{
// 4
//   -3 -5 -2 1
// k  2  4  0 3
static ArrayList<int[]> ans = new ArrayList<>();
    
    public static void add(int a,int b,int c,int d,int e,int f){
        int[] tem=new int[6];
        tem[0]=a;tem[1]=b;tem[2]=c;tem[3]=d;tem[4]=e;tem[5]=f;
        ans.add(tem);
    }
   public static void helper(int[][] arr,int r,int c){
       for(int k=0;k<12;k++){
           if(arr[r][c]==1){
               add(r,c,r+1,c,r,c+1);
               arr[r][c]=1-arr[r][c];
               arr[r+1][c]=1-arr[r+1][c];
               arr[r][c+1]=1-arr[r][c+1];
           }
           if(arr[r][c+1]==1){
                add(r,c+1,r+1,c+1,r,c);
               arr[r][c+1]=1-arr[r][c+1];
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r][c]=1-arr[r][c];
           }
           if(arr[r+1][c]==1){
                add(r+1,c+1,r,c,r+1,c);
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r][c]=1-arr[r][c];
               arr[r+1][c]=1-arr[r+1][c];
           }
           if(arr[r+1][c+1]==1){
                add(r+1,c+1,r+1,c,r,c+1);
               arr[r+1][c+1]=1-arr[r+1][c+1];
               arr[r+1][c]=1-arr[r+1][c];
               arr[r][c+1]=1-arr[r][c+1];
           }
           
       }
       
   } 
   public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
		    int n = sc.nextInt();
		    int m = sc.nextInt();
		    ans.clear();
		    int[][] arr=new int[n][m];
		    for(int i=0;i<n;i++){
		        String str = sc.next();
		        for(int j=0;j<m;j++){
		            arr[i][j]=str.charAt(j)-'0';
		        }
		    }
		    
		    for(int i=0;i<n;i+=2){
		        for(int j=0;j<m;j+=2){
		            if(i==n-1&&j==m-1){
		                helper(arr,i-1,j-1);
		            }else if(i==n-1){
		                helper(arr,i-1,j);
		            }else if(j==m-1){
		                helper(arr,i,j-1);
		            }else{
		                helper(arr,i,j);
		            }
		            
		        }
		    }
		    System.out.println(ans.size());
		    for(int[] move:ans){
		        for(int i=0;i<6;i++){
		            System.out.print(move[i]+1 +"" "");
		        }
		        System.out.println();
		    }
		  //  for(int i=0;i<n;i++){
		        
		  //      for(int j=0;j<m;j++){
		  //          System.out.print(arr[i][j] +"" "");
		  //      }
		  //      System.out.println();
		  //  }	
		
		    
		}   
		
		
        
	}
}
",0,Non-plagiarised
403e3270,58d18fca,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;

//import sun.nio.fs.RegistryFileTypeDetector;


 
public class Codeforces {
	static int mod= 998244353;
	
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
		FastScanner fs=new FastScanner();
		int t=fs.nextInt();
		
		outer:while(t-->0) {
			int n=fs.nextInt();
			int arr[]=fs.readArray(n);
			int l=0, r=1000000000;
			while(l<r) {
				int mid=(l+r+1)/2;
				if(check(arr,mid)) {
					l=mid;
				}
				else r=mid-1;
			}
			out.println(l);
			
//			System.out.println(check(arr,13));
			
		}
		
		out.close();
		
	}
	static boolean check(int arr[],int min) {
		int n=arr.length;
		int brr[]=new int[n];
		for(int i=n-1;i>1;i--) {
			if(brr[i]+arr[i]<min) return false;
			int cur= Math.min(arr[i], arr[i]+brr[i]-min);
//			System.out.println(cur+"" "");
			int d=cur/3;
//			System.out.println(d);
			brr[i-1]+=d;
			brr[i-2]+=2*d;
		}
		
		return (arr[0]+brr[0]>=min)&&(arr[1]+brr[1]>=min);
	}
	
	
	
	
	
	
	
	
	
	// Use this to input code since it is faster than a Scanner
	
 
}
","import java.io.*;
import java.util.*;

public class Main {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		PrintWriter out = new PrintWriter(System.out);

		/******  CODE STARTS HERE  *****/
		//--------------------------------------------------------------------------------------------------------
		int t = fs.nextInt();
		while(t-->0) {
			int n = fs.nextInt();
			int[] h = fs.readArray(n);
			int l=1, r=(int)1e9;
			int ans = -1;
			while(l<=r) {
				int mid = (l+r)/2;
				if(isPossible(mid, h, n)) {
					ans = mid;
					l = mid+1;
				}else {
					r= mid-1;
				}
			}
			out.println(ans);
		}
		out.close();
	}
	
	static boolean isPossible(int min, int[] h, int n) {
		int[] c = new int[n];
		for(int i=n-1; i>=2; i--) {
			
			if(h[i]+c[i]-min<0)return false;
			
			int x  = Math.min(h[i], h[i]+c[i]-min) / 3;
			c[i-1] += x;
			c[i-2] += 2*x;
		}
		
		return (h[0]+c[0]>=min&&h[1]+c[1]>=min);
	}
    
	//******  CODE ENDS HERE  *****
	//----------------------------------------------------------------------------------------------------------------
	
	
	
	
	//----------- FastScanner class for faster input---------------------------
	
}
",1,Plagiarised