filename_1,filename_2,code_1,code_2,labels,notes
51151974,c23278ec,"import java.io.*;
import java.util.*;
 public class Solution{
    public static void main (String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        int testCase = sc.nextInt();
        while (testCase-->0){
            int n = sc.nextInt();
            String[] strArr = new String[n];
            for(int i=0; i<n; i++) {
                strArr[i]=sc.nextLine();
            }
            int[] total = new int[5];
            ArrayList<int[]> al = new ArrayList<>();
            for(int i=0; i<n; i++){
                int[] arr= new int[5];
                for(int j=0; j<strArr[i].length(); j++){
                    arr[strArr[i].charAt(j)-'a']++;
                }
                for(int j=0; j<5; j++){
                    total[j]+=arr[j];
                }
                al.add(arr);
            }
            int ans=0;
            for(int i=0; i<5; i++){
                ArrayList<Integer> all = new ArrayList<>();
                for(int j=0; j<n; j++){
                    all.add(strArr[j].length()-2*al.get(j)[i]);
                }
                java.util.Collections.sort(all);
                int c=0, d=0;
                for(int j=0; j<n; j++){
                    c+=all.get(j);
                    if(c<0) d=j+1;
                }
                ans = Math.max(ans,d);
            }
            System.out.println(ans);
        }
    }
    // Fast Reader Class
    
}
","import java.io.*;
import java.sql.Array;
import java.util.*;

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

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

    

}
",0,Non-plagiarised
13441e8f,141effef,"import java.util.*;

public class Armchairs {

	public static int findMinTime(List<Integer> zeros, List<Integer> ones) {
		if (ones.size() == 0)
			return 0;
		int oneSize = ones.size();
		int zeroSize = zeros.size();
		int [][] time = new int [oneSize + 1][zeroSize + 1];
		for (int i=1; i<=oneSize; i++) {
			time[i][i] = time[i - 1][i - 1] + Math.abs(ones.get(i - 1) - zeros.get(i - 1));
			for (int j=i+1; j<=zeroSize; j++) {
				time[i][j] = Math.min(time[i][j - 1], time[i - 1][j - 1] + 
					Math.abs(ones.get(i - 1) - zeros.get(j - 1)));
			}
		}
		return time[oneSize][zeroSize];
	}

	public static void main (String [] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		List<Integer> zeros = new ArrayList<>();
		List<Integer> ones = new ArrayList<>();
		for (int i=0; i<n; i++) {
			int number= sc.nextInt();
			if (number == 1)
				ones.add(i);
			else
				zeros.add(i);
		}
		System.out.println(findMinTime(zeros, ones));
	}
}
","import java.util.*;

public class ArmChairs {
	static int[]arr;
	static ArrayList<Integer>a;
	static ArrayList<Integer>b;
	static int dp[][];
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		arr=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=scn.nextInt();
		}
		dp=new int[n+1][n+1];
		a =new ArrayList<>();
		b =new ArrayList<>();
		for(int i=0;i<n;i++) {
			if(arr[i]==0) {
				a.add(i);
			}else{
				b.add(i);
			}
		}
		System.out.println(solve(0,0));	
	}
	
	public static int solve(int i,int j) {
		if(i==b.size()) {
			return 0;
		}
		if(j==a.size()) {
			return 100000000;
		}

		if(dp[i][j]!=0) {
			return dp[i][j];
		}
		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
		int y=solve(i,j+1);
		return dp[i][j]=Math.min(x, y);
	}
	

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

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

	
	public static void main(String[] args) throws java.lang.Exception {
		FastReader fr = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int t = fr.ni();
		while(t-->0) {
			
			int n = fr.ni();
			long arr [] = new long[n];
			for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
			long even = arr[0];
			long odd = arr[1];
			long minEven = arr[0];
			long minOdd = arr[1];
			long ans = (minEven*n) + (minOdd*n);
			for(int i = 2 ; i < n ; i++) {
				if((i&1) == 0) {
					even += arr[i];
					minEven = Math.min(minEven, arr[i]);
					long a = (i+2)/2;
					long b = (i+1)-a;
					long temp = (even + (minEven*(n - a)));
					temp += (odd + (minOdd*(n - b)));
					ans = Math.min(ans, temp);
				}else {
					odd += arr[i];
					minOdd = Math.min(minOdd, arr[i]);
					long a = (i+2)/2;
					long b = (i+1)-a;
					long temp = (even + (minEven*(n - a)));
					temp += (odd + (minOdd*(n - b)));
					ans = Math.min(ans, temp);
					
				}
			}
			out.println(ans);
		}
		out.close();
	}
}
","import java.util.*;
public class ss
{
    public static void main(String[]args)
    {
        Scanner in=new Scanner (System.in);
        int t=in.nextInt();
        for(int i1=0;i1<t;i1++)
        {
            int n=in.nextInt();
	
	long[] ar=new long[n];
	
	for(int i=0;i<n;i++)
	{
		ar[i]=in.nextLong();
		
	}
	
	long[] ans=new long[n];
	ans[0]=ar[0]*n;
	long m=ar[0];
	long s1=ar[0];
	for(int i=2;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);
 
		
 
 
	}
	ans[1]=ar[1]*n;
	 m=ar[1];
	 s1=ar[1];
	for(int i=3;i<n;i+=2)
	{
		if(m>ar[i])
		{
			m=ar[i];
		}
		s1+=ar[i];
		ans[i]=s1-m+m*(n-i/2);
	}
	long mini=ans[0]+ans[1];
	for(int i=1;i<n-1;i++)
	{
		mini=Math.min(ans[i]+ans[i+1],mini);
	}
	System.out.println(mini);
}
}
}
",0,Non-plagiarised
01b911ac,a195911e,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.TreeMap;
import java.util.PriorityQueue;
import java.util.Collections;
import java.util.Stack;

import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Iterator;

public class First {

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

            solve(fs);
        }
        
    }
    static void solve(FastScanner fs)
    {
        int n=fs.nextInt();
        long[] times=takeLong(n, fs);
        long[] damage=takeLong(n, fs);
        long reqTime=times[n-1]-damage[n-1]+1;
        long ans=0;
        for(int i=n-1;i>=0;)
        {
            reqTime=times[i]-damage[i]+1;
            long time=times[i];
            i--;    
            while(i>=0 && times[i]>=reqTime)
            {
                long thisReqTime=times[i]-damage[i]+1;
                reqTime=Math.min(reqTime, thisReqTime);
                i--;
            }
            long x=time-reqTime+1;
            // pn(x);
            ans+=(x*(x+1)/2);



        }
        pn(ans);
    }
    static long MOD=(long)(1e9+7);
    
    
    static void pn(Object o) { System.out.println(o); } 
    
    

    
    
    
    
    static long[] takeLong(int n, FastScanner fs)
    {
        long[] arr=new long[n];
        for(int i=0;i<n;++i)
            arr[i]=fs.nextLong();
        return arr;
    } 
     
     
     
    
    
    
    
    


}

","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
4dc0247e,875ed4c8,"import java.io.*;
import java.util.*;


public class ComdeFormces {
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		FastReader sc=new FastReader();
		BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
		int t=sc.nextInt();
		while(t--!=0) {
			int n=sc.nextInt();
//			int m=sc.nextInt();
		    ArrayList<ArrayList<pair>> ar=new ArrayList<>();
		    ArrayList<pair> arr=new ArrayList<>();
		    int c[]=new int[n];
		    for(int i=0;i<=n;i++) {
		    	ar.add(new ArrayList<>());
		    }
		    for(int i=0;i<n-1;i++) {
		    	int a=sc.nextInt();
		    	int b=sc.nextInt();
		    	ar.get(a).add(new pair(b,i));
		    	ar.get(b).add(new pair(a,i));
		    	
		    }
		    boolean ans=true;
		    for(int i=0;i<=n;i++) {
		     if(ar.get(i).size()>2) {
		    	 ans=false;
		    	 break;
		     }  	
		    }
		    if(ans) {
		    
		       for(int i=1;i<=n;i++) {
		    	   if(ar.get(i).size()==1) {
		    		   boolean vis[]=new boolean[n+1];
		    		   dfs(ar,2,i,vis,c);
		    		   break;
		    	   }
		       }
		       for(int i=0;i<n;i++) {
		    	   if(c[i]!=0)log.write(c[i]+"" "");
		       }
		    }
		    else log.write(""-1"");
		    
		     log.write(""\n"");
		     log.flush();
			}
		}
	
		
static void dfs(ArrayList<ArrayList<pair>>ar ,int val,int src,boolean vis[],int c[]) {
	if(vis[src])return;
	vis[src]=true;
	for(int i=0;i<ar.get(src).size();i++) {
		if(!vis[ar.get(src).get(i).a]) {
			c[ar.get(src).get(i).b]=val;
			if(val==2) {
				dfs(ar,3,ar.get(src).get(i).a,vis,c);
			}
			else {
				dfs(ar,2,ar.get(src).get(i).a,vis,c);
			}
		}
	}
}	
	
	
	
		

		
		


	
	
		
	

	
	
	
	
	
	
	
	
	
	
//utils
 
 
	
	
	
	
public static class pair{
	int a;
	int b;
	public pair(int a,int b) {
		this.a=a;
		this.b=b;
	}
	
	
}	


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


public class Main
{
    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	public static void main (String[] args) throws java.lang.Exception
	{
		FastReader sc = new FastReader();
		
		int t = sc.nextInt();
		while(t-->0){
		    
		    solve(sc);

		    
		}
		
	}
	
	
	public static void solve(FastReader sc){

	    int n = sc.nextInt();
	    
	    ArrayList<ArrayList<Edge>> graph = new ArrayList<ArrayList<Edge>>();
	    for(int i = 0;i<n;++i){
	        graph.add(new ArrayList<>());
	    }
	    for(int i = 0;i<n-1;++i){
	        int u = sc.nextInt();
	        int v = sc.nextInt();
	        
	        u--;
	        v--;
	        
	        graph.get(u).add(new Edge(v, i));
	        graph.get(v).add(new Edge(u, i));
	        
	        
	    }
	    
	    int start = 0;
	    for(int i = 0;i<n;++i){
	        if(graph.get(i).size()>2){
	            out.println(-1);out.flush();return;
	        }else if(graph.get(i).size()==1){
	            start=i;
	        }
	    }
	    
	    int val=2;
	    int [] wgt = new int[n-1];

	    int curr = graph.get(start).get(0).node;
	    
	    wgt[graph.get(start).get(0).idx] = val;
	    
	    val=5;
	    
	    while(true){
	        ArrayList<Edge> list = graph.get(curr);
	        if(list.size()==1){
	            break;
	        }else{
	            for(Edge el : list){
	                if(wgt[el.idx]==0){
	                    wgt[el.idx] = val;
	                    val = 7-val;
	                    curr = el.node;
	                }
	            }
	            
	        }
	        
	    }
	    
	    
	    for(int el : wgt){
	        out.print(el + "" "");
	    }
	    out.println();
	    out.flush();
	    
	}
	
	
	
	
	
	
	static class Edge {
      int node;
      int idx;

      Edge(int src, int nbr) {
         this.node = src;
         this.idx = nbr;
      }
   }
	/*
	int [] arr = new int[n];
	for(int i = 0;i<n;++i){
	    arr[i] = sc.nextInt();
	}
	*/
	
	
		
}
",0,Non-plagiarised
476e94d3,9310ad0c,"import java.util.*;
import java.io.*;
import java.math.BigInteger;
 
public class code2{
 
    
    
    
    //@SuppressWarnings(""unchecked"")
    public static void main(String[] arg) throws IOException{
        //Reader in=new Reader();
        
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner(System.in);
        
        int t=in.nextInt();
        
        while(t-- > 0){
           int n=in.nextInt();
           long[] k=new long[n];
           long[] h=new long[n];

           for(int i=0;i<n;i++) k[i]=in.nextLong();
           for(int i=0;i<n;i++) h[i]=in.nextLong();

           long[] res=new long[n];
           long[] power=new long[n];
           long l=k[n-1]+1,r=-1;

           for(int i=0;i<n;i++){
             long lc=k[i]-h[i]+1;
             //out.println(""lc:""+lc);
             long m=h[i];
             if(lc<=l){
               res[i]=(m*(m+1))/2;
               power[i]=h[i];
             }
             else if(lc>r){
               //out.println(m);
               res[i]=res[i-1]+(m*(m+1))/2;
               power[i]=h[i];
             }
             else{
               res[i]=Long.MAX_VALUE;
               
               for(int j=i-1;j>=0;j--){
                 
                if(power[j]+k[i]-k[j] >= h[i]){
					
                   long x=power[j]+k[i]-k[j];
				   
                   if(x>=h[i]){
					  if(k[i]-h[i]+1>k[j]){
						power[i]=h[i];
						res[i]=res[j]+(m*(m+1))/2;
					  } 
					  else{
						power[i]=x;
						long c=(x*(x+1))/2;
						long d=(power[j]*(power[j]+1))/2;
						res[i]=res[j]+c-d;
					  }
					  break;
				   }

                 }

               }
             }
             l=Math.min(l,lc);
             r=k[i];
             
           }

           out.println(res[n-1]);
        }
 
        out.flush();
    }
 
}
","import java.io.*;
import java.util.*;

public class Main{

    
    
    


    

    

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


    FastReader sc = new FastReader();
    
   int t=sc.nextInt();

   
  while(t-->0)
  {
      int n=sc.nextInt();

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

      long h[]=new long[n];
      for(int i=0;i<n;i++)
      {
          h[i]=sc.nextLong();
      }
      ArrayList<Long> al=new ArrayList<>();
      long csp=h[n-1],idx=k[n-1]-h[n-1];
      for(int i=n-2;i>=0;i--)
      {
          if(idx<k[i])
          {
              if(k[i]-idx<h[i])
              {
                  long diff=h[i]-(k[i]-idx);
                  csp+=diff;
                  idx-=diff;
              }
          }
          else
          {
              al.add(csp);
              csp=h[i];
              idx=k[i]-csp;
          }
         

      }

      long sum=0;
      al.add(csp);
      for(long i:al)
      {
         sum=sum+((i*(i+1))/2);
      }

      System.out.println(sum);
     
  }
}
}
",0,Non-plagiarised
1dab88fb,bac616ee,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class NotAssigning {
	
	
	
	static class Pair {
		
		int a, b;

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

	}
	
	static boolean vis[];
	public static void dfs(ArrayList<ArrayList<Pair>> t, int cur, boolean mode, int[] w) {
		vis[cur] = true;
		for (Pair p : t.get(cur)) {
			if (!vis[p.a]) {
				if (mode) {
					w[p.b] = 3;
				}
				else {
					w[p.b] = 2;
				}
				dfs(t, p.a, !mode, w);
			}
		}
	}
	
	public static void solve(int n, int[] u, int[] v) {
		
		ArrayList<ArrayList<Pair>> t = new ArrayList<ArrayList<Pair>>(n);
		for (int i=0; i<n; i++) {
			t.add(new ArrayList<Pair>());
		}
		for (int i=0; i<n-1; i++) {
			t.get(u[i]).add(new Pair(v[i], i));
			t.get(v[i]).add(new Pair(u[i], i));
		}
		int start = 0;
		for (int i=0; i<n; i++) {
			if (t.get(i).size() > 2) {
				System.out.println(""-1"");
				return;
			}
			if (t.get(i).size() == 1) {
				start = i;
			}
		}
		vis = new boolean[n];
		int[] w = new int[n-1];
		dfs(t, start, false, w);
		StringBuilder ans = new StringBuilder();
		for (int i=0; i<n-1; i++) {
			ans.append(w[i]).append("" "");
		}
		System.out.println(ans);
		
	}

	public static void main(String[] args) {
		
		FastReader in = new FastReader();
		int t = in.nextInt();
		while (t-- > 0) {
			int n = in.nextInt();
			int[] u = new int[n-1];
			int[] v = new int[n-1];
			for (int i=0; i<n-1; i++) {
				u[i] = in.nextInt()-1;
				v[i] = in.nextInt()-1;
			}
			solve(n, u, v);
		}

	}

}
",0,Non-plagiarised
3368f340,d8a171a3,"import java.io.*;
import java.util.*;

public class Menorah {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();
        StringBuilder sb = new StringBuilder();
        while (t-->0){
            int n = sc.nextInt();
            char[] a = sc.next().toCharArray();
            char[] b = sc.next().toCharArray();

            int a1=0, b1=0;
            for(int i=0;i<n;i++){
                if(a[i]=='1')
                    a1++;
                if(b[i]=='1')
                    b1++;
            }

            int min = 100000000;

            if(a1==b1){
                int c = 0;
                for(int i=0;i<n;i++){
                    if(a[i]!=b[i])
                        c++;
                }

                min = Math.min(min, c);
            }

            if(b1==(n-a1+1)){
                int ind = -1;
                for(int i=0;i<n;i++){
                    if(a[i]==b[i] && a[i]=='1'){
                        ind = i;
                        break;
                    }
                }

                int c = 0;
                for(int i=0;i<n;i++){
                    if(i==ind)
                        continue;

                    if(a[i]==b[i])
                        c++;
                }

                min = Math.min(min, c + 1);
            }

            if(min == 100000000)
                sb.append(""-1\n"");
            else sb.append(min).append(""\n"");
        }

        System.out.println(sb);

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

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

}
",0,Non-plagiarised
51cc7026,e81b2d16,"import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class C_Balanced_Stone_Heaps {
	
	
    public static int t, n;
    public static int H[];
	private static long startTime = System.currentTimeMillis();
	public static void main(String[] args) {
		FastReader sc =new FastReader();
		t = sc.nextInt();
        while (t-->0) {
            n = sc.nextInt();
            H = new int[n];
            int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
			for (int i = 0; i < n; i++) {
                H[i] = sc.nextInt();
                max = Math.max(H[i], max);
                min = Math.min(H[i], min);
            }
            int mid = 0;
            while (min < max) {
                mid = min + (max-min+1)/2;
                if(check(mid)) {
                    min = mid;
                }
                else max = mid-1;
            }			

            System.out.println(min);
        }

	}

    public static boolean check(int x){
        int S[] = Arrays.copyOf(H, H.length);
        for (int i = n-1; i >= 2; i--) {
            if(S[i]<x) return false;

            int move = Math.min(S[i]-x, H[i])/3;
            if(i>=2){
                // S[i]-=move*3;
                S[i-1]+=(move);
                S[i-2]+=2*(move);
            }
        }
        return S[0]>= x && S[1] >= x;
    }

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

public class fastTemp {
    

    static int n;
    static int arr[];
    public static void main(String[] args)
    {
        FastReader fs = new FastReader();
        int t = fs.nextInt();
        while(t-- >0){
               n = fs.nextInt();
               arr = new int[n];
              int max = Integer.MIN_VALUE;
              for(int i=0;i<n;i++){
                arr[i] = fs.nextInt();
                  if(max<arr[i]){
                      max =arr[i];
                  }
              }
              int l=1;
              int r = max;
              int ans = 0;
              while(l<r){
                  int mid = l + (r-l+1)/2;
                  if(check(mid)){
                  l = mid;
                  }else{
                      r = mid-1;
                  }
              }
            System.out.println(l);
        }

    }
static int min = Integer.MAX_VALUE;
    public static boolean check(int x){

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

       // Collections.copy(curr,arr);

        for(int i=n-1;i>=2;i--){
           if(ar[i]<x){
               return false;
           }
           int d = (Math.min(arr[i],ar[i]-x))/3;
          ar[i-1] += d;
          ar[i-2] += 2*d;
        }

        return ar[0]>=x && ar[1]>=x;
    }


}
",1,Plagiarised
0df4050e,d9199dfd,"import java.io.*;
import java.util.*;

public class MainClass {
    public static void main(String[] args) {
        Reader in = new Reader(System.in);
        int t = in.nextInt();
        StringBuilder stringBuilder = new StringBuilder();
        while (t-- > 0) {
            ArrayList<Integer> reds = new ArrayList<>();
            ArrayList<Integer> blue = new ArrayList<>();
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt() - 1;
            }
            char[] s = in.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (s[i] == 'R') {
                    reds.add(a[i]);
                } else {
                    blue.add(a[i]);
                }
            }
            Collections.sort(reds, Collections.reverseOrder());
            Collections.sort(blue);
            boolean ff = true;
            int start = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < start) {
                    ff = false;
                    break;
                }
                start++;
            }
            start = n - 1;
            for (int i = 0; i < reds.size(); i++) {
                if (reds.get(i) > start) {
                    ff = false;
                    break;
                }
                start--;
            }
            stringBuilder.append(ff?""YES"":""NO"").append(""\n"");
        }
        System.out.println(stringBuilder);
    }
}

","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",1,Plagiarised
df594a00,fcbe7917,"import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int cases = Integer.parseInt(br.readLine());
		while(cases-- > 0) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}
","import java.io.*;
import java.util.*;

public class E_Air_Conditioners{

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

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

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

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

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

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

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

            Arrays.fill(ans,Integer.MAX_VALUE);

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



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

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

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

        }

    }
}
",0,Non-plagiarised
3ff60986,d0b4b96c,"import java.io.*;
import java.util.*;

public class Main {
    
    static int N = (int)2e5 +10;
    static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
    static
    {
        for(int i=0; i<N; i++)
        {
            adj.add(new ArrayList<>());
        }
    }
    static int[][] a = new int[2][N];

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

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

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


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


        }
    }





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

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


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

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

public class Main {
    
    static int N = (int)2e5 +10;
    static ArrayList<ArrayList<Integer>> adj= new ArrayList<>(N);
    static
    {
        for(int i=0; i<N; i++)
        {
            adj.add(new ArrayList<>());
        }
    }
    static int[][] a = new int[2][N];

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

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

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


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


        }
    }





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

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


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

    }
}
",1,Plagiarised
1230c43e,ce0b2178,"import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static boolean[] primecheck = new boolean[1000002];

    public static void main(String[] args) throws IOException {
        OutputStream outputStream = System.out;
        FastReader in = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        PROBLEM solver = new PROBLEM();
        int t = 1;
        t = in.nextInt();
        for (int i = 0; i < t; i++) {
            solver.solve(in, out);
        }
        out.close();
    }

    static class PROBLEM {

        public void solve(FastReader in, PrintWriter out) {

            int n = in.nextInt();
            int[] a = in.readArray(n);
            char[] c = in.nextLine().toCharArray();
            int cur = 1;

            ArrayList<Pair> p = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                p.add(new Pair(c[i], a[i]));
            }

            Collections.sort(p);
//            for (int i = 0; i < n; i++) {
//                out.println(p.get(i).x + "" "" + p.get(i).y);
//            }

            for (int i = 0; i < n; i++) {
                if(p.get(i).x == 'B' && p.get(i).y < i+1){
                    out.println(""NO"");
                    return;
                }
                if(p.get(i).x == 'R' && p.get(i).y > i+1){
                    out.println(""NO"");
                    return;
                }
            }

            out.println(""YES"");

//            int n = in.nextInt(), m = in.nextInt();
//            char[] s = in.nextLine().toCharArray();
//
//            int rl = 0, ud = 0, r = 0 , l = 0, rlf = 0, udf = 0;
//            int lmax = 0, rmax = 0, umax = 0, dmax = 0;
//
//            for (int i = 0; i < s.length; i++) {
//                if(s[i] == 'L'){
//                    if(rlf == 0) rlf = -1;
//                    rl--;
//                    l--;
//                    if(rl == 0) l = 0;
//                    if(rl < 0 && lmax+rmax <= m) lmax = Math.max(Math.abs(l), lmax);
//                }
//                if(s[i] == 'R'){
//                    if(rlf == 0) rlf = 1;
//                    rl++;
//                    r++;
//
//                    if(rl > 0 && lmax+rmax <= m) rmax = Math.max(r, rmax);
//                }
//                if(s[i] == 'U'){
//                    if(udf == 0) udf = 1;
//                    ud++;
//                    r = Math.max(Math.abs(ud), r);
//                    if(ud > 0 && umax+dmax <= n) umax = Math.max(Math.abs(ud), umax);
//                }
//                if(s[i] == 'D'){
//                    if(udf == 0) udf = -1;
//                    ud--;
//                    r = Math.max(Math.abs(ud), r);
//                    if(ud < 0 && umax+dmax <= n) dmax = Math.max(Math.abs(ud), dmax);
//                }
//            }
//
//            int ansc = 0, ansr = 0;
//
//            out.println(rlf + ""  lmx = "" + lmax + "" rmax"" + rmax);
//
//            if(rlf == 1) ansc = m-rmax;
//            else if(rlf == -1) ansc = 1+lmax;
//            else ansc = 1;
//
//            if(udf == 1) ansr = 1+umax;
//            else if(udf == -1) ansr = m-dmax;
//            else ansr = 1;
//
//            out.println(ansr + "" "" + ansc);

        }
    }

    

    

    

    

    

    

    

    

    


    static class Pair implements Comparable<Pair>{

        char x;
        int y;

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

        
    }

    

//    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
//        public U x;
//        public V y;
//
//        public Pair(U x, V y) {
//            this.x = x;
//            this.y = y;
//        }
//
//        public int hashCode() {
//            return (x == null ? 0 : x.hashCode() * 31) + (y == null ? 0 : y.hashCode());
//        }
//
//        public boolean equals(Object o) {
//            if (this == o)
//                return true;
//            if (o == null || getClass() != o.getClass())
//                return false;
//            Pair<U, V> p = (Pair<U, V>) o;
//            return (x == null ? p.x == null : x.equals(p.x)) && (y == null ? p.y == null : y.equals(p.y));
//        }
//
//        public int compareTo(Pair<U, V> b) {
//            int cmpU = x.compareTo(b.x);
//            return cmpU != 0 ? cmpU : y.compareTo(b.y);
//        }
//
//        public int compareToY(Pair<U, V> b) {
//            int cmpU = y.compareTo(b.y);
//            return cmpU != 0 ? cmpU : x.compareTo(b.x);
//        }
//
//        public String toString() {
//            return String.format(""(%s, %s)"", x.toString(), y.toString());
//        }
//
//    }

    

    

    

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

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

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

		
	}
	
	public static void main(String[] args)throws IOException {
		
		FastScanner scan = new FastScanner();
		PrintWriter output = new PrintWriter(System.out);
		int t = scan.nextInt();
		for(int tt = 0;tt<t;tt++) {
			
			int n = scan.nextInt();
			int arr[] = scan.readArray(n);
			char line[] = scan.next().toCharArray();
			ArrayList<Pair> pairs = new ArrayList<Pair>();
			for(int i = 0;i<n;i++) {
				pairs.add(new Pair(arr[i], line[i]));
			}
			Collections.sort(pairs);
			boolean possible = true;
			for(int i = 1;i<=n;i++) {
				if(pairs.get(i-1).a == i) {
					continue;
				}
				else if(pairs.get(i-1).a < i && pairs.get(i-1).b == 'R') {
					continue;
				}
				else if(pairs.get(i-1).a > i && pairs.get(i-1).b == 'B') {
					continue;
				}
				else {
					possible = false;
					break;
				}
			}
			output.println(possible == true ? ""YES"" : ""NO"");
		}
		output.flush();

	}
	
	public static int[] sort(int arr[]) {
		List<Integer> list = new ArrayList<>();
		for(int i:arr) list.add(i);
		Collections.sort(list);
		for(int i = 0;i<list.size();i++) arr[i] = list.get(i);
		return arr;
	}
	
	
	
	
	
	
	
	

}
",0,Non-plagiarised
9f354c5c,a6532df9,"import java.util.*;

import java.io.*;
import java.math.*;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;



public class Solution {
	 
	  
	 
	  static long mod = (long)(1e9 + 7);
	 
	
	
	
	

	
	
	 
	 

	 
	   
	   
	 
	   
     
	      
	      
	      
	      
	      
	      
	      
	      
/************************************************ Query **************************************************************************************/	  
	 
/***************************************** 		Sparse Table	********************************************************/
	      
	      
	      
/********************************************************	Segement Tree	*****************************************************/
/**
	 	 static class SegmentTree{
			 long[] tree;
			 long[] arr;
			 int n;
			 SegmentTree(long[] arr){
				 this.n = arr.length;
				 tree = new long[4*n+1];
				 this.arr = arr;
				 buildTree(0, n-1, 1);
			 }
			 
			 
			  void buildTree(int s ,int e  ,int index ) {
					if(s == e) {
						tree[index] = arr[s];
						return;
					}
				
					int mid = (s+e)/2;
					
					buildTree( s,  mid, 2*index);
					buildTree( mid+1, e, 2*index+1);
					
					tree[index] = Math.min(tree[2*index] , tree[2*index+1]);
				}
			  
			 long query(int si ,int ei) {
				 return query(0 ,n-1 , si ,ei , 1   );
			 }
			 private long query( int ss ,int se ,int qs , int qe,int index) {
					
					if(ss>=qs && se<=qe) return tree[index];
					
					if(qe<ss || se<qs) return (long)(1e17);
					
					int mid = (ss + se)/2;
					long left = query( ss , mid , qs ,qe , 2*index);
					long right= query(mid + 1 , se , qs ,qe , 2*index+1);
					return Math.min(left, right);
				}
			 public void update(int index , int val) {
				 arr[index] = val;
				 for(long e:arr) System.out.print(e+"" "");
				 update(index , 0 , n-1 , 1);
			 }
			 private void update(int id ,int si , int ei , int index) {
				 if(id < si || id>ei) return;
				 if(si == ei ) { 
					 tree[index] = arr[id];
					 return;
				 }
				 if(si > ei) return;
				 int mid = (ei + si)/2;
					
					update( id,  si, mid , 2*index);
					update( id , mid+1, ei , 2*index+1);
					
					tree[index] = Math.min(tree[2*index] ,tree[2*index+1]);
			 }
			  
		 }
		 */

/* ***************************************************************************************************************************************************/	 
	 
//	      static MyScanner sc = new MyScanner(); // only in case of less memory
	      static Reader sc = new Reader();
	 static StringBuilder sb = new StringBuilder();
	 public static void main(String args[]) throws IOException {

		 int tc = 1;
		  tc = sc.nextInt();

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

//			 sb.append(""Case #"" + i + "": ""  );	// During KickStart && HackerCup
			 TEST_CASE();
			  
		 }
		 System.out.println(sb);
	 }

	 static void TEST_CASE() {
		int n = sc.nextInt();
		ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
		for(int i =0 ; i<n ; i++) adj.add(new ArrayList<>());
		int[] U = new int[n-1] , V = new int[n-1];
		for(int i = 0 ; i<n-1 ; i++) {
			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
			U[i] = u; V[i] = v;
			adj.get(u).add(v);
			adj.get(v).add(u);
		}
		int ind = -1;
		for(int i =0 ; i<n ; i++) {
			if(adj.get(i).size()>2) {
				sb.append(""-1\n"");
				return;
			}
			if(adj.get(i).size() == 1) {
				ind = i;
			}
		}
		Map<String , Integer> map = new HashMap<>();
		dfs(adj, ind, -1, true, map);
		for(int i =0 ; i<n-1 ; i++) {
		 int u = U[i];
		 int v = V[i];
		 if(map.containsKey(u+"" ""+v)) sb.append(map.get(u+"" ""+v)+"" "");
		 else sb.append(map.get(v+"" ""+u)+"" "");
		}
		sb.append(""\n"");
		
	 }
	 static void dfs(ArrayList<ArrayList<Integer>> adj ,int u , int p ,boolean eve ,Map<String , Integer> map ) {
		 if(eve) {
			 map.put(u+"" ""+p, 2);
		 }else {
			 map.put(u+"" ""+p, 3);
		 }
		 for(int v:adj.get(u)) {
			 if(v == p) continue;
			 eve = !eve;
			 dfs(adj, v, u, eve, map);
		 }
	 }
	}
","import java.io.*;
import java.util.*;
public class new1{
	
	
	public static void dfs(ArrayList<ArrayList<int[]> > aList1, int p, int u, int[] ans, int v) {
		int[] aa = aList1.get(u).get(0);
		if(aa[0] != p) {
			ans[aa[1]] = v;
			if(v == 2) dfs(aList1, u, aa[0], ans, 3);
			else dfs(aList1, u, aa[0], ans, 2);
		}
		else if(aList1.get(u).size() > 1){
			aa = aList1.get(u).get(1);
			ans[aa[1]] = v;
			if(v == 2) dfs(aList1, u, aa[0], ans, 3);
			else dfs(aList1, u, aa[0], ans, 2);
		}
		
		
	}
	
	public static void main(String[] args)  throws IOException{

		
		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		FastReader s = new FastReader();
		int t = s.nextInt();
		for(int z = 0; z < t; z++) {
			int n = s.nextInt();
			ArrayList<ArrayList<int[]> > aList1 =  new ArrayList<ArrayList<int[]> >(n + 1);
			
	        for (int j = 1; j <= n + 1; j++) { 
	            ArrayList<int[]> list = new ArrayList<>();
	            aList1.add(list);
	        }
		
			for(int j = 0; j < n - 1; j ++) {
				int u = s.nextInt();
				int v = s.nextInt();
				int[] aa = {v, j};
				int[] bb = {u, j};
				aList1.get(u).add(aa);
				aList1.get(v).add(bb);
			}
			int pos = 1; int ind = -1;
			for(int i = 1; i <= n; i++) {
				if(aList1.get(i).size() > 2) {
					pos = 0;
					break;
				}
				if(aList1.get(i).size() == 1) {
					ind = i;
				}
			}
			if(pos == 0) {
				output.write(-1 + ""\n"");
			}
			else {
				int[] ans = new int[n - 1];
				dfs(aList1, -1, ind, ans, 2);
				for(int i = 0; i < n - 1; i++) {
					output.write(ans[i] + "" "");
				}
				output.write(""\n"");
			}
			
			
			
		}
	   output.flush();
	  }
}


 
	
",0,Non-plagiarised
8703709f,d2901569,"import java.io.*;
import java.util.*;

public class Main {

//	static boolean[] prime = new boolean[10000000];
	final static long mod = 1000000007;

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

		int t = in.nextInt();
		while (t-- > 0) {
			int n = in.nextInt();

			Integer[] k = intInput(n, in), h = intInput(n, in);
			long ans = 0;
			int a = k[n - 1];
			int current = k[n - 1];
			for (int i = n - 1; i >= 0; i--) {
				if (current > k[i]) {
					ans += sum(a - current + 1);
					a = k[i];
					current = k[i]-h[i]+1;
				}else {
					current = Math.min(current, k[i] - h[i]+1);
				}
			}
			ans += sum(a - current + 1);
			out.println(ans);
		}

		out.flush();
	}

	static long sum(long a) {
		return a * (a + 1) / 2;
	}

	

	

	

	static Integer[] intInput(int n, InputReader in) {
		Integer[] a = new Integer[n];
		for (int i = 0; i < a.length; i++)
			a[i] = in.nextInt();
		return a;
	}

	

	

//	static void sieve() {
//		for (int i = 2; i * i < prime.length; i++) {
//			if (prime[i])
//				continue;	
//			for (int j = i * i; j < prime.length; j += i) {
//				prime[j] = true;
//			}
//		}
//	}

}








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


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

		Scanner sc=new Scanner(System.in);
		int tt=sc.nextInt();
//		
//		
		while(tt-->0){
				int n=sc.nextInt();
			
				int k[]=new int[n];
				int h[]=new int[n];
				
				for(int i=0;i<n;i++) {
					k[i]=sc.nextInt();
				}
				for(int i=0;i<n;i++) {
					h[i]=sc.nextInt();
				}
				long ans=0;
				int start=k[0]-h[0]-1;
				int end=k[0];
				int last=0;
				for(int j=0;j<n;j++) {
					 start=k[j]-h[j]+1;
					 end=k[j];
					 last=j;
				for(int i=j+1;i<n;i++) {
					int temp=k[i]-h[i]+1;
					
					if(temp<=end) {
						start=Math.min(start, temp);
						end=Math.max(end, k[i]);
						last=i;
					}
					
					
					
				}
				j=last;
				
				long va=end-start+1;
				
				ans+=(va*(va+1))/2;
				
				}
				System.out.println(ans);
				
			
		}
	}
		
		
	
		
		
	
	
	


}
",0,Non-plagiarised
161b4a40,49e94e7e,"import java.util.*;
import java.io.*;

public class Main{
    static final Random random=new Random();
    static long mod=1000000007L;
    static HashMap<String,Integer>map=new HashMap<>();

    
    
    public static void main(String[] args) {
        try {
            FastReader in=new FastReader();
            FastWriter out = new FastWriter();
            int testCases=in.nextInt();
            //int testCases=1;
            while(testCases-- > 0){
                solve(in);
            }
            out.close();
        } catch (Exception e) {
            return;
        }
    }
    public static void solve( FastReader in){
        int n=in.nextInt();
        String s=in.next();
        String t=in.next();
        //int k=in.nextInt();
        //long y=in.nextInt();
        //long n=in.nextLong();
        //int k=in.nextInt();
        //long k=in.nextLong();
        StringBuilder res=new StringBuilder();
        char[] s1=s.toCharArray();
        char[] t1=t.toCharArray();
        int ans=n+2;
        int[] cnt={0,0};
        for(int i=0;i<n;i++){
            if(s1[i]=='0' && t1[i]=='1'){
                cnt[0]++;
            }
            if(s1[i]=='1' && t1[i]=='0'){
                cnt[1]++;
            }
        }
        if(cnt[0]==cnt[1])ans=Math.min(ans,cnt[0]+cnt[1]);
        cnt[0]=cnt[1]=0;
        for(int i=0;i<n;i++){
            if(s1[i]=='0' && t1[i]=='0'){
                cnt[0]++;
            }
            if(s1[i]=='1' && t1[i]=='1'){
                cnt[1]++;
            }
        }
        if(cnt[1]==cnt[0]+1){
            ans=Math.min(ans,cnt[0]+cnt[1]);
        }
        if(ans>n){
            res.append(""-1"");
        }
        else{
            res.append(""""+ans);
        }
        //int ans=x.size()+y.size();
        //res.append(""""+""Yes"");
        //res.append(""""+"""");
        System.out.println(res.toString());
    }
    
    

    
    

    

    
    static < E > void print(E res)
    {
        System.out.println(res);
    }
    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	
	
	

	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
			
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   
			
			
			
			
			
			
			   
				
		   
		   
		
			   /*
			    * 
			    * >=         <=
			   0 1 2 3 4 5 6 7  
			   5 5 5 6 6 6 7 7
			   lower_bound for 6 at index 3 (>=)
			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
			   */

		   
		   
			
			
			
			
			
	
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out); 
		
		int tt = sc.nextInt();
		while(tt-- > 0)
		{
	       int n = sc.nextInt();
	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
	       
	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
	       for(int i = 0;i<n;i++)
	       {
	    	   if(a[i] == '0' && b[i] == '0')
	    	   {
	    		   c00++;
	    	   }
	    	   else if(a[i] == '0' && b[i] == '1')
	    	   {
	    		   c01++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '0')
	    	   {
	    		   c10++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '1')
	    	   {
	    		   c11++;
	    	   }
	       }
	       
	       int ans = mod;
	       if(c01 == c10) ans = min(ans, c01 + c10);
	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
	       
	       fout.println((ans == mod) ? -1 : ans);
		}
		
		fout.close();
	}
}
",0,Non-plagiarised
547ee69b,5ce1fe32,"import java.util.Arrays;
import java.util.Scanner;

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

        int[] a = new int[n];

        for(int i=0; i<n; i++) {
            a[i] = in.nextInt();
        }

        System.out.println(getMinimumTime(a, n));
    }

    public static int getMinimumTime(int[] a, int n) {
        int[][] minTime = new int[n][n];
        int[] posOfPerson = new int[n];

        int totalOccupied = 0;
        for(int i=0; i<n; i++) {
            if(a[i] == 1) {
                posOfPerson[totalOccupied] = i;
            }
            totalOccupied += a[i];
        }

        for(int i=0; i<n; i++) {
            Arrays.fill(minTime[i], 1, n, Integer.MAX_VALUE);
        }

        if(a[0] == 0) {
            minTime[0][1] = Math.abs(0-posOfPerson[0]);
        }

        int unoccupiedPlaces = 1-a[0];
        for(int i=1; i<n; i++) {
            if(a[i] == 0) {
                unoccupiedPlaces++;
            }

            for(int j=1; j<=Math.min(totalOccupied, unoccupiedPlaces); j++) {
                if(a[i] == 1) {
                    minTime[i][j] = minTime[i-1][j];
                }
                else if(j == unoccupiedPlaces) {
                    minTime[i][j] = minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]);
                }
                else {
                    minTime[i][j] = Math.min(minTime[i-1][j], minTime[i-1][j-1] + Math.abs(i-posOfPerson[j-1]));
                }
            }
        }

        return minTime[n-1][totalOccupied];
    }
}
","import java.io.*;
import java.util.*;

public class D{

    static long[][] dp;
    static List<Integer> seats,people;
    static int n1,n2;

    static long solve(int i,int j){
        
        if(i==n1) return 0;
        long ans = Integer.MAX_VALUE;
        if(n1-i>n2-j) return ans;
        if(dp[i][j]!=-1) return dp[i][j];
        
        ans = Math.min(solve(i,j+1),solve(i+1,j+1)+Math.abs(people.get(i)-seats.get(j)));
        // out.printf(""%d %d : %ld"",i,j,ans);
        return dp[i][j]=ans;
    }

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

        int n=sc.nextInt();
        
        seats = new ArrayList<>(n/2);
        people = new ArrayList<>(n/2);

        for(int i=1;i<=n;i++){
            if(sc.nextInt()==0){
                seats.add(i);
            }else{
                people.add(i);
            }
        }

        n1=people.size();
        n2=seats.size();

        // if(n2==n){
        //     out.println(0);
            
        // }

        dp = new long[n1][n2]; 
        for(int i=0;i<n1;i++)
        Arrays.fill(dp[i],-1);

        long ans =solve(0,0);
        out.println(ans);

        out.close();
    }
    


    


    

    

    
    

    static FastScanner sc = new FastScanner();
    static PrintWriter out =new PrintWriter(System.out);

    
}
",0,Non-plagiarised
49e94e7e,fcc7e8fa,"import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	
	
	

	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
			
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   
			
			
			
			
			
			
			   
				
		   
		   
		
			   /*
			    * 
			    * >=         <=
			   0 1 2 3 4 5 6 7  
			   5 5 5 6 6 6 7 7
			   lower_bound for 6 at index 3 (>=)
			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
			   */

		   
		   
			
			
			
			
			
	
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out); 
		
		int tt = sc.nextInt();
		while(tt-- > 0)
		{
	       int n = sc.nextInt();
	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
	       
	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
	       for(int i = 0;i<n;i++)
	       {
	    	   if(a[i] == '0' && b[i] == '0')
	    	   {
	    		   c00++;
	    	   }
	    	   else if(a[i] == '0' && b[i] == '1')
	    	   {
	    		   c01++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '0')
	    	   {
	    		   c10++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '1')
	    	   {
	    		   c11++;
	    	   }
	       }
	       
	       int ans = mod;
	       if(c01 == c10) ans = min(ans, c01 + c10);
	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
	       
	       fout.println((ans == mod) ? -1 : ans);
		}
		
		fout.close();
	}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class Main {

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

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

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

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

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

    

    

    

    

    

    

    static final Random random=new Random();

    

    
}
",0,Non-plagiarised
35f0c004,efa38999,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            String a=input.next();
            String b=input.next();
            int same1=0,same0=0,opp1=0,opp0=0;
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)==b.charAt(i))
                {
                    if(a.charAt(i)=='1') same1++;
                    else same0++;
                }
                else
                {
                    if(a.charAt(i)=='1') opp1++;
                    else opp0++;
                }
            }
            if(same0+same1==n)
            {
                out.println(0);
            }
            else
            {
                int x=same1+opp1;
                int y=same1+opp0;
                int z=same0+opp0;
                if(x==y || (z+1)==y)
                {
                    int min=Integer.MAX_VALUE;
                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
                    {
                        min=Math.min(min,same0+same1);
                    }
                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
                    {
                        min=Math.min(min,opp0+opp1);
                    }
                    out.println(min);
                }
                else
                {
                    out.println(-1);
                }
            }
        }
        out.close();
    }
    
}
","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();
            String a = reader.nextLine();
            String b = reader.nextLine();
            ans  = -1;

            int even_demand = 0;
            int odd_demand = 0;
            int same_ones = 0, same_zeros = 0;
            int diff_ones = 0, diff_zeros = 0;
            for(int i=0; i<n; i++){
                if(a.charAt(i)==b.charAt(i)){
                    even_demand++;
                    if(a.charAt(i)=='1'){
                        same_ones++;
                    }else{
                        same_zeros++;
                    }
                }else{
                    odd_demand++;
                    if(a.charAt(i)=='1'){
                        diff_ones++;
                    }else{
                        diff_zeros++;
                    }
                }
            }

            // System.out.println(even_demand+"" ""+same_ones+"" ""+same_zeros+"" ""+odd_demand+"" ""+diff_ones+"" ""+diff_zeros);
            if(even_demand%2==1 && same_ones==same_zeros+1){
                ans = even_demand;
            }
            if(odd_demand%2==0 && diff_ones==diff_zeros){
                if(ans==-1){
                    ans = odd_demand;
                }else{
                    ans = Math.min(ans, odd_demand);
                }
            }
            sb.append(ans + ""\n"");
        }
        System.out.println(sb);
    }
}
",0,Non-plagiarised
ac180326,d1cd194e,"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;
		}

		

		

	}

	

	
}
","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
a7063d01,ac4d0fc5,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

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

    

    

    

    

    

    

    

    

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

    static long m = 0;

    
    
    
    
    

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

    
    
    
    
    

    static long max1 = 0;

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

    static boolean possible;

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

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

    
  
    

    

    

    

    

    

    

    

    

    

    

    

     

    

    

    

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

public class Main {
    static boolean[] ret;
    static boolean[] updated;
    static ArrayList<Integer>[] adjacencyList;
    static Edge[] edgeList;
    static class Edge {
        int start, end, number;
        public Edge (int _start, int _end, int _number) {
            start = _start;
            end = _end;
            number = _number;
        }
    }
    public static void dfs(int node) {
        updated[node] = true;
        for (int next : adjacencyList[edgeList[node].start]) {
            if (!updated[next]) {
                ret[next] = !ret[node];
                dfs(next);
            }
        }
        for (int next : adjacencyList[edgeList[node].end]) {
            if (!updated[next]) {
                ret[next] = !ret[node];
                dfs(next);
            }
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int numCases = Integer.parseInt(br.readLine());
        for (int i = 0; i < numCases; i++) {
            int numVertices = Integer.parseInt(br.readLine());
            int[] numEdges = new int[numVertices];
            edgeList = new Edge[numVertices - 1];
            adjacencyList = new ArrayList[numVertices];
            for (int j = 0; j < numVertices; j++) {
                adjacencyList[j] = new ArrayList<>();
            }
            for (int j = 0; j < numVertices - 1; j++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                int a = Integer.parseInt(st.nextToken()) - 1;
                int b = Integer.parseInt(st.nextToken()) - 1;
                edgeList[j] = new Edge(a, b, j);
                numEdges[a]++;
                numEdges[b]++;
                adjacencyList[a].add(j);
                adjacencyList[b].add(j);
            }
            boolean good = true;
            for (int j = 0; j < numVertices; j++) {
                if (numEdges[j] > 2) {
                    good = false;
                    break;
                }
            }
            if (!good) {
                pw.println(-1);
            } else {
                ret = new boolean[numVertices - 1];
                updated = new boolean[numVertices - 1];
                dfs(0);
                for (boolean b : ret) {
                    if (b)
                        pw.print(5 + "" "");
                    else
                        pw.print(2 + "" "");
                }
                pw.println();
            }
        }
        br.close();
        pw.close();
    }
}
",0,Non-plagiarised
1162c08f,a4d6775d,"import java.util.*;

public class CodeForces1525C{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.io.*;
import java.util.*;
 
public class ArmChairs {
    
 
    public static int solution(int n, int[] arr) {
 
        ArrayList<Integer> one = new ArrayList<Integer>();
        ArrayList<Integer> zero = new ArrayList<Integer>();
 
        for (int i = 0; i < n; i++) {
            if (arr[i] == 1) {
                one.add(i);
            } else {
                zero.add(i);
            }
        }
 
        int[][] dp = new int[one.size() + 1][zero.size() + 1];
 
        for (int i = 1; i <= one.size(); i++) {
            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
            for (int j = i + 1; j <= zero.size(); j++) {
                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
            }
        }
 
        return dp[one.size()][zero.size()];
    }
 
 
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int n = Integer.parseInt(br.readLine());
 
        String[] s = br.readLine().split("" "");
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(s[i]);
        } 
 
        log.write(Integer.toString(solution(n, arr)) + ""\n"");
        log.flush();
        
    }
 
}
",1,Plagiarised
9fc811f7,cff39394,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;


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

    static class DTreeTag {
        int diam = 0;

        public int dfs(ArrayList<Integer> g[], int x, int depth[], int p) {
            int len = 0;
            for (int y : g[x]) {
                if (y != p) {
                    depth[y] = depth[x] + 1;
                    int cur = 1 + dfs(g, y, depth, x);
                    diam = Math.max(diam, cur + len);
                    len = Math.max(len, cur);
                }
            }
            return len;
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            int da = in.nextInt();
            int db = in.nextInt();
            int dis[] = new int[n];
            ArrayList<Integer> g[] = new ArrayList[n];
            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
            for (int i = 0; i < n - 1; i++) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;
                g[u].add(v);
                g[v].add(u);
            }
            diam = 0;
            dfs(g, a, dis, -1);
            int disb = dis[b];
            if (2 * da >= Math.min(diam, db) || disb <= da) {
                out.println(""Alice"");
            } else {
                out.println(""Bob"");
            }

        }

    }

    
}
","import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class D {
	static int diam=0;
	public static int dfs(int a, int p,int[] depth,ArrayList<Integer>[] list) {
		int len=0;
		for(int y:list[a]) {
			if(y==p)
				continue;
			depth[y]=depth[a]+1;
			int cur=1+dfs(y,a,depth,list);
			diam=Math.max(cur+len,diam);
			len=Math.max(cur, len);
		}
		return len;
	}

	public static void main(String[] args) {
		MyScanner s = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		try {
		int t=s.nextInt();
		while(t-->0) {
		int n=s.nextInt();
		int a=s.nextInt();
		int b=s.nextInt();
		int da=s.nextInt();
		int db=s.nextInt();
		ArrayList<Integer>[] list=new ArrayList[n+1];
		for(int i=0;i<=n;i++)
			list[i]=new ArrayList<Integer>();
		for(int i=0;i<n-1;i++) {
			int u=s.nextInt();
			int v=s.nextInt();
			list[u].add(v);
			list[v].add(u);
		}
		int[] depth=new int[n+1];
		diam=0;
		depth[a]=0;
		int dia=dfs(a,0,depth,list);
		if(2*da>=Math.min(diam, db) || depth[b]<=da) {
			System.out.println(""Alice"");
		}
		else {
			System.out.println(""Bob"");
		}
		}
		out.close();
		}catch(Exception e) {
			System.out.println(e);
			return;
		}
	}
	
	public static PrintWriter out;
	
	
	

}
",1,Plagiarised
00af3420,86102d81,"import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }

    
}
","import java.io.*;
import java.util.*;
		
	public class Aqueous {
		
		
		static MyScanner sc = new MyScanner();
			
		public static void main(String[] args) {
			
			int t = sc.nextInt();
			
				while(t-->0) {
					
					int n = sc.nextInt();
					
						String s[] = new String[n];
						
							for(int i = 0; i<n; i++) {
								s[i] = sc.next();
							}
							
							int ans = Integer.MIN_VALUE;
							
							for(char c = 'a'; c<='e'; c++) {
								
								int ls[] = new int[n];
								
									for(int i = 0; i<n; i++) {
										
										String temp = s[i];
										int delta = 0;
										
											for(int j = 0; j<temp.length(); j++) {
												if(temp.charAt(j)==c) {
													delta++;
												}
												else {
													delta--;
												}
											}
											
											ls[i] = delta;
									}
									
									Arrays.sort(ls);
									
									int cur = 0;
									int score= 0;
									
									for(int k = n-1; k>=0; k--) {
										if(cur+ls[k]>=1) {
											cur+=ls[k];
											score++;
										}
									}
									
									ans = Math.max(ans, score);
							}
							
							System.out.println(ans);
						
				}
		}
		
		
		
		
		

		
		
	    
	}
",0,Non-plagiarised
1162c08f,734a94be,"import java.util.*;

public class CodeForces1525C{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   
	  
	    
	 
	   
	
	   
	     
	   public static void main(String args[]) throws Exception { 
		
		   Scanner sc = new Scanner();
		   StringBuffer res = new StringBuffer();
		   
		   int tc = 1;
		   
		   while(tc-->0) { 
			
			    int n = sc.nextInt();
			    
			    ArrayList<Integer> one = new ArrayList<>();
			    ArrayList<Integer> zero = new ArrayList<>();
			    
			    for(int i=0;i<n;i++) { 
			    	
			    	int x = sc.nextInt();
			    	
			    	if(x==1) { 
			    		one.add(i);
			    	}
			    	else { 
			    		zero.add(i);
			    	}
			    }
			    
			    int dp[][] = new int[one.size()+1][zero.size()+1];
			    
			     for(int i=1;i<=one.size();i++)
			     {
			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
			         for(int j=i+1;j<=zero.size();j++)
			         {
			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
			         }
			     }
			     System.out.println(dp[one.size()][zero.size()]);
		   }
			System.out.println(res);
	   }
}
",1,Plagiarised
163d0dde,f87eb1b3,"import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.*;
  
public class aa
{ 
     
   
    public static void main(String[] args) 
    {
            FastReader d=new FastReader();
            int t,i,j,c,z,k,l,n;
            int mod = (int) 1e9 + 7;
            int Inf=Integer.MAX_VALUE;
            int negInf=Integer.MIN_VALUE;
        t=d.nextInt();
        //t=1;
        //String s;
        //char ch,ch1,ch2,ch3;
        while(t-->0)
        {
            z=c=0;
            n=d.nextInt();
            int a[]=new int[n];
            for(i=0;i<n;i++)
            a[i]=d.nextInt();
            //s=d.nextLine();//dont need extra d.nextLine()
            long p=0;
            long ans;
            long x,y;
            long e,o;
            ans=Long.MAX_VALUE;
            x=y=Integer.MAX_VALUE;
            e=o=n;
            for(i=0;i<n;i++) {
                if(i%2==1) {
               	p+=a[i];
               	e--;
               	x=Long.min(x, a[i]);
               	ans=Long.min(ans,p+(o*y)+(e*x));
               	}
               	else {
               	p+=a[i];
               	o--;
               	y=Long.min(y, a[i]);
               	ans=Long.min(ans,p+(o*y)+(e*x));
                	}
                }
                System.out.println(ans);
        }
    } 
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.PrintStream;
import java.io.PrintWriter;
public class A {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	

	
	
	
	
	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
		
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		
		
		
		
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   /*
		    * 
		    * >=         <=
		   0 1 2 3 4 5 6 7  
		   5 5 5 6 6 6 7 7
		   lower_bound for 6 at index 3 (>=)
		   upper_bound for 6 at index 6(To get six reduce by one) (<=)
		   */
		
		   
		
		   
					
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out);
		
		int t = sc.nextInt();
		while(t-- > 0)
		{
			long INF = 1000000000000000007L;
			int n = sc.nextInt();
			
			long[] c = new long[n+1];
			for(int i = 1;i<=n;i++) c[i] = sc.nextLong();
			
			long ans = INF;
			long mo = INF,  so = 0, co = 0;
			long me = INF,  se = 0, ce = 0;
			
			for(int i=1;i<=n;i++)
			{
				if(i%2 == 1)
				{
					mo = min(mo,c[i]);
					so += c[i];
					co++;
				}
				else
				{
					me = min(me,c[i]);
					se += c[i];
					ce++;
				}
				if(i>=2)
				{
					long x = so + (n - co) * mo + se + (n - ce) * me;
					ans=min(ans,x);
				}
			}
			fout.println(ans);
		}
			
		fout.close();
	}
}
",0,Non-plagiarised
0922b7e7,d1cd194e,"import java.io.*;
import java.util.*;

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

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

		out.close();
		in.close();
	}
	
	public static class Tower implements Comparable<Tower> {
		int idx, size;
		public Tower(int idx, int size) {
			this.idx = idx;
			this.size = size;
		}
		
	}
}
","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
4303de0d,c9a316ca,"import java.io.*;
import java.util.*;
public class ParsasHumongousTree
{
    
    
    static class Pair
    {
    	int a;
    	int b;
    	public Pair(int a, int b)
    	{
    		this.a=a;
    		this.b=b;
    	}
    }
    static HashMap<Integer,List<Integer>> edge=new HashMap();
    static Pair a[];
    static long dp[][];
    static void dfs(int node, int parent)
    {
        for(int i:edge.get(node))
        {
            if(i!=parent)
            {
                dfs(i,node);
                dp[node][0]+=Math.max(Math.abs(a[node].a-a[i].a)+dp[i][0],Math.abs(a[node].a-a[i].b)+dp[i][1]);
                dp[node][1]+=Math.max(Math.abs(a[node].b-a[i].a)+dp[i][0],Math.abs(a[node].b-a[i].b)+dp[i][1]);
            }
        }
    }
    public static void main(String args[])
    {
        FastReader sc=new FastReader();
        Output out=new Output(System.out);
        int t=sc.nextInt();
        while(t-->0)
        {
            int n=sc.nextInt();
            a=new Pair[n+1];
            edge.clear();
            for(int i=1;i<n+1;i++)
            {
                int l=sc.nextInt();
                int r=sc.nextInt();
                Pair p=new Pair(l,r);
                a[i]=p;
            }
            for(int i=0;i<n-1;i++)
            {
                int u=sc.nextInt();
                int v=sc.nextInt();
                if(edge.containsKey(u))
                {
                    List<Integer> list=edge.get(u);
                    list.add(v);
                    edge.put(u,list);
                }
                else
                {
                    List<Integer> list=new ArrayList();
                    list.add(v);
                    edge.put(u,list);
                }
                if(edge.containsKey(v))
                {
                    List<Integer> list=edge.get(v);
                    list.add(u);
                    edge.put(v,list);
                }
                else
                {
                    List<Integer> list=new ArrayList();
                    list.add(u);
                    edge.put(v,list);
                }
            }
            dp=new long[n+1][2];
            dfs(1,0);
            out.printLine(((long)Math.max(dp[1][0],dp[1][1])));
            out.flush();
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;



import static javax.swing.UIManager.get;
import static javax.swing.UIManager.getString;


public class Main {


    static class Pair implements Comparable<Pair> {
        int x = 0;
        int y = 0;

        public Pair(int x1, int y1) {
            x = x1;
            y = y1;
        }


        
    }

    


    

    

    static int min = Integer.MAX_VALUE;

    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
//(1)very very important**(never take the first problem for granted, always check the test cases) take 5 minutes more and check the edge cases
        // 5 minutes will not decreases rating as much as a wrong submission does it is easy u just think with an open mind and u will surely get the answer
        //(2)let ur brain consume the problem don't just jump to the solution. after reading the problem take a pause 1 minute
        //(3)go through the example test cases and also at least two of ur own test cases.Think of testcases which are difficult(edge cases).dry run ur concept
 //(4) sometimes if else condition is not required but due to if else you miss some points and get wrong answer


        int t = sc.nextInt();
        while (t-- > 0) {

            int n =sc.nextInt();
            ArrayList<ArrayList<Integer>> list = new ArrayList<>();
            for(int i=0;i<n;i++)
                list.add(new ArrayList<Integer>());

            ArrayList<Pair> list1 = new ArrayList<>();

            for(int i=0;i<n;i++)
            list1.add(new Pair(sc.nextInt(),sc.nextInt()));

            for(int i=0;i<n-1;i++)
            {
                int a =sc.nextInt()-1,b=sc.nextInt()-1;
                list.get(a).add(b);
                list.get(b).add(a);
            }

            long[][] dp = new long[2][n];

            dfs(0,-1,dp,list,list1);


System.out.println(Math.max(dp[0][0],dp[1][0]));
        }



}

static void dfs(int u,int p,long[][] dp,ArrayList<ArrayList<Integer>> list,ArrayList<Pair> list1)
{
    for(int v:list.get(u))
    {  if(v==p)
        continue;
        dfs(v,u,dp,list,list1);
        dp[1][u]+= Math.max(Math.abs(list1.get(u).y-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).y-list1.get(v).y)+dp[1][v]);
        dp[0][u]+=Math.max(Math.abs(list1.get(u).x-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).x-list1.get(v).y)+dp[1][v]);

    }

}


//static int lcs( int[] X, int[] Y, int m, int n )
//{
//    int L[][] = new int[m+1][n+1];
//
//    /* Following steps build L[m+1][n+1] in bottom up fashion. Note
//        that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
//    for (int i=0; i<=m; i++)
//    {
//        for (int j=0; j<=n; j++)
//        {
//            if (i == 0 || j == 0)
//                L[i][j] = 0;
//            else if (X[i-1] == Y[j-1])
//                L[i][j] = L[i-1][j-1] + 1;
//            else
//                L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
//        }
//    }
//    return L[m][n];
//}























// syntax of conditional operator y=(x==1)?1:0;
//Things to check when u r getting wrong answer
// 1-  check the flow of the code
//2- If ur stuck read the problem once again
//3- before submitting always check the output format of ur code
//4- don't check standings until problem B is done
//5- if u r thinking ur concept is correct but still u r getting wrong answer try to implement it in another way
//6- By default, java interpret all numeral literals as 32-bit integer values.
// If you want to explicitely specify that this is something bigger then 32-bit integer you should use suffix L for long values.    example   long a = 600851475143L

//All the functions




    

    










    

    //collections.sort use merge sort instead of quick sort but arrays.sort use quicksort whose worst time complexity is O(n^2)
    

    //function to print an array for debugging
    

    


    //normal gcd function, always put the greater number as a and the smaller number as b
    

    


    //to find gcd and lcm for numbers of long data type
    

    


    //Input Reader to read faster input
    



}
",0,Non-plagiarised
6f393cfe,d3a0b8d2,"import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
","import java.io.File;
import java.io.IOException;
import java.util.*;

public class C {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- > 0){
            int n = in.nextInt();
            int[][] cnt = new int[n][5];
            int[] len = new int[n];
            for (int i = 0; i < n; i++){
                String s = in.next();
                len[i] = s.length();
                for (char c : s.toCharArray()) cnt[i][c-'a']++;
            }
            int max = 0;
            for (int i = 0; i < 5; i++){
                int[] diff = new int[n];
                for (int j = 0; j < n; j++) diff[j] = cnt[j][i] - (len[j] - cnt[j][i]);
                Arrays.sort(diff);
                int j = n-2, sum = diff[n-1];
                while (j>=0 && sum > 0){
                    max = Math.max(max, n - 1 - j);
                    sum += diff[j]; j--;
                }
                if (sum > 0) max = Math.max(max, n);
            }
            System.out.println(max);
        }
    }
}
",0,Non-plagiarised
8f6421f3,ea2fc2bc,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
public class Main{  
    public static void main (String[] args){
        FastReader s = new FastReader();
        int t=1;t=s.ni();
        for(int test=1;test<=t;test++){
        int n=s.ni(),k=s.ni();
        int position[]=s.readArray(k),temp[]=s.readArray(k);
        int ans[]=new int[n];
        Arrays.fill(ans,Integer.MAX_VALUE/2);
        for(int i=0;i<k;i++){
            ans[position[i]-1]=temp[i];
        }
        for(int i=1;i<n;i++){
            ans[i]=Math.min(ans[i-1]+1,ans[i]);
        }
        for(int i=n-2;i>=0;i--){
            ans[i]=Math.min(ans[i],ans[i+1]+1);
        }
        for(int i=0;i<n;i++)
        System.out.print(ans[i]+"" "");
        System.out.println();
        }
    }
    
    
    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class AirConditioner {
	public static void main(String args[]) {
		FastScanner fs=new FastScanner();
		int t=fs.nextInt();
		for(int t1=0;t1<t;t1++) {
			int n=fs.nextInt();
			int k=fs.nextInt();
			int []arr1=new int[k];
			int []arr2=new int[k];
			arr1=fs.readArray(k);
			arr2=fs.readArray(k);
			int []dp=new int[n];
			//for(int i=0;i<k;i++)
				//dp[arr1[i]-1]=arr2[i];
			Arrays.fill(dp,Integer.MAX_VALUE/2);
			for(int i=0;i<k;i++) {
				dp[arr1[i]-1]=arr2[i];
			}
			for(int i=1;i<n;i++) {
				dp[i]=Math.min(dp[i],dp[i-1]+1);
			}
			//Print(dp);
			for(int i=n-2;i>=0;i--) {
				dp[i]=Math.min(dp[i], dp[i+1]+1);
			}
			//Print(dp);
			
			/*for(int i=0;i<n;i++) {
				int min=Integer.MAX_VALUE;
				for(int j=0;j<k;j++) {
					min=Math.min(min, arr2[j]+Math.abs(i-arr1[j]+1));
				}
				dp[i]=min;
			}*/
			for(int val:dp) {
				System.out.print(val+"" "");
			}
			System.out.println();
		}
		
	}
	static final Random random=new Random();	
	
	
	
	
}
",1,Plagiarised
4d279121,a3e272af,"import java.util.*;
import java.io.*;
        
@SuppressWarnings(""unchecked"")
public class Main {
    public static void main(String args[]) {    
        FastReader input = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = input.nextInt();
        while(t-- > 0) {
        int n = input.nextInt();
        int m = input.nextInt();
        int x = input.nextInt();
        int arr[] = new int[n];
        for(int i = 0; i < n; i++) arr[i] = input.nextInt(); 
        PriorityQueue<Pair> queue = new PriorityQueue();
        out.println(""YES"");
        int res[] = new int[n];
        for(int i = 1; i <= m; i++) {
            queue.add(new Pair(0, i));
        }
        for(int i = 0; i < n; i++) {
            Pair p = queue.remove();
            out.print(p.second()+"" "");
            queue.add(new Pair(p.first()+arr[i], p.second()));    
        }
        out.println();
        out.flush();
        }
    }   
}
 
class Pair implements Comparable<Pair> {    
    public int x;
    public int y;
 
    public Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public int first() {
        return x;
    }
    public int second() {
        return y;
    }
 
     
}
 

","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
1162c08f,6bcc5afd,"import java.util.*;

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

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
    
    public static void main(String[] args)
    {
        FastScanner sc=new FastScanner();
        int t=sc.nextInt();
        PrintWriter pw=new PrintWriter(System.out);
        while(t-->0) {
            int n=sc.nextInt();
            int[] a=sc.readArray(n);
            char[] s=sc.next().toCharArray();
            boolean ok=true;
            ArrayList<Integer> blues=new ArrayList<>();
            ArrayList<Integer> reds=new ArrayList<>();
            for(int i=0;i<n;i++){
                if(s[i]=='B'){
                    blues.add(a[i]);
                } else {
                    reds.add(a[i]);
                }
            }
            Collections.sort(blues);
            Collections.sort(reds);
            for(int i=0;i<blues.size();i++){
                if(blues.get(i)<(i+1)){
                    ok=false;
                    break;
                }
            }
            int start=blues.size()+1;
            for(int i=0;i<reds.size();i++){
                if(reds.get(i)>(start++)){
                    ok=false;
                    break;
                }
            }
            if(ok){
               pw.println(""YES"");
            } else {
                pw.println(""NO"");
            }
        }
        pw.flush();
    }

    
}
",1,Plagiarised
16a2a867,3951966f,"import java.util.*;
import java.io.*;
public class Armchairs{
    public static void main(String[] args) {
        FastReader fr = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Scanner sc= new Scanner (System.in);
        
        //Code From Here----
        int t =fr.nextInt();
        ArrayList <Integer> chairs= new ArrayList<>();
        ArrayList <Integer> free= new ArrayList<>();

        for (int i = 0; i < t; i++) {
            int state =fr.nextInt();
            if(state==1)
            {
                chairs.add(i);
            }
            else{
                free.add(i);
            }
        }
        int [][] dp=new int [t][t];
        for (int[] is : dp) {
            Arrays.fill(is, -1);
        }
        int ans=solve(chairs,free,0,0,chairs.size(),dp);
        out.println(ans);
        
    
        out.flush();
        sc.close();
    }

    //This RadixSort() is for long method

   

    private static int solve(ArrayList<Integer> chairs, ArrayList<Integer> free, int i, int j, int size,int [][] dp) {
        if (dp[i][j]!=-1) {
            return dp[i][j];
        }
        if (size==0) {
            return 0;
        }
        if (j==free.size()) {
            return 10000000;
        }
        int a=solve(chairs, free, i, j+1, size,dp);
        int b=Math.abs(chairs.get(i)-free.get(j))+solve(chairs, free, i+1, j+1, size-1,dp);
        dp[i][j]=Math.min(a, b);
        return dp[i][j];
    }

    
	

	

	


	
    

    

    

    


	// For Fast Input  ----
    
    
	



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

    

    

    

    

    

    
}
",0,Non-plagiarised
3a12e509,6de04ee2,"import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
","import java.util.*;
public class Solution{
    public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();

    while(t-->0) {
        int n=sc.nextInt();
        int[] a=new int[n];
        for(int i=0;i<n;i++)
             a[i]=sc.nextInt();

     char[] c=sc.next().toCharArray();

        Vector<Integer> l=new Vector<>(), r=new Vector<>();
        for(int i=0;i<n;i++)
            (c[i] == 'B' ? l : r).add(a[i]);
        Collections.sort(l);
        Collections.sort(r,Collections.reverseOrder());

        boolean ok = true;
        for(int i=0;i<l.size();i++)
            if (l.get(i) < i + 1)
                ok = false;
        for(int i=0;i<r.size();i++)
            if (r.get(i) > n - i)
                ok = false;

         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
    }
    }
}
",0,Non-plagiarised
b728ba1d,d04e5afb,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;

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

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

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

        

        

        

    }

    
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;

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

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

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

        

        

        

    }
}
",1,Plagiarised
ee270b2a,fc80cbe0,"import java.util.*;

public class D{
    private static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args){
        int q = scanner.nextInt();
        while(q-- > 0){
            int n = scanner.nextInt(),
            k = scanner.nextInt();
            int[] a = new int[k];
            for(int i=0;i<k;i++){
                a[i] = scanner.nextInt();
            }
            int[] t = new int[k];
            for(int j=0;j<k;j++){
                t[j] = scanner.nextInt();
            }
            long[] L = new long[n];
            long[] R = new long[n];
            for(int i=0;i<n;i++){
                L[i] = Integer.MAX_VALUE;
                R[i] = Integer.MAX_VALUE;
            }
            for(int i=0;i<k;i++){
                L[a[i]-1] = t[i];
                R[a[i]-1] = t[i];
            }
            
            long min = Integer.MAX_VALUE;
            for(int i=0;i<n;i++){
                L[i] = Math.min(min+1,L[i]);
                min = L[i];
            }
            min = Integer.MAX_VALUE;
            for(int i=n-1;i>=0;i--){
                R[i] = Math.min(min+1,R[i]);
                min = R[i];
            }
            for(int i=0;i<n;i++){
                System.out.print(Math.min(L[i],R[i]) + "" "");
            }
            System.out.println();
        }
    }
}
","import javax.swing.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.StringTokenizer;

public class AirConditioner {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();

        int input = sc.nextInt();
        sc.nextLine();
        for(int i = 0; i < input; i++){
            String[] length = sc.nextLine().split("" "");
            String[] index = sc.nextLine().split("" "");
            String[] temperature = sc.nextLine().split("" "");
            long[] boxes = findTemp(length, index,temperature);
            for(int j = 0; j < boxes.length; j++){
                if(j == 0) System.out.print(boxes[j]);
                else System.out.print("" ""+boxes[j]);
            }
            System.out.println();
            sc.nextLine();
        }
    }

    public static long[]  findTemp(String[] length, String[] index,String[] temperature) {
        long n = Long.parseLong(length[0]);
        HashSet<Integer> set = new HashSet<>();
        long airCond = Long.parseLong(length[1]);
        long[] boxes = new long[(int)n];
        Arrays.fill(boxes,Integer.MAX_VALUE);
        for(int i = 0 ; i < index.length; i++){
            boxes[Integer.parseInt(index[i]) - 1] = Long.parseLong(temperature[i]);
            set.add(Integer.parseInt(index[i]) - 1);
           // System.out.println(index[i]);
        }

        int prev = -1;
        for(int i = 0 ; i < boxes.length; i++) {
            //System.out.println(i +"" ""+set.contains(i));
            if(set.contains(i)){
                if(prev != - 1) boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
               // System.out.println(i + ""  ""+prev);
                prev = i;
            }
           if(prev == -1) continue;
           if(set.contains(i)){
               prev = i;
           }

           else{
               boxes[i] = (Math.abs(i - prev) ) + boxes[prev];
           }
        }
        prev = boxes.length;
        for(int i = boxes.length - 1; i >= 0; i--) {
            if(set.contains(i)){
              //  System.out.println(i);
                if(prev != boxes.length)  boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
                prev = i;
            }
            if(prev == boxes.length) continue;

            else{
                boxes[i] = Math.min((Math.abs(i - prev) ) + boxes[prev],boxes[i]);
            }
        }


        return boxes;
    }
}

",0,Non-plagiarised
18e2441c,b728ba1d,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map;
import java.util.HashMap;

public class cf1515 {

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

	static class Task {
		public void solve(InputReader in, PrintWriter out) {
			int t = in.nextInt();
			while (t-- != 0) {
				int n = in.nextInt();
				int m = in.nextInt();
				int x = in.nextInt();
				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
				for (int i = 0; i < n; i++) {
					int j = in.nextInt();
					if (!map.containsKey(j)) {
						map.put(j, new ArrayList<Integer>());
					}
					map.get(j).add(i);
				}
				out.println(""YES"");
				int[] ans = new int[n];
				int sta = 0;
				for (int s : map.keySet()) {
					for (int i = 0; i < map.get(s).size(); i++) {
						ans[map.get(s).get(i)] = (sta++) % m + 1;
					}
				}
				for(int i=0;i<n;i++) {
					out.print(ans[i]+"" "");
				}
				out.println();
			}

		}
	}

	
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;


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

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

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

        

        

        

    }

    
}
",0,Non-plagiarised
722e318f,b790ef12,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class TaskB {

    static long mod = 1000000007;
    static FastScanner scanner;

    static final StringBuilder result = new StringBuilder();

    public static void main(String[] args) {
        // 2 : 1000000000
        scanner = new FastScanner();
        int T = scanner.nextInt();
        for (int t = 0; t < T; t++) {
            solve(t + 1);
            result.append(""\n"");
        }
        System.out.println(result);
    }

    static void solve(int t) {
        int n = scanner.nextInt();
        int[] a = scanner.nextIntArray(n);
        String s = scanner.nextToken();

        List<Integer> blue = new ArrayList<>();
        List<Integer> red = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'B') {
                blue.add(a[i]);
            } else {
                red.add(a[i]);
            }
        }
        Collections.sort(blue);
        Collections.sort(red);
        for (int i = 0; i < blue.size(); i++) {
            if (blue.get(i) < i + 1) {
                result.append(""NO"");
                return;
            }
        }
        for (int i = 0; i < red.size(); i++) {
            if (red.get(i) > i + 1 + blue.size()) {
                result.append(""NO"");
                return;
            }
        }
        result.append(""YES"");
    }

    

    

    

    

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

    public static void main(String[] args) {
        FastReader obj = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int l = obj.nextInt();
        while (l-- != 0) {
            int n = obj.nextInt();
            int[] num = new int[n];
            for (int i = 0; i < n; i++) num[i] = obj.nextInt();
            Vector<Integer> red = new Vector<>();
            Vector<Integer> blue = new Vector<>();
            String s = obj.next();
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == 'R') red.add(num[i]);
                else blue.add(num[i]);
            }
            Collections.sort(blue);
            Collections.sort(red);
            int c = 1, f = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < c) {
                    f = 1;
                    break;
                }
                c++;
            }
            for (int i = 0; i < red.size(); i++) {
                if (red.get(i) > c) {
                    f = 1;
                    break;
                }
                c++;
            }
            if (f == 0) out.println(""YES"");
            else out.println(""NO"");
        }
        out.flush();
    }
}
",1,Plagiarised
3e8ff074,d9199dfd,"import java.io.*;
import java.util.*;

public class blue_red_permutation {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());

        while (T-- > 0) {
            int N = Integer.parseInt(br.readLine());

            String line1[] = br.readLine().split("" "");
            char line2[] = br.readLine().toCharArray();

            Range ranges[] = new Range[N];
            for (int i = 0; i < N; i++) {
                int cnt = Integer.parseInt(line1[i]);
                int low = line2[i] == 'B' ? Math.min(1, cnt) : Math.max(1, cnt);
                int high = line2[i] == 'R' ? Math.max(N, cnt) : Math.min(N, cnt);
                ranges[i] = new Range(low, high);
            }

            Arrays.sort(ranges);

            boolean doable = true;
            for (int i = 0; i < N; i++) {
                if (!ranges[i].contains(i + 1)) { doable = false; break; }
            }

            System.out.println(doable ? ""YES"" : ""NO"");
        }
    }

    static class Range implements Comparable<Range> {
        final int low, high;
        
        Range(int low,int high) {
            this.low = low;
            this.high = high;
        }

        public boolean contains(int val) {
            return val >= this.low && val <= this.high;
        }

        
    }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",0,Non-plagiarised
d2eb953e,dcf09f37,"import java.util.*;
// import java.lang.*;
import java.io.*;

//           THIS TEMPLATE MADE BY AKSH BANSAL.

public class Solution {
    
    private static boolean[] isPrime;
    
    
    
    static ArrayList<Integer>[] adj;
    static void getAdj(int n,int q, FastReader sc){
        adj = new ArrayList[n+1];
        for(int i=1;i<=n;i++){
            adj[i] = new ArrayList<>();
        }
        for(int i=0;i<q;i++){
            int a = sc.nextInt();
            int b = sc.nextInt();

            adj[a].add(b);
            adj[b].add(a);
        }
    }
    static PrintWriter out;
    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
        out = new PrintWriter(System.out);
        // primes();
        // ________________________________

        int t = sc.nextInt();
        StringBuilder output = new StringBuilder();

        while (t-- > 0) {
            int n = sc.nextInt();
            pair = new int[n+1][2];
            dp = new long[n+1][2];
            for(int i=1;i<=n;i++){
                pair[i][0]=sc.nextInt();
                pair[i][1]=sc.nextInt();
            }
            getAdj(n, n-1, sc);
            output.append(solver(n)).append(""\n"");
        }

        out.println(output);
        // _______________________________

        // int n = sc.nextInt();
        // out.println(solver());
        // ________________________________
        out.flush();
    }

    static int[][] pair;
    static long[][] dp;

    public static long solver(int n) {
        dfs(1,  0);
        return Math.max(dp[1][0], dp[1][1]);
    }

    static void dfs(int node, int parent){
        for(Integer child: adj[node]){
            if(child!=parent){
                dfs(child,  node);
                long left1 = Math.abs(pair[node][0]-pair[child][0]) + dp[child][0];
                long right1 = Math.abs(pair[node][0]-pair[child][1]) + dp[child][1];
                long left2 = Math.abs(pair[node][1]-pair[child][0]) + dp[child][0];
                long right2 = Math.abs(pair[node][1]-pair[child][1]) + dp[child][1];
                dp[node][0] += Math.max(left1, right1);
                dp[node][1] += Math.max(left2, right2);
            }
        }
    }
}
","import java.io.*;
import java.util.*;

public class E
{ 
	
	static long dp[][];
	static long val[][];
	static ArrayList<Integer> arr[];
    public static void main(String[] args) 
	{ 
		FastReader sc=new FastReader(); 
		StringBuffer ans=new StringBuffer();
		int test=sc.nextInt();
		while(test-->0)
		{
			int n=sc.nextInt();
			arr=new ArrayList[n+1];
			val=new long[n+1][2];
			dp=new long[n+1][2];
			for(int i=0;i<=n;i++) Arrays.fill(dp[i], -1);
			for(int i=1;i<=n;i++) {
				val[i][0]=sc.nextLong();val[i][1]=sc.nextLong();
			}
			for(int i=0;i<=n;i++) arr[i]=new ArrayList<>();
			for(int i=0;i<n-1;i++) {
				int a=sc.nextInt(),b=sc.nextInt();
				arr[a].add(b);arr[b].add(a);
			}
			long max1=0,max2=0;
			
			for(int ch:arr[1]) {
				max1+=solve(ch,0,1);
				max2+=solve(ch,1,1);
			}
			ans.append(Math.max(max1, max2)+""\n"");
		}
		
	    System.out.print(ans);
	} 
    
    static long solve(int nd,int prv,int par) {
    	
    	
    	
    	if(dp[nd][prv] != -1) return dp[nd][prv];
    	
    	long l=Math.abs(val[par][prv]-val[nd][0]);long r=Math.abs(val[par][prv]-val[nd][1]);
    
    		for(int ch:arr[nd]) {
    			if(ch != par) {
    				l+=solve(ch,0,nd);//Take left
    				r+=solve(ch,1,nd);//Take right
    			}
    		}
    
    		return dp[nd][prv] =Math.max(l, r);
    }
 
    
    
    static final Random random=new Random();
    
	
	
	
	
	 


}
",0,Non-plagiarised
8a041ef5,bdf7bfb2,"import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.jar.JarEntry;

public class Main{
    /* || श्री गणेशाय नमः ||
       @𝐚𝐮𝐭𝐡𝐨𝐫 𝐉𝐢𝐠𝐚𝐫 𝐍𝐚𝐢𝐧𝐮𝐣𝐢
       𝐒𝐕𝐍𝐈𝐓- 𝐒𝐮𝐫𝐚𝐭
    */
    public static void main(String args[]){
        InputReader in=new InputReader(System.in);
        TASK solver = new TASK();
        int t=1;
        t = in.nextInt();
        for(int i=1;i<=t;i++)
        {
            solver.solve(in,i);
        }
    }
    static class TASK {


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
















        }
    }


    

    
    
}
","import java.util.*;
import java.io.*;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }
 
    
}
",0,Non-plagiarised
298ee961,392218ef,"import java.util.*;
import java.io.*;

public class Main {
  
  static void printLine(String s) {
    System.out.println(s);
  }
  
  static int parseInt(String s) {
    return Integer.parseInt(s.trim());
  }
  static String[] split(String s) {
    return s.split(""\\s+"");
  }
  
  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String line;
    StringTokenizer st;
    int test = parseInt(br.readLine());
    for (int t = 0; t < test; t++) {
      int n = parseInt(br.readLine());
      ArrayList<Integer> blue = new ArrayList<Integer>();
      ArrayList<Integer> red = new ArrayList<Integer>();
      String[] toks = split(br.readLine());
      String color = br.readLine();
      for (int i = 0; i < n; i++) {
        if (color.charAt(i) == 'B') {
          blue.add(parseInt(toks[i]));
        } else {
          red.add(parseInt(toks[i]));
        }
      }
      int[] blueArr = new int[blue.size()];
      int[] redArr = new int[red.size()];
      for (int i = 0; i < blue.size(); i++) {
        blueArr[i] = blue.get(i);
      }
      for (int i = 0; i < red.size(); i++) {
        redArr[i] = red.get(i);
      }
      Arrays.sort(blueArr);
      Arrays.sort(redArr);
      int blueP = 0; // pointer
      int redP = 0; // pointer
      
      // blue -> decrease, red -> increase
      int start = 1;
      boolean unable = false;
      while (start <= n) {
        if (blueP < blueArr.length) {
          if (blueArr[blueP] < start) {
            unable = true;
            printLine(""NO"");
            break;  
          } else {
            blueP++;
            start++;
          }
        } else {
          if (redArr[redP] > start) {
            unable = true;
            printLine(""NO"");
            break;  
          } else {
            redP++;
            start++;
          }
        }        
      }
      if (!unable) {
        printLine(""YES"");
      }      
    }
  }
}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
    static void sort(int a[]){
        ArrayList<Integer> arr=new ArrayList<>();
        for(int i=0;i<a.length;i++)arr.add(a[i]);
        Collections.sort(arr);
        for(int i=0;i<a.length;i++)a[i]=arr.get(i);
    }
	public static void main (String[] args) throws java.lang.Exception
	{
	   // Scanner sc=new Scanner(System.in);
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	   // int t=1;
	    //t=sc.nextInt();
	    int t=Integer.parseInt(br.readLine());
	    while(--t>=0){
	        int n=Integer.parseInt(br.readLine());
	         int a[]=new int[n];
	         StringTokenizer st=new StringTokenizer(br.readLine());
	        for(int i=0;i<n;i++)a[i]=Integer.parseInt(st.nextToken());
	       String s=br.readLine();
	        ArrayList<Integer> inc=new ArrayList<>();
	        ArrayList<Integer> dec=new ArrayList<>();
	        
	        for(int i=0;i<n;i++){
	            if(s.charAt(i)=='R')inc.add(a[i]);
	            else dec.add(a[i]);
	        }
	        Collections.sort(dec);
	        Collections.sort(inc,Collections.reverseOrder());
	        int p=n;
	        boolean flag=false;
	        for(int i=0;i<inc.size();i++){
	            if(inc.get(i)>p)flag=true;
	            p--;
	        }
	        p=1;
	        for(int i=0;i<dec.size();i++){
	            if(dec.get(i)<p)flag=true;
	            p++;
	        }
	        if(flag)System.out.println(""NO"");
	        else System.out.println(""YES"");
	    }
	    
	}
}
",0,Non-plagiarised
4be01508,b7de5c19,"import java.util.*;
import java.io.*;

public class q3{
    static FastScanner fs = new FastScanner();
    static PrintWriter pw = new PrintWriter(System.out);
    static List<List<Edge>> list;
    public static void main(String[] args){
        int tt = fs.nextInt();
        for (int t=0;t<tt;t++){
            solve();
        }
        pw.close();
    }

    static void solve(){
        int n = fs.nextInt();
        list = new ArrayList<>();
        for (int i=0;i<n;i++) list.add(new ArrayList<>());
        
        for (int i=0;i<n-1;i++){
            int from = fs.nextInt()-1, to = fs.nextInt()-1;
            list.get(from).add(new Edge(to, i));
            list.get(to).add(new Edge(from, i));
        }

        int start = -1;
        for (int i=0;i<n;i++){
            if (list.get(i).size() > 2){
                pw.println(-1);
                return;
            }
            else if (list.get(i).size() == 1){
                start = i;
            }
        }   

        int[] ans = new int[n-1];
        int prev = -1;
        int cur = start;
        int curWeight = 2;
        while (true){
            Edge now = list.get(cur).get(0);
            if (now.node == prev){
                if (list.get(cur).size() == 1){
                    break;
                }
                now = list.get(cur).get(1);
            }

            ans[now.index] = 5 - curWeight;
            curWeight = ans[now.index];
            prev = cur;
            cur = now.node;
        }

        for (int i : ans){
            pw.printf(""%d "", i);
        }
        pw.println();
    }

    static class Edge {
        int node;
        int index;

        public Edge(int node, int index){
            this.node = node;
            this.index = index;
        }
    }

//    ----------input function----------

    

    
}
","import java.util.*;

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

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

class Pair {
    int vertex;
    int numberOfEdge;

    public Pair(int vertex, int numberOfEdge) {
        this.vertex = vertex;
        this.numberOfEdge = numberOfEdge;
    }
}
",0,Non-plagiarised
80c384e4,967b67b0,"import java.util.*;

public class Solution {
	
	private static Scanner in = new Scanner(System.in);
	
	public static void main(String[] args) {
		
		int t = in.nextInt();
		while(t-- > 0)
			solve();
    }
	
	private static void solve() {
		int n = in.nextInt();
		int k = in.nextInt();
		int a[] = new int[k+1];
		for(int i=1; i<=k; i++)
			a[i] = in.nextInt();
		long l[] = new long[n+1];
		long r[] = new long[n+1];
		for(int i=1; i<=n; i++) {
			l[i] = Integer.MAX_VALUE;
			r[i] = Integer.MAX_VALUE;
		}
		for(int i=1; i<=k; i++) {
			l[a[i]] = in.nextInt();
			r[a[i]] = l[a[i]];
		}
		for(int i=2;i<=n;i++) {
			l[i] = Math.min(l[i-1]+1, l[i]);
		}
		for(int i=n-1;i>=0;i--) {
			r[i] = Math.min(r[i+1]+1, r[i]);
		}
		
		for(int i=1;i<=n;i++) {
				System.out.print(Math.min(l[i], r[i])+"" "");
		}
		System.out.println();
	}
}
","import java.util.*;

public class Solution {
	
	private static Scanner in = new Scanner(System.in);
	
	public static void main(String[] args) {
		
		int t = in.nextInt();
		while(t-- > 0)
			solve();
    }
	
	private static void solve() {
		int n = in.nextInt();
		int k = in.nextInt();
		int a[] = new int[k+1];
		for(int i=1; i<=k; i++)
			a[i] = in.nextInt();
		long l[] = new long[n+1];
		long r[] = new long[n+1];
		for(int i=1; i<=n; i++) {
			l[i] = Integer.MAX_VALUE;
			r[i] = Integer.MAX_VALUE;
		}
		for(int i=1; i<=k; i++) {
			l[a[i]] = in.nextInt();
			r[a[i]] = l[a[i]];
		}
		for(int i=2;i<=n;i++) {
			l[i] = Math.min(l[i-1]+1, l[i]);
		}
		for(int i=n-1;i>=0;i--) {
			r[i] = Math.min(r[i+1]+1, r[i]);
		}
		
		for(int i=1;i<=n;i++) {
				System.out.print(Math.min(l[i], r[i])+"" "");
		}
		System.out.println();
	}
}
",1,Plagiarised
6f02c6d9,c9159d9c,"import java.io.*;
import java.util.*;

public class Main {


    static long mod = 1000000007;

    

    

    static 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 SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
",0,Non-plagiarised
00af3420,5449d33c,"import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }

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

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

  static class Solver {
    public void Main(InputReader in, PrintWriter out) {
      int T = in.nextInt();
      for (int t = 0; t < T; t++) {
        int n = in.nextInt();
        String[] A = new String[n];
        for (int i = 0; i < n; i++) {
          A[i] = in.next();
        }
        int ans = 0;
        for (char c = 'a'; c <= 'e'; c++) {
          int[] ls = new int[n];
          for (int i = 0; i < n; i++) {
            int delta = 0;
            for (int j = 0; j < A[i].length(); j++) {
              if (A[i].charAt(j) == c) {
                delta += 1;
              } else {
                delta -= 1;
              }
            }
            ls[i] = delta;
          }
          Arrays.sort(ls, 0, n);
          int cur = 0;
          int score = 0;
          for (int i = n - 1; i >= 0; i--) {
            if (cur + ls[i] >= 1) {
              cur += ls[i];
              score += 1;
            }
          }
          ans = Math.max(ans, score);
        }
        out.println(ans);
      }
    }
  }

  
}
",0,Non-plagiarised
2b2d3b84,9fd33d5a,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Main
{



public static void main(String[] args)
{
   FastReader in = new FastReader();
   int t=in.nextInt();
   while(t-->0)
   {
       int n=in.nextInt();
       int k=in.nextInt();
       
       int a[]=new int[k];
       int ans[]=new int[n];
       int tem[]=new int[k];
       
       for(int i=0;i<k;i++)
           a[i]=in.nextInt();
       for(int  i=0;i<k;i++)
           tem[i]=in.nextInt();
       
      long c[]=new long[n];
      long l[]=new long[n];
      long r[]=new long[n];
      Arrays.fill(c,Integer.MAX_VALUE);
      Arrays.fill(l, Integer.MAX_VALUE);
      Arrays.fill(r,Integer.MAX_VALUE);
      
      long p=Integer.MAX_VALUE;
      for(int i=0;i<k;i++)
          c[a[i]-1]=tem[i];
      
      for(int i=0;i<n;i++)
      {
         p=Math.min(p+1,c[i]);
         l[i]=p;
      }
      p=Integer.MAX_VALUE;
      for(int i=n-1;i>=0;i--)
      {
         p=Math.min(p+1,c[i]);
         r[i]=p;
      }
    
       
      for(int i=0;i<n;i++)
          System.out.print(Math.min(l[i],r[i])+"" "");
      System.out.println();
   }
}
}
","import java.util.*;
import java.io.*;

public class Solution {

    private static ArrayList<Integer> prime = new ArrayList<>();

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

        Scanner in=new Scanner(System.in);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringBuffer out = new StringBuffer();

        int T = in.nextInt();

        OUTER:
        while(T-->0) {

            int n=in.nextInt(), k=in.nextInt();

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

            int t[]=new int[k];
            long ans[]=new long[n];
            for(int i=0; i<k; i++) {
                t[i]=in.nextInt();
                ans[a[i]]=t[i];
            }

            long temp=Integer.MAX_VALUE;

            long left[]=new long[n];
            for(int i=0; i<n; i++) {
                if(ans[i]!=0) {
                    temp=Math.min(temp, ans[i]);
                }
                left[i]=temp;
                temp+=1;
            }

            temp=Integer.MAX_VALUE;

            long right[]=new long[n];
            for(int i=n-1; i>=0; i--) {
                if(ans[i]!=0) {
                    temp=Math.min(temp, ans[i]);
                }
                right[i]=temp;
                temp+=1;
            }

            for(int i=0; i<n; i++) {
                ans[i]=Math.min(left[i], right[i]);
                out.append(ans[i]+"" "");
            }
            out.append(""\n"");
        }

        System.out.print(out);
    }

    

    

    

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

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

public class Solution {

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

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

    

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

    //-----------MyScanner class for faster input----------
    
    //--------------------------------------------------------
}
",0,Non-plagiarised
6de04ee2,d9199dfd,"import java.util.*;
public class Solution{
    public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();

    while(t-->0) {
        int n=sc.nextInt();
        int[] a=new int[n];
        for(int i=0;i<n;i++)
             a[i]=sc.nextInt();

     char[] c=sc.next().toCharArray();

        Vector<Integer> l=new Vector<>(), r=new Vector<>();
        for(int i=0;i<n;i++)
            (c[i] == 'B' ? l : r).add(a[i]);
        Collections.sort(l);
        Collections.sort(r,Collections.reverseOrder());

        boolean ok = true;
        for(int i=0;i<l.size();i++)
            if (l.get(i) < i + 1)
                ok = false;
        for(int i=0;i<r.size();i++)
            if (r.get(i) > n - i)
                ok = false;

         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
    }
    }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",0,Non-plagiarised
464a03b8,c9159d9c,"import java.util.*;

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
","import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
",0,Non-plagiarised
8d6f1bf5,e90a198b,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Menorah {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t > 0) {
            int n = Integer.parseInt(br.readLine());
            String source = br.readLine();
            String destination = br.readLine();
            int sameStatusOnes = 0;
            int sameStatusZeros = 0;
            int diffStatusOnes = 0;
            int diffStatusZeros = 0;
            for (int i = 0; i < n; i++) {
                char c1 = source.charAt(i);
                char c2 = destination.charAt(i);
                if (c1 == c2) {
                    if (c1 == '0') {
                        sameStatusZeros += 1;
                    } else {
                        sameStatusOnes += 1;
                    }
                } else {
                    if (c1 == '0') {
                        diffStatusZeros += 1;
                    } else {
                        diffStatusOnes += 1;
                    }
                }
            }
            int sameStatus = sameStatusOnes + sameStatusZeros;
            int diffStatus = diffStatusOnes + diffStatusZeros;
            //first case
            if (sameStatus == n) {
                System.out.println(0);
            } else if (diffStatus == n) {
                //second case
                if (diffStatus % 2 == 0 && diffStatusOnes == (n + 1) / 2)
                    System.out.println(n);
                else
                    System.out.println(-1);
            } else {
                int op1 = -1;
                int op2 = -1;
                if (sameStatus % 2 != 0 && sameStatusOnes == (sameStatus + 1) / 2)
                    op1 = sameStatus;
                if (diffStatus % 2 == 0 && diffStatusOnes == (diffStatus + 1) / 2)
                    op2 = diffStatus;

                if (op1 != -1 && op2 != -1)
                    System.out.println(Integer.min(op1, op2));
                else if (op1 != -1)
                    System.out.println(op1);
                else if (op2 != -1)
                    System.out.println(op2);
                else
                    System.out.println(-1);
            }
            t--;
        }
    }
}
","import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class Template {
    
	static int mod = 1000000007;

	public static void main(String[] args){
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int yo = sc.nextInt();
        while (yo-- > 0) {
            int n = sc.nextInt();
            String s = sc.next();
            String t = sc.next();
            int op1 = cal(s,t,n);
            int op2 = helper(s,t,n,'0');
            int op3 = helper(s,t,n,'1');
            int ans = min(min(op1,op2),op3);
            if(ans == Integer.MAX_VALUE){
                out.println(""-1"");
            }
            else {
                out.println(ans);
            }
        }
        out.close();
	}
    
    static int helper(String str1, String str2, int n, int ch){
        char[] s = str1.toCharArray();
        char[] t = str2.toCharArray();
        int idx = -1;
        for(int i = 0; i < n; i++){
            if(s[i] == '1' && t[i] == ch){
                idx = i;
                break;
            }
        }
        if(idx == -1){
            return Integer.MAX_VALUE;
        }
        for(int i = 0; i < n; i++){
            if(i == idx) continue;
            if(s[i] == '1') s[i] = '0';
            else s[i] = '1';
        }
        int ans = cal(String.valueOf(s),String.valueOf(t),n);
        if(ans == Integer.MAX_VALUE) return ans;
        return 1 + ans;
    }
    static int cal(String s, String t, int n){
        int op01 = 0;
        int op10 = 0;
        for(int i = 0; i < n; i++){
            if(s.charAt(i) != t.charAt(i)){
                if(s.charAt(i) == '1') op10++;
                else op01++;
            }
        }
        if(op10 != op01){
            return Integer.MAX_VALUE;
        }
        return op01 + op10;
    }
    
    /*
    Source: hu_tao
         Random stuff to try when stuck:
            - use bruteforcer
            - check for n = 1, n = 2, so on
            -if it's 2C then it's dp
            -for combo/probability problems, expand the given form we're interested in
            -make everything the same then build an answer (constructive, make everything 0 then do something)
            -something appears in parts of 2 --> model as graph
            -assume a greedy then try to show why it works
            -find way to simplify into one variable if multiple exist
            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
            -find lower and upper bounds on answer
            -figure out what ur trying to find and isolate it
            -see what observations you have and come up with more continuations
            -work backwards (in constructive, go from the goal to the start)
            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
            -draw something
            -simulate a process
            -dont implement something unless if ur fairly confident its correct
            -after 3 bad submissions move on to next problem if applicable
            -do something instead of nothing and stay organized
            -write stuff down
         Random stuff to check when wa:
            -if code is way too long/cancer then reassess
            -switched N/M
            -int overflow
            -switched variables
            -wrong MOD
            -hardcoded edge case incorrectly
         Random stuff to check when tle:
            -continue instead of break
            -condition in for/while loop bad
         Random stuff to check when rte:
            -switched N/M
            -long to int/int overflow
            -division by 0
            -edge case for empty list/data structure/N=1
            
      */

	

	

	

	

	

	
    
    
    
    

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
",0,Non-plagiarised
2e404969,bc46480a,"import java.util.*;
import java.lang.*;
import java.io.*;

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

	

	

	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.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

/**
 * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
 */

public class Main {
   static InputReader sc=new InputReader(System.in);
   public static void main(String[] args) {
      // Write your solution here
      int t=sc.nextInt();
      while(t-->0){
         solve();
      }
   }

   private static void solve() {
      int n=sc.nextInt();
      Node left[]=new Node[n];
      int index=0;
      Node ini[]=new Node[n];
      int tmp[]=new int[n];
      for(int i=0;i<n;i++){
         tmp[i]=sc.nextInt();
      }
      for(int i=0;i<n;i++){
         ini[i]=new Node(tmp[i],tmp[i]-sc.nextInt()+1);
      }
      Arrays.sort(ini);
      left[0]=ini[0];
      for(int i=1;i<n;i++){
         //System.out.println(ini[i].k+"" ""+ini[i].s);
         if(ini[i].s<=left[index].k&&ini[i].k>left[index].k){
            left[index].k=ini[i].k;
         }else if(ini[i].s>left[index].k){
            index++;
            left[index]=ini[i];
         }
      }
      long ans=0;
      for(int i=0;i<=index;i++){
         //System.out.println(left[i].k+"" ""+left[i].s);
         ans+=(long)(left[i].k-left[i].s+2)*(left[i].k-left[i].s+1)/2;
      }
      System.out.println(ans);


   }
}
class Node implements Comparable<Node>{
   int k,s;
   Node(int k,int s){
      this.s=s;
      this.k=k;
   }
   
}

",0,Non-plagiarised
42fe7dd0,c4ca2ff3,"import java.util.*;
 public class Solution {
    static Scanner sc=new Scanner(System.in);
    public static void main(String args[]) {
      int t=sc.nextInt();
      outer:while(t-->0){
        int n=sc.nextInt();
        int[][] ct=new int[n][5];
        int[] len=new int[n];
        for (int i=0;i<n;i++) {
            String s=sc.next();
            len[i]=s.length();
            for(char c:s.toCharArray()){
                ct[i][c-'a']++;
            }
        }
        int mx=0;
        for (int i=0;i<5;i++) {
            int[] diff=new int[n];
            for (int j=0;j<n;j++) {
                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
            }
            Arrays.sort(diff);
            int sum=0,inc=0;
            for(int j=n-1;j>=0;j--){
                sum+=diff[j];
                if (sum>0) {
                    inc++;
                }else {
                    break;
                }
            }
            mx=Math.max(mx,inc);
        }
        System.out.println(mx);
        }
        
      }

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

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

////***************************************************************************
 /* public class E_Gardener_and_Tree implements Runnable{

       public static void main(String[] args) throws Exception {
        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
       }
    public void run(){
         WRITE YOUR CODE HERE!!!!
         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
       }

  }
*/
/////**************************************************************************


public class C_Menorah{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        //PrintWriter out=new PrintWriter(System.out);
        //end of program
        //out.println(answer);
        //out.close();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        
        while(p<t){
        int n=s.nextInt();
        String str1=s.nextToken();
        String str2=s.nextToken();
       
        if(str1.equals(str2)){
            res.append(""0 \n"");
        }
      
        else{
            long count1=0;
            long count0=0;
            for(int i=0;i<n;i++){
                char ch=str1.charAt(i);
                if(ch=='1'){
                    count1++;
                }
            }
            count0=n-count1;
            if(count1==0){
                res.append(""-1 \n"");
            }
            else{
                long nice1=0;
                long nice0=0;
                for(int i=0;i<n;i++){
                    char ch=str2.charAt(i);
                    if(ch=='1'){
                        nice1++;
                    }
                }
                nice0=(n-nice1);
                int check1=0;
                int check2=0;
                if((count1==nice1)&&(count0==nice0)){
                    check1=1;
                }
                long yo1=(1+count0);
                long yo0=(count1-1);
                if((yo1==nice1)&&(yo0==nice0)){
                    check2=1;
                }
                if(check1==0 && check2==0){
                    res.append(""-1 \n"");
                }
                else{
                    //System.out.println(""here"");
                    long correct=0;
                    long wrong=0;
                    long correct1=0;
                    long correct0=0;
                    long wrong1=0;
                    long wrong0=0;
                   
                    for(int i=0;i<n;i++){
                        char ch1=str1.charAt(i);
                        char ch2=str2.charAt(i);
                        if(ch1==ch2){
                            correct++;
                            if(ch1=='1'){
                                correct1++;
                            }
                            else{
                                correct0++;
                            }
                        }
                        else{
                            wrong++;
                            if(ch1=='1'){
                                wrong1++;
                            }
                            else{
                                wrong0++;
                            }
                        }
                    }
              long ans1=      solve(correct1,correct0,wrong1,wrong0,1);
              long ans2=      solve(correct1,correct0,wrong1,wrong0,0);
              long ans=Math.min(ans1,ans2);
              if(ans>=Integer.MAX_VALUE){
                  ans=-1;
              }
              res.append(ans+"" \n"");
                  
                    
                   
                }



            }

        }
        p++;
    }
    
    System.out.println(res);
    
    }
    private static long solve( long correct1, long correct0, long wrong1, long wrong0,long a) {
               long op1=Integer.MAX_VALUE;
               long op2=Integer.MAX_VALUE;
               if(wrong1==0 && wrong0==0){
                   return 0;
               }
               if(a==1){
               {
                   // using correct1
                   if(correct1>0){
                       long newcorrect1=1+wrong0;
                       long newcorrect0=wrong1;
                       long newwrong1=correct0;
                       long newwrong0=correct1-1;
                       op1=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,0));

                   }
               }
            }
            else{

               {
                   //using wrong1
                   {
                       if(wrong1>0){
                        long newcorrect1=wrong0;
                        long newcorrect0=wrong1-1;
                        long newwrong1=1+correct0;
                        long newwrong0=correct1;
                        op2=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,1));
                       }
                   }
               }
            }  
               long ans=Math.min(op1,op2);
               return ans;
    
    }
    


    

  
   // SIMPLE POWER FUNCTION=>


      





}
","import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

public class a729 {

	public static void main(String[] args) throws IOException {
   
		
//		try {
			
		BufferedWriter out = new BufferedWriter(
	            new OutputStreamWriter(System.out));
		BufferedReader br = new BufferedReader(
		        new InputStreamReader(System.in));
		PrintWriter pt = new PrintWriter(System.out);
		FastReader sc = new FastReader();
		int t = sc.nextInt();
	
for(int o = 0 ; o<t;o++){

	int n = sc.nextInt();
	String s1 = sc.next();
	String s2 = sc.next();
	if(s1.equals(s2)) {
		System.out.println(0);
		continue;
	}
	int f = 0;
	for(int i = 0 ; i<n;i++) {
		if(s1.charAt(i) == '1') {
			f = 1;
			break;
		}
	}
if(f == 0) {
	System.out.println(-1);
continue;
}
int c = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
int c4 = 0;
for(int i = 0; i<n;i++) {
	if(s1.charAt(i)!=s2.charAt(i)) {
		c++;
	if(s1.charAt(i) == '1') {
		c1++;
	}else {
		c2++;
	}
	}else {
		if(s1.charAt(i) == '1') {
			c3++;
		}else {
			c4++;
		}
	}
}

int g = 0;
int h = 0;

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

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

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

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

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

	
	
	
	

	
	
	
	
	
	

	
	
	
	
//for f/inding minimum in range 

//// for sum
//

	
	
	
	
	
	
	
	
	

//	-----------------------------------------------------------------------------------------------------------------------------------------------
	
//--------------------------------------------------------------------------------------------------------------------------------------------------------
	

		

//-----------------------------------------------------------------------------------------------------------------------------------

	//segment tree
	//for finding minimum in range 
//	public static void build(int [] seg,int []arr,int idx, int lo , int hi) {
//		if(lo == hi) {
//			seg[idx] = arr[lo];
//			return;
//		}
//		int mid = (lo + hi)/2;
//	build(seg,arr,2*idx+1, lo, mid);
//	build(seg,arr,idx*2+2, mid +1, hi);
//	seg[idx] = Math.min(seg[2*idx+1],seg[2*idx+2]);
//	}
////for finding minimum in range 
//public static int query(int[]seg,int idx , int lo , int hi , int l , int r) {
//		if(lo>=l && hi<=r) {
//			return seg[idx];
//		}
//	if(hi<l || lo>r) {
//		return Integer.MAX_VALUE;
//	}
//	int mid = (lo + hi)/2;
//	int left = query(seg,idx*2 +1, lo, mid, l, r);
//	int right = query(seg,idx*2 + 2, mid + 1, hi, l, r);
//	return Math.min(left, right);
//}
//	// for sum
//
//public static void update(int[]seg,int idx, int lo , int hi , int node , int val) {
//	if(lo == hi) {
//		seg[idx] += val;
//	}else {
//int mid = (lo + hi )/2;
//if(node<=mid && node>=lo) {
//	update(seg, idx * 2 +1, lo, mid, node, val);
//}else {
//	update(seg, idx*2 + 2, mid + 1, hi, node, val);
//}
//seg[idx] = seg[idx*2 + 1] + seg[idx*2 + 2];
//
//}

//}
//---------------------------------------------------------------------------------------------------------------------------------------


	
//-----------------------------------------------------------------------------------------------------------------------------------------------------------

}



//------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------



",0,Non-plagiarised
00db6701,0c1143f7,"import java.util.*;
import java.io.*;
public class Main  {
    public static void main(String args[]) {
      FastScanner fs=new FastScanner();    
      PrintWriter out=new PrintWriter(System.out);
      
      int t=fs.nextInt();
      while(t-->0)
      {
          int n=fs.nextInt();
          int c[]=fs.readArray(n);
          int i;
          
          
          long mn0=c[0];
          long mn1=c[1];
          long s0=c[0];
          long s1=c[1];
          
          
          long ans;
          ans=(mn0+mn1)*n*1L;
          
          for(i=2;i<n;i++)
          {
              if(i%2==0)
              {
                  s0+=c[i];
                  mn0=Math.min(mn0,c[i]);
              }
              else
              {
                  s1+=c[i];
                  mn1=Math.min(mn1,c[i]);
              }
              ans=Math.min(ans,s0+mn0*(n-i/2-1)+s1+mn1*(n-(i+1)/2));
          }
          
          out.println(ans);
          
          
          
          
      }
        
        out.flush();
        out.close();
    }
	
}
        
","import java.io.*;
import java.util.*;

public class E {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			FastScanner sc = new FastScanner();
			
			int t = sc.nextInt();
			
			while(t-- > 0) {
				
				int n = sc.nextInt();
				int[] a = new int[n];
				
				for(int i = 0 ; i< n ; i++) {
					a[i] = sc.nextInt();
				}
				long oddMin = a[1];
				long evenMin = a[0];
				long res = (n * oddMin) + (n * evenMin);
				long oddSum = a[1];
				long evenSum = a[0];
				
				for(int i = 2 ;i < n ; i++) {
					
					if(i % 2 == 1) {
						oddSum += a[i];
						oddMin = Math.min(oddMin, a[i]);
					}
					else {
						evenSum += a[i];
						evenMin = Math.min(evenMin, a[i]);
					}
					
					int odd = (i + 1) / 2;
					int even = (i / 2) + 1;
					
					long minCostOdd = oddSum + oddMin*(n - odd);
					long minCostEven = evenSum + evenMin*(n - even);
					
					res = Math.min(res, minCostOdd + minCostEven);
				}
				
				System.out.println(res);
			}
			
			
			
			

	}
	
	
	
	// Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
		// worst case since it uses a version of quicksort. Although this would never
		// actually show up in the real world, in codeforces, people can hack, so
		// this is needed.
		

}
",0,Non-plagiarised
29cf2e70,2f4509a0,"import java.util.*;
import java.io.*;
 
public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();
 
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }
 
            Collections.sort(blue);
            Collections.sort(red);
 
            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
","import java.util.*;
import java.io.*;
	
public class Main {
		private static FS sc = new FS();
		
		
		
		private static class extra {
			
			static int[] intArr(int size) {
				int[] a = new int[size];
				for(int i = 0; i < size; i++) a[i] = sc.nextInt();
				return a;
			}
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		}
		
		static int mod = (int) 1e9 + 7;
		
		static LinkedList<String>[] temp, temp2;
		static int inf = (int) 1e9;
//		static long inf = Long.MAX_VALUE;
		
		public static void main(String[] args) {	
			int t = sc.nextInt();
//			int t = 1;
			StringBuilder ret = new StringBuilder();
			while(t-- > 0) {
				int n = sc.nextInt();
				int[] a = extra.intArr(n);
				String s = sc.next();
				ArrayList<Integer> red = new ArrayList<>(), blue = new ArrayList<>();
				for(int i = 0; i < n; i++) {
					if(s.charAt(i) == 'R') red.add(a[i]);
					else blue.add(a[i]);
				}
				Collections.sort(red);
				Collections.sort(blue);
				int start = 1, flag = 0;
				for(int aa:blue) {
					if(start > aa) {
						flag = 1;
						break;
					}
					start++;
				}
				for(int aa:red) {
					if(start < aa) {
						flag = 1;
						break;
					}
					start++;
				}
				if(flag == 1) ret.append(""NO\n"");
				else ret.append(""YES\n"");
			}
			System.out.println(ret);
		}
		
	}
",1,Plagiarised
83b44c9c,e431de28,"import java.util.Scanner;

public class MinimumGridPath {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int test = scanner.nextInt();

        StringBuilder sb = new StringBuilder();
        for (int t = 0; t < test; t++) {
            int n = scanner.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextLong();
            }

            long minx = arr[0];
            long miny = arr[1];

            long min = minx * n + miny * n;
            long sumx = arr[0];
            long sumy = arr[1];

            for(int i=2; i<n; i++) {
                int xc;
                int yc;
                if(i%2 == 0) {
                    xc = i/2 + 1;
                    yc = i/2;
                    sumx += arr[i];
                    minx = Math.min(minx, arr[i]);
                } else {
                    xc = i/2 + 1;
                    yc = i/2 + 1;
                    sumy += arr[i];
                    miny = Math.min(miny, arr[i]);
                }
                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
            }


            sb.append(min).append(System.lineSeparator());
        }
        System.out.println(sb);

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int t=s.nextInt();
		while(t-->0){
			
			int n = s.nextInt();
			long[] aa =new long[n];
			for(int i=0;i<n;i++)
				aa[i]=s.nextLong();
 
			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
			
		}
	}

}
",0,Non-plagiarised
a4c98ae1,ee4f7b06,"import java.io.*;
import java.util.*;
public class Main {
    static ArrayList<Integer> one=new ArrayList<>();
    static ArrayList<Integer> zero=new ArrayList<>();
    static long dp[][]= new long[5001][5001];
    static long solve(int i,int j){
        if (i==one.size())return 0;
        if (j==zero.size())return Integer.MAX_VALUE;
        if (dp[i][j]!=-1){
           return dp[i][j];
        }
        return dp[i][j]=Math.min(solve(i+1,j+1)+Math.abs(one.get(i)-zero.get(j)),solve(i,j+1));
    }

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




    }


//        out.flush();



    //------------------------------------if-------------------------------------------------------------------------------------------------------------------------------------------------
    //sieve
    
    static void sort(int[] a) {
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a) l.add(i);
        Collections.sort(l);
        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
    }
    
    
    
    
    static long mod =(long)(1e9+7);
    static long mod(long x) {
        return ((x % mod + mod) % mod);
    }
    
    static long add(long x, long y) {
        return mod(mod(x) + mod(y));
    }
    
    //Fast Power(logN)
    
    
    
    
    
    
    
    
    
    
}
","import java.io.*;
    import java.util.*;
    import java.lang.Math;


    public class Main {

          static Scanner sc;
          static StringBuilder ans;


          /*-------------- for input in an value ---------------------*/
          static int ni()     { return sc.nextInt();       }
          
          
          




          /*-------------- for input in an array ---------------------*/
          
          
              
          


          /*-------------- File vs Input ---------------------*/
          
          static void runIo() throws Exception  {
               sc = new Scanner(System.in);
          }    

          

          

          
          
           
          
                   

          

          

          
  

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

               // runFile();

               runIo();              

               int t;
               t = 1;     
            
               // t =  sc.nextInt();
          
               ans = new StringBuilder();
          
               while( t-- > 0 ) {   
                    solve();
               }                
          
               System.out.println(ans+""""); 
 
          }
    
          static int N ; 
          static int M ; 
          static ArrayList<Integer> f;
          static ArrayList<Integer> e;
          static long dp[][];

          static long find(int i, int j ) {
               
               if( i == N )   return 0;
               if( j == M )   return Integer.MAX_VALUE;


               if (dp[i][j] != -1 )
                    return dp[i][j];

               return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) +  find(i+1, j+1) );
          }       


          public static void solve() {          
          
               int n = ni();
               f = new ArrayList();
               e = new ArrayList();               

               for(int i = 0; i<n; i++) {
                    int v = ni();
                    if( v == 0 ) {
                         e.add(i);
                    }
                    else
                         f.add(i);
               }

               N = f.size();
               M = e.size();               

               dp = new long[N][M];

               for(int i = 0; i<N; i++)
                    Arrays.fill(dp[i], -1);

               ans.append(find(0, 0)+""\n"");
          }
 
     }
",1,Plagiarised
3a318b43,90b71536,"import java.lang.reflect.Array;
import java.util.*;
import java.io.*;
import java.util.regex.Pattern;

public class B2 {

    
    

    
    public static long[] maxBeauty(HashMap[] arr, long[] lv,long[] rv,int start,int parent,boolean[] vis){
        vis[start] = true;
        long[] ans  = new long[2];
       // System.out.println(start);
        ArrayList<Integer> list = new ArrayList<Integer>(arr[start].keySet());
        for(int node:list){
            if(vis[node]==false) {
                long[] curr = maxBeauty(arr,lv,rv,node,start,vis);
                ans[0] += Math.max(curr[0] + Math.abs(lv[start]-lv[node]),curr[1] + Math.abs(lv[start]-rv[node]));
                ans[1]  += Math.max(curr[0] + Math.abs(rv[start]-lv[node]),curr[1] + Math.abs(rv[start]-rv[node]));
            }
        }
        return ans;
    }

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int tc = Integer.parseInt(br.readLine());
        while (tc > 0) {
            int n = Integer.parseInt(br.readLine());
            boolean[] vis = new boolean[n+1];
            HashMap[] arr = new HashMap[n+1];
            for(int i=0;i<=n;i++){
                arr[i] = new HashMap<Integer,Long>();
            }
            long[] lv = new long[n+1];
            long[] rv = new long[n+1];
            for(int i=1;i<=n;i++){
                String[] s1 = br.readLine().split("" "");
                lv[i] = Long.valueOf(s1[0]);
                rv[i] = Long.valueOf(s1[1]);
            }
            for(int i=0;i<n-1;i++){
                String[] s1 = br.readLine().split("" "");
                int u = Integer.valueOf(s1[0]);
                int v = Integer.valueOf(s1[1]);
                arr[u].put(v,1);
                arr[v].put(u,1);
            }

            long[] ans  = maxBeauty(arr,lv,rv,1,0,vis);

            //System.out.println(maxBeauty(graph,lvrv,1,0,0));
            //System.out.println(maxBeauty(graph,lvrv,1,1,0));

            pw.println(Math.max(ans[1],ans[0]));
            tc--;
        }
        pw.close();
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main{
    
 
    
    
    public static void sortbyColumn(int arr[][], int col) 
    { 
        
        Arrays.sort(arr, new Comparator<int[]>() { 
            
           
        });  
    } 
    
    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;
    
        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }
    
        
    
        
    
        
    
        
    
    }
    
    
    
    
    
    
    
    // static void calc(int n){
    //     int i,j;
    //     dp[n-1]=0;
    //     if(n>1)
    //     dp[n-2]=1;
    //     for(i=n-3;i>=0;i--){
    //         long ind=n-i-1;
    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
    //     }
    // }
    
    static long dist[],dp[][],left[],right[];
    static int visited[],isit[];
    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
    //static int dp[][][];
    static int MOD=1000000007;
    static char ch[];
    static int[] sieve,is_sieve;
    static TreeSet<Integer> tr;
    static long mat[][];
    
    // static void bfs(int node,int par,Pair<Long,Long> p[],long taken){
    //     LinkedList<Integer> li=new LinkedList<>();
    //     li.add(node);
        
    //     while(!li.isEmpty()){
    //         int x=li.pollFirst();
    //         long lowNode=p[x-1].x;
    //         long highNode=p[x-1].y;
    //         int left=0,right=0;
    //         visited[x]=1;
    //         for(Pair<Integer,Pair<Long,Long>> pp:adj[x]){
                    
    //                 long max=0;
                    
    //                 if(selected[pp.x]==0){
    //                     max=Math.max(Math.abs(lowNode-pp.y.y),Math.abs(highNode-pp.y.x));
                        
    //                     if(max==Math.abs(lowNode-pp.y.y)){
                            
    //                         left++;
    //                     }else{
                            
    //                         right++;
    //                     }
    //                 }else{
    //                     max=Math.max(Math.abs(lowNode-selected[pp.x]),Math.abs(highNode-selected[pp.x]));
    //                     if(max==Math.abs(lowNode-selected[pp.x])){
                            
    //                         left++;
    //                     }else{
                            
    //                         right++;
    //                     }
    //                 }
    //                 if(visited[pp.x]==0)
    //                 li.add(pp.x);
                
    //         }
    //         if(left>=right){
    //             selected[x]=lowNode;
    //         }else{
    //             selected[x]=highNode;
    //         }
    //     }
    // }
    static void dfs(int node,int par, Pair<Long,Long> p[]){
        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
            if(pp.x!=par){
                //sum+=Math.abs(selected[node]-selected[pp.x]);
                dfs(pp.x,node,p);
                //System.out.println(node+"" ""+pp.x);
                long x=Math.abs(p[node].x-p[pp.x].x);
                long y=Math.abs(p[node].x-p[pp.x].y);
                long z=Math.abs(p[node].y-p[pp.x].x);
                long w=Math.abs(p[node].y-p[pp.x].y);
                
                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
                
            }
        }
    }
    
    public static void main(String args[]){
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter w = new PrintWriter(outputStream);
        int t,i,j,tno=0,tte;
        
        t=in.nextInt();
        //t=1;
        //tte=t;
        
        while(t-->0){
            //sum=0;
            int n=in.nextInt();
            adj=new ArrayList[n+1];
            left=new long[n+1];
            right=new long[n+1];
            visited=new int[n+1];
            for(i=0;i<n+1;i++){
                adj[i]=new ArrayList<>();
            }
            Pair<Long,Long> p[]=new Pair[n+1];
            for(i=1;i<=n;i++){
                p[i]=new Pair<>(in.nextLong(),in.nextLong());
            } 
            for(i=0;i<n-1;i++){
                int u,v;
                u=in.nextInt();
                v=in.nextInt();
                adj[u].add(new Pair<>(v,p[v]));
                adj[v].add(new Pair<>(u,p[u]));
            }
            //bfs(1,-1,p,Long.MAX_VALUE);
            dfs(1,-1,p);
            // for(i=0;i<n+1;i++){
            //     w.print(selected[i]+"" "");
            // }
            // w.println();
            w.println((long)Math.max(left[1],right[1]));
        }
        w.close();
    }
}
",0,Non-plagiarised
12c1cc56,c06c758d,"import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int n=Integer.parseInt(bu.readLine());
        String s[]=bu.readLine().split("" "");
        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
        long dp[][]=new long[n+1][n+1];
        int i,j,a;
        for(i=0;i<n;i++)
        {
            a=Integer.parseInt(s[i]);
            if(a==0) z.add(i);
            else o.add(i);
        }

        for(i=1;i<=o.size();i++)
        {
            long min=dp[i-1][i-1];
            for(j=i;j<=z.size();j++)
            {
                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
                min=Math.min(min,dp[i-1][j]);
            }
        }
        long ans=Long.MAX_VALUE;
        for(i=o.size();i<=z.size();i++)
        ans=Math.min(ans,dp[o.size()][i]);
        System.out.print(ans);
    }
}
","import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int n=Integer.parseInt(bu.readLine());
        String s[]=bu.readLine().split("" "");
        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
        long dp[][]=new long[n+1][n+1];
        int i,j,a;
        for(i=0;i<n;i++)
        {
            a=Integer.parseInt(s[i]);
            if(a==0) z.add(i);
            else o.add(i);
        }

        for(i=1;i<=o.size();i++)
        {
            long min=dp[i-1][i-1];
            for(j=i;j<=z.size();j++)
            {
                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
                min=Math.min(min,dp[i-1][j]);
            }
        }
        long ans=Long.MAX_VALUE;
        for(i=o.size();i<=z.size();i++)
        ans=Math.min(ans,dp[o.size()][i]);
        System.out.print(ans);
    }
}
",1,Plagiarised
06b9cf99,fb69b3b4,"import java.util.*;
import java.io.*;

public class Solution {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer st;

        while (t-- > 0) {

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

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

            st = new StringTokenizer(br.readLine());

            long arr[] = new long[n];
            long tot_sum = 0;
            for(int i = 0; i < n; i++)
            {
            long e = Long.parseLong(st.nextToken());
            arr[i] = e;
            tot_sum+=e;
            }

            if(tot_sum <= k)
            {
                output.write(""0\n"");
                continue;
            }
            Arrays.sort(arr);
            long psum = 0;
            long res = tot_sum - k;
            for(int p = 0; p < n - 1; p++)
            {
                int ind = n - p - 1;
                psum+=arr[ind];
                long sum = arr[0] + psum - tot_sum + k;
                double d = sum / (double)(p + 2);
                long x = (long)Math.floor(d);
                // output.write(""x = "" + x + "" sum = "" + sum + "" d = "" + d + ""\n"");
                long numsteps = Math.max(arr[0] - x, 0) + p + 1;
                if(numsteps < 0)
                    continue;
                // output.write(""for p = "" + p + "" the number of steps req = "" + numsteps + "" and the x = "" + x + ""\n"");
                res = Math.min(res, numsteps);
            }

            output.write(res + ""\n"");

            // int k = Integer.parseInt(st.nextToken());

            // char arr[] = br.readLine().toCharArray();

            // output.write();
            // int n = Integer.parseInt(st.nextToken());

            // HashMap<Character, Integer> map = new HashMap<Character, Integer>();

            // if
            // output.write(""YES\n"");
            // else
            // output.write(""NO\n"");

            // long a = Long.parseLong(st.nextToken());
            // long b = Long.parseLong(st.nextToken());

            // if(flag == 1)
            // output.write(""NO\n"");
            // else
            // output.write(""YES\n"" + x + "" "" + y + "" "" + z + ""\n"");

            // output.write(n+ ""\n"");

        }

        output.flush();

    }

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
public class Main {
    public static long floor(long a, long b) {
        long res = a / b;
        while(res * b > a) res--;
        return res;
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long k = Long.parseLong(st.nextToken());
            st = new StringTokenizer(br.readLine());
            Long[] p = new Long[n];
            for(int i = 0 ;i<n;i++) {
                p[i] = Long.parseLong(st.nextToken());
            }
            Arrays.sort(p);
            long[] sums = new long[n+1];
            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
            long ans = Long.MAX_VALUE;
            for(int y=0;y<n;y++) {
                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
                ans = Math.min(Math.max(x, 0) + y, ans);
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
21123500,fbd26aa0,"import java.io.*;
import java.util.*;

public class Main {
	static class Pair implements Comparable<Pair> {
		int f, s;
		Pair(int f, int s) {
			this.f = f; this.s = s;
		}
		
	}
	public static void main(String[] args) throws IOException {
		PriorityQueue<Pair> pq = new PriorityQueue();
		for (int t = readInt(); t > 0; --t) {
			int n = readInt(), m = readInt(), x = readInt();
			System.out.println(""YES"");
			for (int i = 1; i <= m; ++i) {
				pq.add(new Pair(readInt(), i));
				System.out.print(i + "" "");
			}
			for (int i = m + 1; i <= n; ++i) {
				Pair p = pq.poll();
				p.f += readInt();
				pq.add(p);
				System.out.print(p.s + "" "");
			}
			System.out.println();
			pq.clear();
		}
	}
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
}
","import java.io.*;
import java.util.*;

public class Main {
	static class Pair implements Comparable<Pair> {
		int f, s;
		Pair(int f, int s) {
			this.f = f; this.s = s;
		}
		
	}
	public static void main(String[] args) throws IOException {
		PriorityQueue<Pair> pq = new PriorityQueue();
		for (int t = readInt(); t > 0; --t) {
			int n = readInt(), m = readInt(), x = readInt();
			System.out.println(""YES"");
			for (int i = 1; i <= m; ++i) {
				pq.add(new Pair(readInt(), i));
				System.out.print(i + "" "");
			}
			for (int i = m + 1; i <= n; ++i) {
				Pair p = pq.poll();
				p.f += readInt();
				pq.add(p);
				System.out.print(p.s + "" "");
			}
			System.out.println();
			pq.clear();
		}
	}
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
}
",1,Plagiarised
734a94be,f6ca6fc8,"import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   
	  
	    
	 
	   
	
	   
	     
	   public static void main(String args[]) throws Exception { 
		
		   Scanner sc = new Scanner();
		   StringBuffer res = new StringBuffer();
		   
		   int tc = 1;
		   
		   while(tc-->0) { 
			
			    int n = sc.nextInt();
			    
			    ArrayList<Integer> one = new ArrayList<>();
			    ArrayList<Integer> zero = new ArrayList<>();
			    
			    for(int i=0;i<n;i++) { 
			    	
			    	int x = sc.nextInt();
			    	
			    	if(x==1) { 
			    		one.add(i);
			    	}
			    	else { 
			    		zero.add(i);
			    	}
			    }
			    
			    int dp[][] = new int[one.size()+1][zero.size()+1];
			    
			     for(int i=1;i<=one.size();i++)
			     {
			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
			         for(int j=i+1;j<=zero.size();j++)
			         {
			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
			         }
			     }
			     System.out.println(dp[one.size()][zero.size()]);
		   }
			System.out.println(res);
	   }
}
","import java.util.*;
import java.io.*;

public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		ArrayList<Integer>  o=new ArrayList<Integer>();
		ArrayList<Integer>  e=new ArrayList<Integer>();
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		int dp[][]=new int[o.size()+1][e.size()+1];
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++){
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",1,Plagiarised
07038b12,a18cb2c1,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class h {

	public static int r1=0;
	 
	static long[][] f=new long[501][501];
	public static void main(String[] args)  {
		OutputStream outputStream =System.out;
	    PrintWriter out =new PrintWriter(outputStream);
		FastReader s=new FastReader();
			
		   int t=s.nextInt();
		 while(t>0) {
				int n=s.nextInt();
				for(int i=1;i<=n;i++) {
					vis[i]=0;
					deg[i]=0;
					ans[i]=0;
					f1[i]=new ArrayList<>();
				}
				for(int i=1;i<=n-1;i++) {
					int x=s.nextInt();
					int y=s.nextInt();
					f1[x].add(new pair1(y,i));
					f1[y].add(new pair1(x,i));
					deg[x]++;
					deg[y]++;
				}
//				dfs(1);
				int node=-1;
				boolean p=false;
				for(int i=1;i<=n;i++) {
					if(deg[i]>2) {
						p=true;
					}
					if(deg[i]==1) {
						node=i;
					}
				}
				if(p) {
					out.println(-1);
				}else {
					dfs(node,2);
//					System.out.println();
				for(int i=1;i<=n-1;i++) {
					out.print(ans[i]+"" "");
				}
				out.println();
				}
			 t--;
			   }
			
		
		
	out.close();
	}
	static int[] ans=new int[100001];
	static int[] deg=new int[100001];
	static void dfs(int node,int v) {
		vis[node]=1;
//		deg[node]++;

		for(int i=0;i<f1[node].size();i++) {
			if(vis[f1[node].get(i).a]==0) {
			int g=2;
			if(v==2) {
				g=5;
			}
			ans[f1[node].get(i).b]=v;
				dfs(f1[node].get(i).a,g);
//				deg[node]++;
				
			}
			
		}
	}
//	static long ans(int[] a,int[] b,long till,long[] post,int n,int k,int i) {
//		if(k==0 || i==n) {
//			return till+post[i];
//		}
//		if(f[i][k]!=-1) {
//			return f[i][k];
//		}
//		
//	}
//	static class pair
	static int[] vis=new int[100001];
	static class pair1 {
		private int a;
		private int b;
		pair1(int a,int b){
			this.a=a;
			this.b=b;
		}
		
		
		
	}
	
	
	
	public static int[] is_prime=new int[100001];
	public static ArrayList<Long> primes=new ArrayList<>();
	
	
	static ArrayList<pair1>[] f1=new ArrayList[100001];
	
	
	
	
	
}
","import java.util.*;
import java.io.*;

public class C1627 {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            int[][] edges = new int[n - 1][2];
            int[] deg = new int[n];
            boolean valid = true;
            ArrayList<Integer>[] adjList = new ArrayList[n];
            for (int i = 0; i < n; i++) {
                adjList[i] = new ArrayList<>();
            }
            for (int i = 0; i < n - 1; i++) {
                int u = sc.nextInt() - 1;
                int v = sc.nextInt() - 1;
                edges[i] = new int[]{u, v};
                deg[u]++;
                deg[v]++;
                valid &= deg[u] <= 2 && deg[v] <= 2;
                adjList[u].add(i);
                adjList[v].add(i);
            }
            if (!valid) {
                pw.println(-1);
                continue;
            }
            int root = -1;
            for (int i = 0; i < n; i++) {
                if (adjList[i].size() == 1)
                    root = i;
            }
            int[] ans = new int[n - 1];
            int curColor = 2;
            int par = -1;
            while (true) {
                int nxt = -1;
                for (int e : adjList[root]) {
                    int other = edges[e][0] ^ edges[e][1] ^ root;
                    if (other != par) {
                        ans[e] = curColor;
                        curColor = 5 - curColor;
                        nxt = other;
                        break;
                    }
                }
                if (nxt == -1)
                    break;
                par = root;
                root = nxt;
            }
            for (int x : ans) {
                pw.print(x + "" "");
            }
            pw.println();
        }
        pw.close();
    }

    
}
",0,Non-plagiarised
c9159d9c,f0ede32a,"import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

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

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
",0,Non-plagiarised
584b0e9e,722e318f,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;


public class D_Round_753_Div3 {
    public static int MOD = 1000000007;

    static int[][] dp;


    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // ""output.txt"")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int T = in.nextInt();
        for (int z = 0; z < T; z++) {
            int n = in.nextInt();
            int[] data = new int[n];
            for (int i = 0; i < n; i++) {
                data[i] = in.nextInt();
            }
            String line = in.next();
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (line.charAt(i) == 'B') {
                    blue.add(data[i]);
                } else {
                    red.add(data[i]);
                }
            }
            Collections.sort(blue);
            Collections.sort(red);
            int st = 1;
            boolean ok = true;
            for (int i : blue) {
                if (i < st) {
                    ok = false;
                    break;
                }
                st++;
            }
            if (ok) {
                for (int i : red) {
                    if (i > st) {
                        ok = false;
                        break;
                    }
                    st++;
                }
            }
            out.println(ok ? ""Yes"" : ""No"");
        }
        out.close();
    }

    


    


    

    

    

    

    

    

    

    

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class TaskB {

    static long mod = 1000000007;
    static FastScanner scanner;

    static final StringBuilder result = new StringBuilder();

    public static void main(String[] args) {
        // 2 : 1000000000
        scanner = new FastScanner();
        int T = scanner.nextInt();
        for (int t = 0; t < T; t++) {
            solve(t + 1);
            result.append(""\n"");
        }
        System.out.println(result);
    }

    static void solve(int t) {
        int n = scanner.nextInt();
        int[] a = scanner.nextIntArray(n);
        String s = scanner.nextToken();

        List<Integer> blue = new ArrayList<>();
        List<Integer> red = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'B') {
                blue.add(a[i]);
            } else {
                red.add(a[i]);
            }
        }
        Collections.sort(blue);
        Collections.sort(red);
        for (int i = 0; i < blue.size(); i++) {
            if (blue.get(i) < i + 1) {
                result.append(""NO"");
                return;
            }
        }
        for (int i = 0; i < red.size(); i++) {
            if (red.get(i) > i + 1 + blue.size()) {
                result.append(""NO"");
                return;
            }
        }
        result.append(""YES"");
    }

    

    

    

    

    
}
",0,Non-plagiarised
313b42e6,e45446bc,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Div2 {
  public static void main(String[] args) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String[] s = reader.readLine().split("" "");
    StringBuilder sb = new StringBuilder();
    Div2 div2 = new Div2();
    int t = Integer.parseInt(s[0]);
    while (t-- > 0) {
      s = reader.readLine().split("" "");
      int n = Integer.parseInt(s[0]);
      s = reader.readLine().split("" "");
      long[] cs = new long[n];
      for (int i = 0; i < n; i++) {
        cs[i] = Long.parseLong(s[i]);
      }
      long min1 = cs[0];
      long min2 = cs[1];
      long cost = n * min1 + n * min2;
      long sum = min1 + min2;
      for (int i = 2; i < n; i++) {
        sum += cs[i];
        int count = i / 2;
        if (i % 2 == 0) {
          min1 = Math.min(min1, cs[i]);
          cost = Math.min(cost, sum + (n - count - 1) * min1 + (n - count) * min2);
        } else {
          count++;
          min2 = Math.min(min2, cs[i]);
          cost = Math.min(cost, sum + (n - count) * min1 + (n - count) * min2);
        }
      }
      sb.append(cost).append(""\n"");
    }
    System.out.println(sb.toString());
  }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class C {

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

//	 created by : Nitesh Gupta

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

	}

	

	

	

}
",0,Non-plagiarised
3b498a39,69b2fd22,"import java.util.*;


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

public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];
	 static int max;
	  public static void main(String[] args)
{
		   PrintWriter out=new PrintWriter(System.out);
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		   //ttt =i();
		 
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int A[]=input(n);
	        	dp=new long[n+1][n+1];
	        	for(int i=0;i<=n;i++) {
	        		Arrays.fill(dp[i],-1);
	        	}
		        	
	        	
	        	ArrayList<Integer> l=new ArrayList<Integer>();
	        	ArrayList<Integer> m=new ArrayList<Integer>();
	        	for(int i=0;i<n;i++) {
	        		if(A[i]==0) {
	        			l.add(i+1);
	        		}
	        		else {
	        			m.add(i+1);
	        		}
	        	}
	        	A=new int[m.size()];
	        	int B[]=new int[l.size()];
	        	for(int i=0;i<l.size();i++) {
	        		B[i]=l.get(i);
	        	}
	        	for(int i=0;i<m.size();i++) {
	        		A[i]=m.get(i);
	        	}
	        	n=m.size();
	        	int o=l.size();
		        	System.out.println(go(A,B,0,0,n,o));
	        	
			}

	     //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	//CHECK FOR N=1
       	//CHECK FOR N=1
		        
		     
    }
	  
	 
	  
	  
	
	 
	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
		if(i==n)
			return 0;
		if(j==m)
			return Integer.MAX_VALUE;
		if(dp[i][j]!=-1)
			return dp[i][j];
		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
		long op2=go(A, B, i, j+1, n, m);
		return dp[i][j]=Math.min(op1, op2);
	
		
		
		
		
		}








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

















     static int i() {
    	 return sc.nextInt();
     }
     
     static long l() {
    	 return sc.nextLong();
     }  
     
     
  
  
  
      
      
      
      
     
        
     
}
","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();
    }
    
}
",0,Non-plagiarised
4e28b45e,d7a8434f,"import java.util.*;
import java.io.*;
public class C {

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

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

}
",1,Plagiarised
23cb8587,48801d9e,"import java.io.*;
import java.util.*;

public class C {

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

	public static void main(String[] args) throws IOException {
		Scanner scn = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		StringBuilder sb = new StringBuilder();
		int T = scn.ni(), tcs = 0;
		C: while (tcs++ < T) {
			int n = scn.ni();
			tree = new ArrayList[n + 1];
			range = new long[n + 1][2];
			for (int i = 0; i <= n; i++)
				tree[i] = new ArrayList<>();
			for (int i = 1; i <= n; i++) {
				range[i][0] = scn.nl();
				range[i][1] = scn.nl();
			}
			for (int i = 0; i < n - 1; i++) {
				int x = scn.ni();
				int y = scn.ni();
				tree[x].add(y);
				tree[y].add(x);
			}
			strg = new long[n + 1][2];
			for (long a1[] : strg)
				Arrays.fill(a1, -1L);
			sb.append(Math.max(DFS(1, -1, 0), DFS(1, -1, 1)));
			sb.append(""\n"");
		}
		out.print(sb);
		out.close();
	}

	static ArrayList<Integer> tree[];
	static long range[][], strg[][];

	static long DFS(int u, int pa, int ok) {
		if (strg[u][ok] != -1)
			return strg[u][ok];
		long tg = 0;
		for (int ch : tree[u]) {
			if (ch == pa)
				continue;
			long sg = 0;
			if (ok == 0) {
				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][0] - range[ch][0]),
						DFS(ch, u, 1) + Math.abs(range[u][0] - range[ch][1]));
			} else {
				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][1] - range[ch][0]),
						DFS(ch, u, 1) + Math.abs(range[u][1] - range[ch][1]));
			}
			tg += sg;
		}
		return strg[u][ok] = tg;
	}

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

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

    private static long[][] dp;

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

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

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

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

    

    

    

    

    

    

    // Returns n^(-1) mod p
    

    // Returns nCr % p using Fermat's
    // little theorem.
    
}
",0,Non-plagiarised
99bc7da3,b3638571,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
 
 
public class Codeforces {
	
	static int mod =1000000007; 
	static Set<Integer> set;
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
	    FastScanner fs=new FastScanner();
	    int t=fs.nextInt();
	    while(t-->0) {
	    	int n=fs.nextInt();
	    	int arr[]=new int[n];
//	    	set=new HashSet<>();
	    	for(int i=0;i<n;i++) {
	    		arr[i]=Math.abs(fs.nextInt());
//	    		set.add(arr[i]);
	    	}
//	    	sort(arr);
//	    	for(int i=0;i<n;i++) System.out.print(arr[i]+"" "");
//	    	System.out.println();
//	    	if(set.size()<n||set.contains(0)) {
//	    		System.out.println(""YES"");
//	    		continue;
//	    	}
	    	boolean f=false;
	    	for(int i=0;i<n;i++) {
	    		boolean cur=recur(0,i,arr,0);
	    		if(cur) {
	    			f=true;
	    			break;
	    		}
	    	}
	    	if(f) System.out.println(""YES"");
	    	else System.out.println(""NO"");
	    }
	    out.close();
	}
	static boolean recur(int pos,int ind,int arr[],int sum) {
		if(pos==ind) return recur(pos+1,ind,arr,sum);
		if(sum==arr[ind]) return true;
		if(pos==arr.length) {
			return false;
		}
		
		if(recur(pos+1,ind,arr,sum+arr[pos])) return true;
		if(recur(pos+1,ind,arr,sum)) return true;
		if(recur(pos+1,ind,arr,sum-arr[pos])) return true;
		return false;
	}
	
	
	
	
	
	
	
	
	// 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) {
        MyScanner scan = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

        int t = scan.nextInt();
        for (int i = 0; i < t; i++) {
            int num = scan.nextInt();
            int[] sequence = new int[num];
            for (int j = 0; j < num; j++) {
                sequence[j] = scan.nextInt();
            }

            int[] setSum = new int[(int) Math.pow(3, num)];

            for (int k = 0; k < num; k++) {
                int pot =(int)Math.pow(3, k);
                
                for (int j = 1; j < setSum.length; j++) {
                    if(j % (pot*3) >= pot ){
                        if(j % (pot*3) >= pot){
                            if(j % (pot*3) >= pot*2){
                                setSum[j] += sequence[k];
                            }else{
                                setSum[j] -= sequence[k];
                            }
                        }

                    }
                }
            }
            String output = ""NO"";
            for (int j = 1; j < setSum.length; j++) {
                if(setSum[j] == 0){
                    output = ""YES"";
                    break;
                }
            }
            out.println(output);
        }
        out.close();
    }

    public static PrintWriter out;
    
}
",0,Non-plagiarised
c9159d9c,fae0662f,"import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
	
	public static void main(String[] args) throws IOException {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		
		int t = fs.nextInt();
		for (int tc = 0; tc < t; tc++) {
			int n = fs.nextInt();
			int[] a = fs.readArray(n);
			String s = fs.nextLine();
			
			// let all blue to be 1 -> blueCount
			ArrayList<Integer> blues = new ArrayList<Integer>();
			ArrayList<Integer> reds = new ArrayList<Integer>();
			
			for (int i = 0; i < s.length(); i++) {
				if (s.charAt(i) == 'B') {
					blues.add(a[i]);
				} else {
					reds.add(a[i]);
				}
			}
			
			Collections.sort(blues);
			Collections.sort(reds);
			
			boolean ok = true;
			
			for (int i = 1; i <= blues.size(); i++) {
				if (blues.get(i - 1) < i) {
					ok = false;
					break;
				}
			}
			
			for (int i = blues.size() + 1; i <= n; i++) {
				if (reds.get(i - blues.size() - 1) > i) {
					ok = false;
					break;
				}
			}
			
			if (ok) {
				out.println(""YES"");
			} else {
				out.println(""NO"");
			}
		}
		
		out.close();
	}
	
	
}
",0,Non-plagiarised
a101df86,f0d91796,"import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);

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

		int t = sc.nextInt();

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

			int n = sc.nextInt();

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

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

				pos = 3;
			}

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

			System.out.println(String.join("" "", b));
		}
	}
}
","import java.io.*;
import java.util.*;
 
public class cf {
 
    public static void main(String[] args){
 
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-- > 0){
 			
 			int n=sc.nextInt();
            int arr[]=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
            }
            int ans[]=new int[n];
            if(n%2==0){
                for(int i=0;i<n;i=i+2){
                    ans[i]=-arr[i+1];
                    ans[i+1]=arr[i];
                }
            }
            else{
                if(arr[0]+arr[1]!=0){
                    ans[0]=-arr[2];
                    ans[1]=-arr[2];
                    ans[2]=arr[0]+arr[1];
                }
                else{
                    if(arr[1]+arr[2]!=0){
                        ans[1]=-arr[0];
                        ans[2]=-arr[0];
                        ans[0]=arr[1]+arr[2];
                    }
                    else{
                        ans[0]=-arr[1];
                        ans[2]=-arr[1];
                        ans[1]=arr[0]+arr[2];
                    }
                }
                for(int i=3;i<n;i=i+2){
                    ans[i]=-arr[i+1];
                    ans[i+1]=arr[i];
                }
            }
            for(int j=0;j<n;j++){
                System.out.print(ans[j]+"" "");
            }
            System.out.println();
            

            
            

            

            
           
 			

        }	        	
        	
 			
    }
 
    
    
    
 
}

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


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

//Iterator



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



",0,Non-plagiarised
d12f26f0,df594a00,"import java.io.*;
import java.util.*;

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

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

	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens()) 
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}
	
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
	
	
	static String readLine() throws IOException {
		return br.readLine().trim();
	}
}
","import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int cases = Integer.parseInt(br.readLine());
		while(cases-- > 0) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}
",0,Non-plagiarised
4e87c35b,f1f600d9,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

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

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

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

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

    }
}
","import java.util.*;
import java.lang.Math;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.management.Query;
import java.io.*;
import java.math.BigInteger;

public class Main {
    static int mod = 1000000007;

    /* ======================DSU===================== */
    

    /* ======================================================== */
    

    

    static FastReader f = new FastReader();
    static BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));

    

    

    

    

    

    

    

    

    

    

    /*
     * ===========Modular Operations==================
     */
    

    

    

    

    /*
     * ===============================================
     */
    

    

    

    /*
     * ===========Dynamic prog Recur Section===========
     */

    static int DP[][];
    static ArrayList<ArrayList<Integer>> g;
    static int count = 0;

    

    /*
     * ====================================Main=================================
     */
    public static void main(String args[]) throws Exception {
        // File file = new File(""D:\\VS Code\\Java\\Output.txt"");
        // FileWriter fw = new FileWriter(""D:\\VS Code\\Java\\Output.txt"");
        Random rand = new Random();
        int t = 1;
        t = f.nextInt();
        int tc = 1;
        while (t-- != 0) {
            int n = f.nextInt();
            int c[] = new int[n];
            long minOdd = 0, minEven = 0;
            long sumEven = 0, sumOdd = 0;
            for (int i = 0; i < n ; i++) {
                c[i] = f.nextInt();
                // if (i % 2 == 0) {
                //     minEven = (c[minEven] > c[i]) ? i : minEven;
                //     sumEven += c[i];
                // } else {
                //     minOdd = (minOdd > c[i]) ? i : minOdd;
                //     sumOdd += c[i];
                // }
            }
            minEven = c[0];
            minOdd = c[1];
            sumEven=c[0];
            sumOdd=c[1];
            long min=minEven*n + minOdd*n;//for k=2
            int even=1,odd=1;
            for (int k = 3; k <= n; k++) {
                if(k%2==1){
                    sumEven+=c[k-1];
                    minEven=Math.min(minEven, c[k-1]);
                    even++;
                }else{
                    sumOdd+=c[k-1];
                    minOdd=Math.min(minOdd, c[k-1]);
                    odd++;
                }
                min=Math.min(min, sumEven-minEven+minEven*(n-even+1) + sumOdd-minOdd+minOdd*(n-odd+1));
            }
            w.write(min+""\n"");

        }
        w.flush();
    }
}
",0,Non-plagiarised
c9159d9c,d3a96420,"import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

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

public class Main {
  public static void main(String[] args) {
    Scanner sc= new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0;i<n;i++)a[i]=sc.nextInt();
      String x=sc.next();
      Vector<Integer> R=new Vector<>();
      Vector<Integer> B=new Vector<>();
      for(int i=0;i<n;i++){
        if(x.charAt(i)=='B') R.add(a[i]);
        else B.add(a[i]);
      }
      Collections.sort(R);
      Collections.sort(B);
      boolean yes=true;
      for(int i=0;i<R.size();i++){
        if(R.get(i)-i<1){System.out.println(""NO"");yes=false;break;}
      }
      if(yes)
        {
          int s=B.size();
          for(int j=0;j<s;j++){
            if(B.get(j)+s-j>n+1){System.out.println(""NO"");yes=false;break;}
          }
        }
        if(yes)System.out.println(""YES"");
    }
    sc.close();
  }
}
",0,Non-plagiarised
b08b1c3c,d92b4600,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {

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

    

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            Node head = null;
            boolean notPossible = false;
            for (int i = 0; i < n; i++) {
                int x = sc.nextInt();
                if (head == null) {
                    head = new Node(x);
                } else {
                    if ((head.next != null && x > head.next.value) || (head.prev != null && x < head.prev.value)) {
                        notPossible = true;
                    } else if ((head.next == null || x <= head.next.value) && x > head.value) {
                        if (head.next != null && x == head.next.value) {
                            head = head.next;
                            continue;
                        }
                        Node temp = head.next;
                        Node next = new Node(x);
                        head.next = next;
                        next.prev = head;
                        next.next = temp;
                        if (temp != null) {
                            temp.prev = next;
                        }
                        head = next;
                    } else if ((head.prev == null || x >= head.prev.value) && x < head.value) {
                        if (head.prev != null && x == head.prev.value) {
                            head = head.prev;
                            continue;
                        }
                        Node temp = head.prev;
                        Node prev = new Node(x);
                        head.prev = prev;
                        prev.next = head;
                        prev.prev = temp;
                        if (temp != null) {
                            temp.next = prev;
                        }
                        head = prev;
                    }
                }
            }
            if (notPossible) {
                out.println(""NO"");
            } else {
                out.println(""YES"");

            }        }
        out.close();
    }

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

public class D_724 {

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

	static class ListNode{

		int data;
		ListNode prev;
		ListNode next;

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

	}

}
",0,Non-plagiarised
2eb89317,fcc7e8fa,"import java.util.*;
import java.io.*;

////***************************************************************************
 /* public class E_Gardener_and_Tree implements Runnable{

       public static void main(String[] args) throws Exception {
        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
       }
    public void run(){
         WRITE YOUR CODE HERE!!!!
         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
       }

  }
*/
/////**************************************************************************


public class C_Menorah{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        //PrintWriter out=new PrintWriter(System.out);
        //end of program
        //out.println(answer);
        //out.close();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        
        while(p<t){
        int n=s.nextInt();
        String str1=s.nextToken();
        String str2=s.nextToken();
       
        if(str1.equals(str2)){
            res.append(""0 \n"");
        }
      
        else{
            long count1=0;
            long count0=0;
            for(int i=0;i<n;i++){
                char ch=str1.charAt(i);
                if(ch=='1'){
                    count1++;
                }
            }
            count0=n-count1;
            if(count1==0){
                res.append(""-1 \n"");
            }
            else{
                long nice1=0;
                long nice0=0;
                for(int i=0;i<n;i++){
                    char ch=str2.charAt(i);
                    if(ch=='1'){
                        nice1++;
                    }
                }
                nice0=(n-nice1);
                int check1=0;
                int check2=0;
                if((count1==nice1)&&(count0==nice0)){
                    check1=1;
                }
                long yo1=(1+count0);
                long yo0=(count1-1);
                if((yo1==nice1)&&(yo0==nice0)){
                    check2=1;
                }
                if(check1==0 && check2==0){
                    res.append(""-1 \n"");
                }
                else{
                    //System.out.println(""here"");
                    long correct=0;
                    long wrong=0;
                    long correct1=0;
                    long correct0=0;
                    long wrong1=0;
                    long wrong0=0;
                   
                    for(int i=0;i<n;i++){
                        char ch1=str1.charAt(i);
                        char ch2=str2.charAt(i);
                        if(ch1==ch2){
                            correct++;
                            if(ch1=='1'){
                                correct1++;
                            }
                            else{
                                correct0++;
                            }
                        }
                        else{
                            wrong++;
                            if(ch1=='1'){
                                wrong1++;
                            }
                            else{
                                wrong0++;
                            }
                        }
                    }
              long ans1=      solve(correct1,correct0,wrong1,wrong0,1);
              long ans2=      solve(correct1,correct0,wrong1,wrong0,0);
              long ans=Math.min(ans1,ans2);
              if(ans>=Integer.MAX_VALUE){
                  ans=-1;
              }
              res.append(ans+"" \n"");
                  
                    
                   
                }



            }

        }
        p++;
    }
    
    System.out.println(res);
    
    }
    private static long solve( long correct1, long correct0, long wrong1, long wrong0,long a) {
               long op1=Integer.MAX_VALUE;
               long op2=Integer.MAX_VALUE;
               if(wrong1==0 && wrong0==0){
                   return 0;
               }
               if(a==1){
               {
                   // using correct1
                   if(correct1>0){
                       long newcorrect1=1+wrong0;
                       long newcorrect0=wrong1;
                       long newwrong1=correct0;
                       long newwrong0=correct1-1;
                       op1=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,0));

                   }
               }
            }
            else{

               {
                   //using wrong1
                   {
                       if(wrong1>0){
                        long newcorrect1=wrong0;
                        long newcorrect0=wrong1-1;
                        long newwrong1=1+correct0;
                        long newwrong0=correct1;
                        op2=(1+solve(newcorrect1,newcorrect0,newwrong1,newwrong0,1));
                       }
                   }
               }
            }  
               long ans=Math.min(op1,op2);
               return ans;
    
    }
    


    

  
   // SIMPLE POWER FUNCTION=>


      





}
","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
6e7cd58b,cfba313d,"import java.util.*;
import java.io.*;

public class CodeforcesRound734 {
	static FastReader sc = new FastReader();

	public static void main(String[] args) throws IOException {
		try {
			int t = sc.nextInt();
			while (t-- > 0) {
//				A();
//				B1();
//				B2();
				C();
			}
		} catch (Exception e) {
//			return;
			e.printStackTrace();
		}
	}

	static void C() {
		int n = sc.nextInt();
		int a[][] = new int[5][n];
		for (int i = 0; i < n; i++) {
			String s = sc.next();
			for (int j = 0; j < s.length(); j++) {
				if (s.charAt(j) == 'a')
					a[0][i]++;
				else
					a[0][i]--;
				if (s.charAt(j) == 'b')
					a[1][i]++;
				else
					a[1][i]--;
				if (s.charAt(j) == 'c')
					a[2][i]++;
				else
					a[2][i]--;
				if (s.charAt(j) == 'd')
					a[3][i]++;
				else
					a[3][i]--;
				if (s.charAt(j) == 'e')
					a[4][i]++;
				else
					a[4][i]--;
			}
		}
		for (int x[] : a) {
			Arrays.sort(x);
		}
		int ans = 0;
		for (int i = 0; i < 5; i++) {
			int temp = 0, cnt = 0;
			for (int j = n - 1; j >= 0; j--) {
				temp += a[i][j];
				if (temp <= 0)
					break;
				else
					cnt++;
			}
			ans = Math.max(ans, cnt);
		}
		System.out.println(ans);
	}

	

	

	

	

	

	

}


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


public class C {//Any Class Name
	
	static class Code {
		
		private void solve(InputReader in, OutputWriter out) throws IOException {
			
			ArrayOpn o= new ArrayOpn();
			int t = in.readInt();
			while(t -- > 0) {
			
				int n=in.readInt();
				
				
				int[][] freq= new int[5][n];
				
				for(int i=0; i<n; i++) {
					char s[]= in.readString().toCharArray();
					
					
					for(char e: s) {
						if(e=='a') {
							freq[0][i]++;
						}
						else {
							freq[0][i]--;
						}
						if(e=='b') {
							freq[1][i]++;
						}
						else {
							freq[1][i]--;
						}
						
						if(e=='c') {
							freq[2][i]++;
						}
						else {
							freq[2][i]--;
						}
						if(e=='d') {
							freq[3][i]++;
						}
						else {
							freq[3][i]--;
						}
						if(e=='e') {
							freq[4][i]++;
						}
						else {
							freq[4][i]--;
						}
							
					}
				}
				
				
				for(int i=0; i<5; i++) {
					Arrays.sort(freq[i]);
				}
				
				int ans=0;
				for(int i=0; i<5; i++) {
					int temp=0, count=0;
					for(int j=n-1; j>=0; j--) {
						temp+=freq[i][j];
						if(temp<=0) {
							break;
						}
						count++;
					}
					ans=Math.max(ans, count);
				}
				
				out.printLine(ans);
				
			}
			out.close();
		}
	}
	
	static class ArrayOpn{
		
		
		static final Random random = new Random();
		
		private void sort(int A[]) {
			int n = A.length;
			for(int i=0; i<n; i++)
			{
				int j = random.nextInt(n),temp = A[j];
				A[j] = A[i];
				A[i] = temp;
			}
			Arrays.sort(A);
//            return A;
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
	}
	
	
	
	// Comparator for using in Sorting On integers
	
	
	
	
	public static void main(String[] args) throws IOException {
		//initialize
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Code solver = new Code();
		solver.solve(in, out);
		out.flush();
		out.close();
	}
	
	
	
	
	
	
	
	
	
	
	
}
",1,Plagiarised
4da08761,a5d5a95f,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;

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

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

        


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

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

        


        

    }

    
}
","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();
  int Q = reader.nextInt();
  outer: for (int q = 0; q < Q; q++) {
    int N = reader.nextInt();
    int[][] scores = new int[5][N];
    for (int i = 0; i < N; i++) {
      int[] occurs = new int[5];
      String word = reader.next();
      for (int j = 0; j < word.length(); j++) {
        occurs[word.charAt(j) - 'a']++;
      }
      for (int j = 0; j < 5; j++) {
        scores[j][i] = occurs[j] - (word.length() - occurs[j]) ;
      }
    }
    int bestCount = 0;
    for (int i = 0; i < 5; i++) {
      int[] curr = scores[i];
      Arrays.sort(curr);
      int currentCount = 1;
      int currentScore = curr[curr.length - 1];
      for (int j = curr.length - 2; j >= 0 && currentScore > 0; j--) {
        currentScore += curr[j];
        currentCount++;
      }
      if (currentScore <= 0) currentCount--;
      bestCount = Math.max(currentCount, bestCount);
    }
    System.out.println(bestCount);
  }
}

}
",0,Non-plagiarised
26ad111c,b0a01ee7,"import java.io.*;
import java.util.*;

public class C {
	
	public static void main(String[] args) {
		
		FastReader f = new FastReader();
		StringBuffer sb=new StringBuffer();
		
		int test=f.nextInt();
		while(test-->0)
		{
			int n=f.nextInt();
			String str[]=new String[n];
			for(int i=0;i<n;i++)
				str[i]=f.next();
			int max=0;
			for(char ch='a';ch<='e';ch++)
				max=Math.max(max,solve(str,ch));
			sb.append(max+""\n"");
		}
		System.out.println(sb);
	}
	
	static int solve(String str[],char ch)
	{	
		int count=0;
		int adv=0,equal=0;
		int totalAdv=0;
		List<Integer> c=new ArrayList<>();
		for(int i=0;i<str.length;i++)
		{		
			int countC=0;
			int countTtl=0;
			for(int j=0;j<str[i].length();j++)
			{
				if(str[i].charAt(j)==ch)
					countC++;
				else
					countTtl++;
			}
			if(countC>countTtl)
			{
				adv++;
				totalAdv+=(countC-countTtl);
			}
			else if(countC==countTtl)
				equal++;
			else
				c.add(Math.abs(countTtl-countC));
		}
		if(adv>0)
			count+=adv+equal;
		
		Collections.sort(c);
		for(int i:c)
		{
			if(totalAdv>i)
			{
				totalAdv-=i;
				count++;
			}
		}
		return count;
	}
	
	 
}
","import java.util.*;

public class interestingstory {
    public static void main(String[] args) throws Exception {
       		// your code goes here
		try{    
            Scanner sc =new Scanner(System.in);
            int t=sc.nextInt();
            while(t-->0)
            {
                int n = sc.nextInt();
                int answer = 0;
                String [] string_arr = new String[n];    
                for (int i = 0; i< n; i++){
                    string_arr[i] = sc.next();
                }

                for(char c = 'a'; c <= 'e'; c++){
                    int [] diff = new int[n];

                    for (int j = 0; j < string_arr.length; j++){
                        for(int i = 0; i < string_arr[j].length(); i++){
                            if(string_arr[j].charAt(i) == c){
                                diff[j] += 1;
                            } else {
                                diff[j] += -1;
                            }
                        }
                    }

                    Arrays.sort(diff);
                    int sum = 0;
                    int ans = n;
                    for(int p = n-1; p >= 0;p--){
                        sum += diff[p];
                        if (sum <= 0) {
                            ans = n - p - 1;
                            break;
                        } 
                    }
                    answer = Math.max(answer, ans);
                }

                System.out.println(answer);
            }
         } catch(java.lang.Exception e){}
    }
}
",0,Non-plagiarised
a5d5a95f,ab7507bf,"import java.util.*;
import java.io.*;
public class Main {
// For fast input output

// end of fast i/o code
public static void main(String[] args) {
  FastReader reader = new FastReader();
  int Q = reader.nextInt();
  outer: for (int q = 0; q < Q; q++) {
    int N = reader.nextInt();
    int[][] scores = new int[5][N];
    for (int i = 0; i < N; i++) {
      int[] occurs = new int[5];
      String word = reader.next();
      for (int j = 0; j < word.length(); j++) {
        occurs[word.charAt(j) - 'a']++;
      }
      for (int j = 0; j < 5; j++) {
        scores[j][i] = occurs[j] - (word.length() - occurs[j]) ;
      }
    }
    int bestCount = 0;
    for (int i = 0; i < 5; i++) {
      int[] curr = scores[i];
      Arrays.sort(curr);
      int currentCount = 1;
      int currentScore = curr[curr.length - 1];
      for (int j = curr.length - 2; j >= 0 && currentScore > 0; j--) {
        currentScore += curr[j];
        currentCount++;
      }
      if (currentScore <= 0) currentCount--;
      bestCount = Math.max(currentCount, bestCount);
    }
    System.out.println(bestCount);
  }
}

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

public class C1551 {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();
			char[][] arr = new char[n][];
			for (int i = 0; i < arr.length; i++) {
				arr[i] = sc.next().toCharArray();
			}
			int[][] cnt = new int[n][5];
			for (int i = 0; i < cnt.length; i++) {
				for (char c : arr[i]) {
					cnt[i][c - 'a']++;
				}
			}
			int fans = 0;
			for (int letter = 0; letter < 5; letter++) {
				ArrayList<Integer> al = new ArrayList<Integer>();
				for (int i = 0; i < n; i++) {
					al.add(2 * cnt[i][letter] - arr[i].length);
				}
				Collections.sort(al, Collections.reverseOrder());
				int sum = 0;
				int ans = 0;
				for (int x : al) {
					sum += x;
					if (sum > 0) {
						ans++;
					} else {
						break;
					}
				}
				fans = Math.max(ans, fans);
			}
			pw.println(fans);
		}
		pw.close();
	}

	

}
",0,Non-plagiarised
0588b869,69b2fd22,"import java.util.*;
import java.io.*;
public class Solution
{
    
    static final long mod=(long)1e9+7;
    
    
    /*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();
        int n=fs.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++)
        a[i]=fs.nextInt();
        ArrayList<Integer> o=new ArrayList<>();
        ArrayList<Integer> z=new ArrayList<>();
        for(int i=0;i<n;i++)
        {
            if(a[i]==1)o.add(i);
            else z.add(i);
        }
        int ans[][]=new int[o.size()+1][z.size()+1];
        for(int i=1;i<=o.size();i++)
        {
            for(int j=i;j<=z.size();j++)
            {
                if(i==j)ans[i][j]=ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1));
                else 
                ans[i][j]=Math.min(ans[i][j-1],ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1)));
            }
        }
        pw.println(ans[o.size()][z.size()]);
        pw.flush();
        pw.close();
    }
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
",0,Non-plagiarised
343cc8e7,7f69a9e8,"import java.io.*;
import java.util.*;

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


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

    static class DDiscreteCentrifugalJumps {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            ArrayList<Integer> jumps[] = new ArrayList[n];
            int h[] = new int[n];
            for (int i = 0; i < n; i++) {
                h[i] = in.nextInt();
                jumps[i] = new ArrayList<>();
            }
            Stack<int[]> s = new Stack<>();
            for (int i = 0; i < n; i++) {
                while (s.size() > 0 && s.peek()[0] > h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[i].add(s.peek()[1]);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = 0; i < n; i++) {
                while (s.size() > 0 && s.peek()[0] < h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[i].add(s.peek()[1]);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = n - 1; i >= 0; i--) {
                while (s.size() > 0 && s.peek()[0] < h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[s.peek()[1]].add(i);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            for (int i = n - 1; i >= 0; i--) {
                while (s.size() > 0 && s.peek()[0] > h[i]) {
                    s.pop();
                }
                if (s.size() > 0) {
                    jumps[s.peek()[1]].add(i);
                }
                s.add(new int[]{h[i], i});
            }
            s.clear();
            int dp[] = new int[n];
            dp[0] = 0;
            for (int i = 1; i < n; i++) {
                dp[i] = Integer.MAX_VALUE;
                for (int x : jumps[i]) {
                    dp[i] = Math.min(dp[i], dp[x] + 1);
                }
            }
            out.print(dp[n - 1]);
        }

    }

    
}
",0,Non-plagiarised
3088ca9c,7a9c69d8,"import java.util.*;
import java.io.*;


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

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
",1,Plagiarised
66e74577,6e207cbf,"import java.io.*;
import java.util.*;

public class Menorah {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			String original = in.next();
			String target = in.next();
			int numDiff = 0;
			int original1 = 0;
			int target1 = 0;
			for (int i=0; i<n; i++) {
				if (original.charAt(i)!=target.charAt(i)) {
					numDiff++;
				}
				if (original.charAt(i)=='1') original1++;
				if (target.charAt(i)=='1') target1++;
			}
			int evenAns = Integer.MAX_VALUE;
			int oddAns = Integer.MAX_VALUE;
			if (original1==target1) {
				evenAns = numDiff;
			}
			for (int i=0; i<n; i++) {
				if (original.charAt(i)=='1' && target.charAt(i)=='1') {
					int ones = (n-original1)+1;
					if (ones==target1) {
						oddAns = n-numDiff;
					}
					break;
				}
			}
			for (int i=0; i<n; i++) {
				if (original.charAt(i)=='1' && target.charAt(i)=='0') {
					int ones = (n-original1)+1;
					if (ones==target1) {
						oddAns = Math.min(n-numDiff+1, oddAns);
					}
					break;
				}
			}
			int ans = Math.min(evenAns, oddAns);
			if (ans==Integer.MAX_VALUE) System.out.println(-1);
			else System.out.println(ans);
		}
	}
	
}
","import java.util.*;
import java.lang.*;
import java.io.*;

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



public class test {
	 
	   
	  
	   
	   
	    
	 
	   
	
	   public static void main(String args[]) throws Exception { 
		
		   
		   Scanner sc = new Scanner();
		   StringBuilder res = new StringBuilder();
		 
		   int tc = sc.nextInt();
		  
		   while(tc-->0) { 
			
			   int n=sc.nextInt();
				int k=sc.nextInt();
				
				int[] ac=new int[k];
				
				long[] ans=new long[n];
				Arrays.fill(ans, Integer.MAX_VALUE/2);
				
				for(int i=0;i<k;i++) {
					ac[i]=sc.nextInt()-1;
				}
				for(int i=0;i<k;i++) {
					long x = sc.nextLong();
					
					ans[ac[i]] = x;
				}
				
				
				
				for(int i=1;i<n;i++) {
					ans[i]=Math.min(ans[i], ans[i-1]+1);
				}
				
				for(int i=n-2;i>=0;i--) {
					ans[i]=Math.min(ans[i], ans[i+1]+1);
				}
				
				
               for(int i=0;i<n;i++) {
            	   res.append(ans[i]+"" "");
               }
               
               res.append(""\n"");
		   }
			System.out.println(res);
		   
	   }
}
",1,Plagiarised
595f5d6c,6653a758,"import java.math.BigInteger;
//import static java.lang.Math.max;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;

import java.util.Scanner;

public class ahh {
//trihund
	static Scanner scn = new Scanner(System.in);
	static boolean vis[][];

	

	static FastReader s = new FastReader();
	static int MOD = 1000000007;

	public static void main(String[] args) {
		
		int n=scn.nextInt(),count=0;
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
		{
			arr[i]=scn.nextInt();
		}
		ArrayList<Integer>zer=new ArrayList<Integer>(),one=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(arr[i]==0)
				zer.add(i);
			else
				one.add(i);
		}
		count=one.size();
		long memo[][]=new long[one.size()+1][zer.size()+1];
		for(int i=0;i<=one.size();i++)
		{
			for(int j=0;j<=zer.size();j++)
				memo[i][j]=-1;
		}
		System.out.println(arm(one, zer, 0, 0, count,memo));
				
		
	}

	public static long arm(ArrayList<Integer>one,ArrayList<Integer>zer,int i,int j,int count,long memo[][])
	{	if(count==0)
		return 0;
		if(i==one.size()||j==zer.size())
			return Integer.MAX_VALUE;
		
		if(memo[i][j]!=-1)
			return memo[i][j];
		
		long a=Integer.MAX_VALUE,b=Integer.MAX_VALUE;
		a=arm(one, zer, i+1, j+1,count-1,memo)+Math.abs(one.get(i)-zer.get(j));
		b=arm(one, zer, i, j+1,count,memo);
		memo[i][j]=Math.min(a, b);
		return Math.min(a, b);
	}
	

	

	

}








","import java.util.*;
public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",0,Non-plagiarised
0f14b12d,7d12d33c,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.*;
import java.util.*;

import javax.management.Query;
public class Test{
    public static void main(String[] args) throws IOException, InterruptedException{
      Scanner sc = new Scanner(System.in);
     int t = sc.nextInt();
    
     while(t-->0){
      int n = sc.nextInt();
      String [] words = new String[n];
      int [] occ = new int[5];
      int [] occWord = new int [5];
      boolean []  found ;
      for(int i =0;i<n;i++){
        words[i] = sc.nextLine();
        found = new boolean[5];
        for(int j=0 ; j<words[i].length();j++){
          occ[words[i].charAt(j)-'a']++;
          if(!found[words[i].charAt(j)-'a']){
            found[words[i].charAt(j)-'a']=true;
            occWord[words[i].charAt(j)-'a'] ++;
          }
        }
      }
      int maxRes =0;
      for(int i =0;i<5;i++){
      int maxChar = 'a' +i;
      
      PriorityQueue<Pair> pq = new PriorityQueue<>();
      for (String word : words){
          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
      }
      int res = 0;
      int curr = 0;
      int maxCharCount = 0;
      int otherCharCount =0;
      while(!pq.isEmpty()){
        String word = pq.poll().x;
        maxCharCount +=occOfMaxChar(word, maxChar);
         otherCharCount += occOfOtherChar(word, maxChar);
         curr ++;
         if(maxCharCount >otherCharCount){
           res = curr;
         }
          
      }
      maxRes = Math.max(maxRes, res);
    }
    System.out.println(maxRes);}
   
  }
  public static int occOfMaxChar (String s, int maxChar){
     int occ = 0;
     for(int i =0 ;i<s.length();i++){
       if(s.charAt(i)==maxChar){
         occ++;
       }
      }
      return occ;
  }
  public static int occOfOtherChar (String s, int maxChar){
    int occ = 0;
    for(int i =0 ;i<s.length();i++){
      if(s.charAt(i)!=maxChar){
        occ++;
      }
     }
     return occ;
 }

    static int w;
    static int n;
    static long [][] memo;
    static int [] depth ;
    static long[] values;
    static ArrayList<Pair> gold ;
    


    static class Pair implements Comparable {
      String x;
      int y;
      public Pair (String x, int y) {
        this.x = x;
        this.y = y;
      }
      
    }
    
     }
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.*;
import java.util.*;

import javax.management.Query;
public class Test{
    public static void main(String[] args) throws IOException, InterruptedException{
      Scanner sc = new Scanner(System.in);
     int t = sc.nextInt();
    
     while(t-->0){
      int n = sc.nextInt();
      String [] words = new String[n];
     
      for(int i =0;i<n;i++){
        words[i] = sc.nextLine();
       
      }
      int maxRes =0;
      for(int i =0;i<5;i++){
      int maxChar = 'a' +i;
      
      PriorityQueue<Pair> pq = new PriorityQueue<>();
      for (String word : words){
          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
      }
      int res = 0;
      int curr = 0;
      int maxCharCount = 0;
      int otherCharCount =0;
      while(!pq.isEmpty()){
        String word = pq.poll().x;
        maxCharCount +=occOfMaxChar(word, maxChar);
         otherCharCount += occOfOtherChar(word, maxChar);
         curr ++;
         if(maxCharCount >otherCharCount){
           res = curr;
         }
          
      }
      maxRes = Math.max(maxRes, res);
    }
    System.out.println(maxRes);}
   
  }
  public static int occOfMaxChar (String s, int maxChar){
     int occ = 0;
     for(int i =0 ;i<s.length();i++){
       if(s.charAt(i)==maxChar){
         occ++;
       }
      }
      return occ;
  }
  public static int occOfOtherChar (String s, int maxChar){
    int occ = 0;
    for(int i =0 ;i<s.length();i++){
      if(s.charAt(i)!=maxChar){
        occ++;
      }
     }
     return occ;
 }

    static int w;
    static int n;
    static long [][] memo;
    static int [] depth ;
    static long[] values;
    static ArrayList<Pair> gold ;
    


    static class Pair implements Comparable {
      String x;
      int y;
      public Pair (String x, int y) {
        this.x = x;
        this.y = y;
      }
      
    }
    
     }
",1,Plagiarised
c287ea9d,d2901569,"import java.util.*;
import java.io.*;

public class monstersandspells {
	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		/*
1
5
1 5 8 9 10
1 2 6 1 2
		 */
		int t = in.nextInt();
		
		for ( ; t > 0; t--) {
			
			int n = in.nextInt();
			
			long[] times = new long[n];
			long[] health = new long[n];
			for (int i = 0; i < n; i++)
				times[i] = in.nextLong();
			for (int i = 0; i < n; i++)
				health[i] = in.nextLong();
			
			long small = 0;
			long prev = 0;
			long lastDamage = 0;
			
			for (int i = 0; i < n; i++) {
				long diff = times[i] - prev;
				boolean use = true;
				long delta = 0;
				//System.out.println(i + "" "" + times[i] + "" "" + diff);
				if (diff >= health[i]) {
					delta += health[i];
					long curr = health[i];
					long lastTime = times[i];
					for (int j = i + 1; j < n; j++) {
						long increase = times[j] - lastTime;
						//long power = damageOverTime(increase + curr, curr + 1);
						if (curr + increase >= health[j]) {
							curr += increase;
							lastTime = times[j];
						}
						else {
							delta += (health[j] - (curr + increase));
							curr = health[j];
							lastTime = times[j];
						}
					}
					if (delta <= diff) {
						use = true;
					}
					else
						use = false;
				}
				else
					use = false;
				
				if (use) {
					//System.out.println(damageOverTime(health[i], 1));
					small += damageOverTime(delta, 1);
					lastDamage = delta;
				}
				else {
					small += damageOverTime((times[i] - prev) + lastDamage, lastDamage + 1);
					lastDamage+=(times[i] - prev);
				}
				// System.out.println(use + "" "" + delta + "" "" + lastDamage + "" "" + small);
				prev = times[i];
			}
			
			out.println(small);
		}
		
		out.close();
	}
	
	public static long damageOverTime(long endPower, long startPower) {
		return triangleSum(endPower) - triangleSum(startPower - 1);
	}
	
	public static long triangleSum(long a) {
		return a * (a + 1) / 2;
	}
	
	
}
","import java.util.*;
import java.util.Scanner;


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

		Scanner sc=new Scanner(System.in);
		int tt=sc.nextInt();
//		
//		
		while(tt-->0){
				int n=sc.nextInt();
			
				int k[]=new int[n];
				int h[]=new int[n];
				
				for(int i=0;i<n;i++) {
					k[i]=sc.nextInt();
				}
				for(int i=0;i<n;i++) {
					h[i]=sc.nextInt();
				}
				long ans=0;
				int start=k[0]-h[0]-1;
				int end=k[0];
				int last=0;
				for(int j=0;j<n;j++) {
					 start=k[j]-h[j]+1;
					 end=k[j];
					 last=j;
				for(int i=j+1;i<n;i++) {
					int temp=k[i]-h[i]+1;
					
					if(temp<=end) {
						start=Math.min(start, temp);
						end=Math.max(end, k[i]);
						last=i;
					}
					
					
					
				}
				j=last;
				
				long va=end-start+1;
				
				ans+=(va*(va+1))/2;
				
				}
				System.out.println(ans);
				
			
		}
	}
		
		
	
		
		
	
	
	


}
",0,Non-plagiarised
54d7c21e,a7e7f371,"import java.io.*;
import java.util.*;


public class cp {
	
//	static  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...
 */
	
	
	
	
	
	
	
	
	
	
	

	    // function to find last index <= y
    
     
	
	
	
          
	
	
	
	
	 
	// 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
	
	
	
	
	
	 static ArrayList<Integer> ans;
	
	
	
	
	
	
	
	
	
		
	


	

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

}
",1,Plagiarised
4548305b,c0aa6246,"import java.util.function.Consumer;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.io.*;
import java.lang.Math.*;

 public class KickStart2020{
	
	
	
	
	 
	
	
	
	
	 
	 
	 
	 
		public static void main(String[] args) throws Exception{
			FastReader sc = new FastReader();
			PrintWriter out = new PrintWriter(System.out);
          int t = sc.nextInt();
          while(t-- > 0) {
           int n = sc.nextInt();
           int k = sc.nextInt();
           int arr[] = new int[k];
           int temp[] = new int[k];
           for(int i = 0; i < k; i++) arr[i] = sc.nextInt();
           for(int i = 0; i < k; i++) temp[i] = sc.nextInt();
           long brr[] = new long[n];
           Arrays.fill(brr, Integer.MAX_VALUE);
           for(int i = 0; i < k; i++) brr[arr[i] - 1] = temp[i];
           for(int i = 1; i < n; i++) {
        	   brr[i] = Math.min(brr[i], brr[i - 1] + 1);
           }
           for(int i = n - 2; i >= 0; i--) {
        	   brr[i] = Math.min(brr[i], brr[i + 1] + 1);
           }
           for(long e: brr) out.print(e + "" "");
           out.println();
             
          }
                 out.close();
			}
		}
","import java.util.*;
import java.util.Map.Entry;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;


public class CF {
	private static FS sc = new FS();
	
	
	
	private static class extra {
		
		static int[] intArr(int size) {
			int[] a = new int[size];
			for(int i = 0; i < size; i++) a[i] = sc.nextInt();
			return a;
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	}
	
	static int mod = (int) 1e9 + 9;
//	static int mod = (int) 998244353;
	static int max = (int) 1e6, sq = 316;
	static LinkedList<Integer>[] temp;
//	static int[] par, rank;
	
	public static void main(String[] args) {	
		int t = sc.nextInt();
//		int t = 1;
		StringBuilder ret = new StringBuilder();
		while(t-- > 0) {
			int n = sc.nextInt(); int m = sc.nextInt();
			int[] a = extra.intArr(m);
			int[] b = extra.intArr(m);
			long[] c = new long[n];
			Arrays.fill(c, (int)1e18);
			for(int i = 0; i < m; i++) c[a[i]-1] = b[i];
			long[] l = new long[n];
			long[] r = new long[n];
			Arrays.fill(l, (int)1e18);
			Arrays.fill(r, (int)1e18);
			long min = (long)1e18;
			for(int i = 0; i < n; i++) {
				min = Math.min(min+1, c[i]);
				l[i] = min;
			}
			min = (int)1e18;
			for(int i = n-1; i >= 0; i--) {
				min = Math.min(min+1, c[i]);
				r[i] = min;
			}
			for(int i = 0; i < n; i++) {
				ret.append(Math.min(l[i], r[i]) + "" "");
			}
			ret.append(""\n"");
 		}
		System.out.println(ret);
	}
	
}
",0,Non-plagiarised
b434c275,f8c99dd0,"import java.io.*;
import java.util.*;



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


public final class A
{    
	static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	//	static 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.util.*;
import java.io.*;

public class Solution {
  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  public static void solve() throws IOException {
    int n = Integer.parseInt(br.readLine());
    ArrayList<int[]> words = new ArrayList<>();
    ArrayList<Integer> lens = new ArrayList<>();
    //count [a,b,c,d,e]
    for (int i = 0; i < n; i++) {
      String temp = br.readLine();
      int[] word = new int[5];
      for (int j = 0; j < temp.length(); j++) {
        word[(int)(temp.charAt(j)) - 97]++;
      }
      words.add(word);
      lens.add(temp.length());
    }
    int ans = 0;
    for (int i = 0; i < 5; i++) {
      ArrayList<Integer> sums = new ArrayList<>();
      //target occ - other occ
      for (int j = 0; j < words.size(); j++) {
        sums.add(words.get(j)[i] - (lens.get(j) - words.get(j)[i]));
      }
      Collections.sort(sums);
      int loc = 0;
      int run = 0;
      for (int j = sums.size() - 1; j >= 0; j--) {
        if(run + sums.get(j) > 0) {
          loc++;
          run += sums.get(j);
        }
        else break;
      }
      ans = Math.max(ans, loc);
    }
    System.out.println(ans);
  }
  public static void main(String[] args) throws IOException {
    int t = Integer.parseInt(br.readLine());
    for (int i = 0; i < t; i++) {
      solve();
    }
  }
}
",0,Non-plagiarised
0df4050e,f5fde094,"import java.io.*;
import java.util.*;

public class MainClass {
    public static void main(String[] args) {
        Reader in = new Reader(System.in);
        int t = in.nextInt();
        StringBuilder stringBuilder = new StringBuilder();
        while (t-- > 0) {
            ArrayList<Integer> reds = new ArrayList<>();
            ArrayList<Integer> blue = new ArrayList<>();
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt() - 1;
            }
            char[] s = in.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (s[i] == 'R') {
                    reds.add(a[i]);
                } else {
                    blue.add(a[i]);
                }
            }
            Collections.sort(reds, Collections.reverseOrder());
            Collections.sort(blue);
            boolean ff = true;
            int start = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < start) {
                    ff = false;
                    break;
                }
                start++;
            }
            start = n - 1;
            for (int i = 0; i < reds.size(); i++) {
                if (reds.get(i) > start) {
                    ff = false;
                    break;
                }
                start--;
            }
            stringBuilder.append(ff?""YES"":""NO"").append(""\n"");
        }
        System.out.println(stringBuilder);
    }
}

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

public class Solution {

    static HritikScanner sc = new HritikScanner();
    static PrintWriter pw = new PrintWriter(System.out, true);
    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) {

        int t = ni();
        while (t-- > 0) {
            solve();
        }
    }

    static void solve() {
        int n = ni();
        int[] arr = nextIntArray(n);
        char[] col = sc.next().toCharArray();
        int[] cB = new int[n+1];
        int[] cR = new int[n+1];
        for(int i = 0; i < n; i++)
        {
//            pl((col[i] == 'R' && arr[i] > n));
//            pl((col[i] == 'B' && arr[i] < 1));
            if((col[i] == 'R' && arr[i] > n)||(col[i] == 'B' && arr[i] < 1))
            {
                System.out.println(""NO"");
                return;
            }
            if(col[i] == 'B')
            {
                if(arr[i] > n)
                    continue;
                cB[arr[i]]++;
                if(cB[arr[i]] > arr[i])
                {
                    System.out.println(""NO"");
                    return;
                }
            }
            else
            {
                if(arr[i] < 1)
                    continue;
                cR[arr[i]]++;
                if(cR[arr[i]] > (n-(arr[i]-1)))
                {
                    System.out.println(""NO"");
                    return;
                }
            }
//            pa(cB);
//            pa(cR);
        }
//        pa(cB);
//        pa(cR);
        int[] psum = new int[n+1];
        for(int i = 1; i<= n; i++)
        {
            psum[i] = psum[i-1]+cB[i];
            if(psum[i] > i)
            {
                System.out.println(""NO"");
                return;
            }
        }
//        pa(psum);
        int[] psum1 = new int[n+1];
        psum1[n] = cR[n];
        for(int i = n-1; i>= 0; i--)
        {
            psum1[i] = psum1[i+1]+cR[i];
            if(psum1[i] > (n-(i-1)))
            {
                System.out.println(""NO"");
                return;
            }
        }
//        pa(psum1);
        
        System.out.println(""YES"");
        
    }
        /////////////////////////////////////////////////////////////////////////////////
    

    /////////////////////////////////////////////////////////////////////////////////
    static int[] nextIntArray(int n) {
        int[] arr = new int[n];
        int i = 0;
        while (i < n) {
            arr[i++] = ni();
        }
        return arr;
    }

    

    

    /////////////////////////////////////////////////////////////////////////////////
    static int ni() {
        return sc.nextInt();
    }

    

    

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

    

    

    

    

    

    

    

    

    

    

    

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

    /////////////////////////////////////////////////////////////////////////////////
    //-----------HritikScanner class for faster input----------//
    

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

    //////////////////////////////////////////////////////////////////
    // Function to return gcd of a and b time complexity O(log(a+b))
    

    // method to return LCM of two numbers 
    

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

    

    

    

    

    //////////////////////////////////////////////////////////////////
    // method returns Nth power of A 
    

}
",0,Non-plagiarised
73f57af1,ac8ef97c,"import java.util.*;
import java.lang.*;
import java.io.*;

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

    /*-------- I/O usaing short named function ---------*/
	
	public static int ni(){return scan.nextInt();}
	public static long nl(){return scan.nextLong();}
	
	
	
	
	public static void pn(Object o){out.println(o);}
    /*-------- for output of an array ---------------------*/
     
	
	
	
    /*-------------- for input in an array ---------------------*/
	
	
	
	
	/*------------ 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
	 

    static long[] l, r;
	public static void main (String[] args) throws java.lang.Exception
	{
		OutputStream outputStream =System.out;
        out =new PrintWriter(outputStream);
        scan =new FastReader();
		//for fast output sometimes
		StringBuilder sb = new StringBuilder();
		int t = ni();
		while(t-->0){
			int n = ni();
			l = new long[n];
			r = new long[n];

			for(int i=0; i<n; i++){
				l[i] = nl();
				r[i] = nl();
			}

			//lPA(l);
			//lPA(r);

			ArrayList<Integer> adj[] = new ArrayList[n];
			for(int i=0; i<n; i++)
				adj[i] = new ArrayList<Integer>();

			for(int i=0; i<n-1; i++){
				int u = ni()-1, v = ni()-1;
				adj[u].add(v);
				adj[v].add(u);
			}

			dp = new Long[n][2];
			visited = new boolean[n];
			long ans = Math.max(solve(adj, 0, 0, visited), solve(adj, 0, 1, visited));
			pn(ans);
        }
        out.flush();
		out.close();
	}

	static Long dp[][];
	static boolean visited[];
	static long solve(ArrayList<Integer> adj[], int vertex, int prev, boolean visited[]){

		visited[vertex] = true;
		if(dp[vertex][prev] != null)
			return dp[vertex][prev];
		long ans = 0;
		for(int x : adj[vertex]){
			if(!visited[x]){
				if(prev == 0){
					ans += Math.max(Math.abs(l[vertex] - l[x]) + solve(adj, x, 0, visited),
						Math.abs(l[vertex] - r[x]) + solve(adj, x, 1, visited));
					//pn(vertex + "" "" + x + "" "" + ans);
				}else{
					ans += Math.max(Math.abs(r[vertex] - l[x]) + solve(adj, x, 0, visited),
						Math.abs(r[vertex] - r[x]) + solve(adj, x, 1, visited));
					//pn(vertex + "" "" + x + "" "" + ans);
				}
			}
		}
		visited[vertex] = false;
		//pn(ans);
		return dp[vertex][prev] = ans;	
	}
	
	
}
","import java.io.*;
import java.util.*;

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

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

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

    static ArrayList<Integer> g[];
    static int N=100000,a[][]=new int[N][2];
    static long s[][]=new long[N][2];
    static void dfs(int n,int p)
    {
        for(int x:g[n])
        if(x!=p)
        {
            dfs(x,n);
            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
        }
    }
}
",0,Non-plagiarised
5b9a0551,9debf95c,"import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class Main {

    public static void main(String[] args) {
        FastScanner in=new FastScanner();
        PrintWriter out=new PrintWriter(System.out);
        int t=in.nextInt();
        while(t-->0)
        solve(in,out);
        out.close();
    }
    static void solve(FastScanner in,PrintWriter out){
        int n=in.nextInt();
        long a[]=new long[n];
        for (int i = 0; i < n; i++) {
            a[i]=in.nextLong();
        }
        long odd=Integer.MAX_VALUE,even=Integer.MAX_VALUE;
        even=a[0];
        long sum=a[0];
        long ans=Long.MAX_VALUE;
        for (int i = 1; i < n; i++) {
            if(i%2==0) {
                ans=Math.min(ans,(n-i/2)*a[i] + odd*(n-i/2) +sum);
                even=Math.min(even,a[i]);
            } else {
                ans=Math.min(ans,(n-i/2)*a[i] + even*(n-i/2-1) +sum);
                odd=Math.min(odd,a[i]);
            }
            sum+=a[i];
        }
        out.println(ans);
    }

    

    

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


    }


}







",0,Non-plagiarised
0ca738ce,931faca2,"import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class G {

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

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

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

            int have = 0;
            long ans = 0;

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

        }

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

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

            
        }


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

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


    }

    

    

    

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



public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static int dp[][][][];
	 static int mod=1000000007;
	 static int mod1=998244353;
	 static int max;
	 static long bit[];
	 static long seg[];
	 static long fact[];
	 static long A[];
	 static long[] fac = new long[300001];
	   static PrintWriter out=new PrintWriter(System.out);
	  public static void main(String[] args)
{
		    //CHECK FOR N=1
	       	//CHECK FOR N=1
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		     // ttt =i();
		 
	      fac[0] = 1;

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

	        	System.out.println(ans);
	        	
	        	
	        }
	        //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	
		        
		     
    }
	  
	  static long modInverse(long n, int p)
	    {
	        return power(n, p - 2, p);
	    }
	 
	    // Returns nCr % p using Fermat's
	    // little theorem.
	    static long nCrModPFermat(int n, int r,
	                             int p)
	    {
	 
	          if (n<r)
	              return 0;
	      // Base case
	        if (r == 0)
	            return 1;
	        
	 
	        return (fac[n] * modInverse(fac[r], p)
	                % p * modInverse(fac[n - r], p)
	                % p)
	            % p;
	    }


static class Pair implements Comparable<Pair>
     {
    	 int x;
    	 int y;
    	 Pair(int x,int y){
    		 this.x=x;
    		 this.y=y;
    		 
    	 }
		
//		public int hashCode() 
//		{ 
//			final int temp = 14; 
//			int ans = 1; 
//			ans =x*31+y*13; 
//			return ans; 
//		} 
//		@Override
//		public boolean equals(Object o) 
//		{ 
//			if (this == o) { 
//				return true; 
//			} 
//			if (o == null) { 
//				return false; 
//			} 
//			if (this.getClass() != o.getClass()) { 
//				return false; 
//			} 
//			Pair other = (Pair)o; 
//			if (this.x != other.x || this.y!=other.y) { 
//				return false; 
//			} 
//			return true; 
//		} 	
//		
		/* FOR TREE MAP PAIR USE */
		
//		public int compareTo(Pair o) {
// 			if (x > o.x) {
// 				return 1;
// 			}
// 			if (x < o.x) {
// 				return -1;
// 			}
// 			if (y > o.y) {
// 				return 1;
// 			}
// 			if (y < o.y) {
// 				return -1;
// 			}
// 			return 0;
// 		}
		
     }
//FENWICK TREE



//END
//static void add(int v) {
//	if(!map.containsKey(v)) {
//		map.put(v, 1);
//	}
//	else {
//		map.put(v, map.get(v)+1);
//	}
//}
//static void remove(int v) {
//	if(map.containsKey(v)) {
//		map.put(v, map.get(v)-1);
//		if(map.get(v)==0)
//			map.remove(v);
//	}
//}












































static long power(long x, long y, long p)
{

	if(y==0)
		return 1;
	if(x==0)
		return 0;
    long res = 1;
    x = x % p;

    while (y > 0) {

        if (y % 2 == 1)
            res = (res * x) % p;

        y = y >> 1; 
        x = (x * x) % p;
    }

    return res;
}





     static int i() {
    	 return sc.nextInt();
     }
     
       
     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();
  }
  
  
      
      
      
      
     
        
     
}
",0,Non-plagiarised
0c00d532,521c5645,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class First {

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

    }

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

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
                if(i==0){
                    array[i] = arr[i];
                }
                else
                    array[i] = (long)arr[i] + array[i-1];
            }

            int evenMin = arr[0], oddMin = arr[1];

            long ans = ((long) n * (long)arr[0]) + ((long) n * (long)arr[1]);

            for (int i = 2; i < n; i++) {
                if(i%2==0){
                    if(evenMin>arr[i]) {
                        evenMin = arr[i];
                    }
                }
                else{
                    if(oddMin>arr[i]) {
                        oddMin = arr[i];
                    }
                }
                if(i%2==0){
                    ans = Math.min(ans, array[i] + (long) ((n - (i / 2)) - 1) * (long)evenMin + (long) ((n - ((i-1) / 2)) - 1) * (long)oddMin );
                }
                else{
                    ans = Math.min(ans, array[i] + (long) ((n - (i / 2)) - 1) * (long)oddMin + (long) ((n - ((i-1) / 2)) - 1) * (long)evenMin);
                }

            }
            out.println(ans);





        }
    }

    

    

    

    

    

    

    static final Random random=new Random();

    

    
}
","import java.io.*;

import java.util.*;
/*


 */



public class C {
    static FastReader sc=null;
 
    
    public static void main(String[] args) {
    	sc=new FastReader();
    	int t=sc.nextInt();
    	while(t-->0) {
    		int n=sc.nextInt();
    		int c[]=sc.readArray(n);
    		long dp[]=new long[n];
    		dp[0]=Long.MAX_VALUE;
    		dp[1]=(long)n*c[1]+ (long)n*c[0];
    		long preMin[]=new long[n],pre[]=new long[n];
    		preMin[0]=pre[0]=c[0];
    		preMin[1]=pre[1]=c[1];
    		for(int i=2;i<n;i++) {
    			preMin[i]=Math.min(preMin[i-2],c[i]);
    			pre[i]=pre[i-2]+c[i];
    		}
    		for(int i=2;i<n;i++) {
    			dp[i]=preMin[i]*(n-i/2)+pre[i]-preMin[i]+preMin[i-1]*(n-(i-1)/2)+pre[i-1]-preMin[i-1];
    		}
    		long ans=Long.MAX_VALUE;
    		//print(dp);
    		for(long e:dp)ans=Math.min(ans, e);
    		System.out.println(ans);
    	}
    	
    	
    }
  
  
   
    
    
   
 
   
    
    
    
    
    
 
       
        
 
    
    
    
    
    
    
    
    
    
    
     
}
",0,Non-plagiarised
9291ca83,b185d034,"import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Practice {
    static HashMap<String, Integer> map = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            int[][] occurances = new int[5][n];
            for(int i=0;i<n;i++){
                String s = sc.next();
                int[] count = new int[5];
                int len = s.length();
                for(int j=0;j<s.length();j++){
                    count[s.charAt(j)-'a']++;
                }
                for(int j=0;j<5;j++){
                    occurances[j][i] = count[j] - (len-count[j]);
                }
            }
            int ans = 0;
            for(int i=0;i<5;i++){
                Arrays.sort(occurances[i]);
                int tmpAns = 0; int tmpSum=0;
                for(int j=n-1;j>=0;j--){
                    tmpSum+=occurances[i][j];
                    if(tmpSum>0) tmpAns++;
                    else break;
                }
                ans = Math.max(ans, tmpAns);
            }
            System.out.println(ans);
        }
    }
}
","import java.io.*;
import java.util.*;
public class A734C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        loop:while(t-->0){
            int n = scan.nextInt();
            String[] arr= new String[n];
            Integer[][] counts = new Integer[5][n];
            for(int i = 0;i<5;i++){
                for(int j = 0;j<n;j++){
                    counts[i][j] = 0;
                }
            }
            for(int i =0;i<n;i++){
                arr[i] = scan.next();
                int[] freq =new int[5];
                for(int j = 0;j<arr[i].length();j++){
                    freq[arr[i].charAt(j)-'a']++;
                }
                for(int j = 0;j<5;j++){
                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
                }
            }
            int best = 0;
            for(int i = 0;i<5;i++){
                Arrays.sort(counts[i]);
                int curr = 0;
                int extra = 0;
                for(int j = n-1;j>=0;j--){
                    extra+=counts[i][j];
                    if(extra>0)curr++;
                }
                best = Math.max(best,curr);
            }
            System.out.println(best);

        }
    }
    
}
",1,Plagiarised
80881cae,f8e7b886,"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;			
//		}
	}
}
","import java.util.*;
import java.io.*;
import java.time.*;
import static java.lang.Math.*;

@SuppressWarnings(""unused"")
public class C {
	static boolean DEBUG = false;

	static Reader fs;
	static PrintWriter pw;

	static void solve() {
		int n = fs.nextInt(), k[] = fs.readArray(n), h[] = fs.readArray(n);
		int prev_h = h[0], prev_k = k[0];
//		int ans = 0;
		ArrayList<pair> intervals = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int start = k[i] - h[i] + 1;
			int end = k[i];
			intervals.add(new pair(start, end));
		}
//		pw.println(intervals);
		Collections.sort(intervals);
		ArrayList<pair> merged = new ArrayList<>();
		merge(intervals, merged);
		long ans = 0;
		for(int i = 0 ; i < merged.size() ; i++) {
			ans += sum(merged.get(i).len());
		}
		pw.println(ans);
	}
	
	static void merge(ArrayList<pair>a1, ArrayList<pair>a2) {
		int n = a1.size();
		int index = 0;
		for(int i =1 ; i < n ; i++) {
			if(a1.get(index).s >= a1.get(i).f) {
				a1.get(index).s = max(a1.get(index).s, a1.get(i).s);
			}
			else {
				index++;
				a1.set(index, a1.get(i));
			}
		}
		for(int i = 0 ; i <= index ; i++) {
			a2.add(a1.get(i));
		}
//		pw.println(a1);
	}
	
//	int index = 0; // Stores index of last element 
//    // in output array (modified arr[]) 
//
//    // Traverse all input Intervals 
//    for (int i=1; i<arr.length; i++) 
//    { 
//        // If this is not first Interval and overlaps 
//        // with the previous one 
//        if (arr[index].end >=  arr[i].start) 
//        { 
//               // Merge previous and current Intervals 
//            arr[index].end = Math.max(arr[index].end, arr[i].end); 
//        } 
//        else {
//            index++;
//            arr[index] = arr[i]; 
//        }    
//    }
	
	
	
	static pair merge(pair p1, pair p2) {
		return new pair(min(p1.f, p2.f), max(p1.s, p2.s));
	}

	static long sum(long n) {
		return (n * (n + 1) / 2);
	}

	static class pair implements Comparable<pair>{
		int f, s;

		pair(int f, int s) {
			this.f = f;
			this.s = s;
		}

		
		
		
		
		public int len() {
			return s - f + 1;
		}
	}

	public static void main(String[] args) throws IOException {
		Instant start = Instant.now();
		if (args.length == 2) {
			System.setIn(new FileInputStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\input.txt"")));
			// System.setOut(new PrintStream(new File(""output.txt"")));
			System.setErr(new PrintStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\error.txt"")));
			DEBUG = true;
		}
		fs = new Reader();
		pw = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-- > 0) {
			solve();
		}
		Instant end = Instant.now();
		if (DEBUG) {
			pw.println(Duration.between(start, end));
		}
		pw.close();
	}

	static void sort(int a[]) {
		ArrayList<Integer> l = new ArrayList<Integer>();
		for (int x : a)
			l.add(x);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++) {
			a[i] = l.get(i);
		}
	}

	

	
}
",0,Non-plagiarised
c1fef98f,fadc1365,"import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Test{

        static FastReader scan;

        static void solve(){
            scan.nextLine();
            int n=scan.nextInt();
            int k=scan.nextInt();
            int []arr=new int[n+1];

            int []block=new int[k];
            int []temp=new int[k];

            for(int i=0;i<k;i++){
                block[i]=scan.nextInt();
            }

            for(int i=0;i<k;i++){
                temp[i]=scan.nextInt();
            }

            for(int i=0;i<k;i++){
                arr[block[i]]=temp[i];
            }
            int []dp=new  int[n+1];
            int prev=Integer.MAX_VALUE-1000;
            for(int i=1;i<=n;i++){
                if(arr[i]==0){
                    if(prev==Integer.MAX_VALUE-1000){
                        dp[i]=prev;
                    }
                    else{
                        prev=prev+1;
                        dp[i]=prev;
                    }
                }
                else{
                    prev=Math.min(prev+1,arr[i]);
                    dp[i]=prev;
                }
            }

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

            for(int i=1;i<=n;i++){
                System.out.print(dp[i]+"" "");
            }
            System.out.println();

        }

        public static void main (String[] args) throws java.lang.Exception{
            scan=new FastReader();
            int t=scan.nextInt();
            while(t-->0){
                solve();                  
            }
        }

        

                

        

        

        

        

           

        

        

        

        
        

        
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class a{ 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(),k=s.nextInt();
			int pos[]=s.readArray(k);
			int temp[]=s.readArray(k);
			long ans[]=new long[n];
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++){
				ans[pos[i]-1]=temp[i];
			}
			for(int i=1;i<n;i++){
				ans[i]=Math.min(ans[i-1]+1,ans[i]);
			}
			for(int i=n-2;i>=0;i--){
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for(int i=0;i<n;i++){
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
	
    
	
    
    
    
    
    
    
}
",0,Non-plagiarised
9be0602e,c4ca2ff3,"import java.io.*;
import java.util.*;

public class Codeforce {

    

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

    

    

    

    

    

    
public static  int fun(int ch,int a[][],int tot[],int n){
        ArrayList<Integer>ar=new ArrayList<>();
        for(int i=0;i<n;i++){
            ar.add((a[i][ch]-(tot[i]-a[i][ch])));
        }
        Collections.sort(ar,Collections.reverseOrder());
        int cou=0;
        int ans=0;
        for(int i:ar){
            cou+=i;
            if(cou>0){
                ans++;
            }
            else
                break;
        }
return ans;
}
    public static void main(String arg[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        while (t-- > 0) {
               int n=Integer.parseInt(br.readLine());
               int a[][]=new int[n][5];
               int tot[]=new int[n];
               for(int i=0;i<n;i++){
                   String s=br.readLine();
                   tot[i]+=s.length();
                   for(int j=0;j<s.length();j++){
                       a[i][s.charAt(j)-'a']++;
                   }
               }
               int ans=0;
               for(int i=0;i<5;i++){
                   ans=Math.max(ans,fun(i,a,tot,n));
               }
               sb.append(ans+""\n"");
                       }
        System.out.println(sb);
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

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

public class Main {

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

	
	
	

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

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

        }
    }





    //----------------------------------------------------------------------------------//
    
    
}
",1,Plagiarised
086f0f90,4a570de6,"import java.io.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int t=sc.nextInt();
        while (t-->=1) {
            int n = sc.nextInt(),m=sc.nextInt(), x = sc.nextInt();
            int a[] = sc.readArray(n);
            PriorityQueue<Pair> pq=new PriorityQueue<>();
            for (int i=0;i<m;i++){
                pq.add(new Pair(0,i+1));
            }
            int ans[]= new int[n];

            System.out.println(""YES"");
            for (int i=0;i<n;i++){
                Pair e=pq.peek();
                pq.remove(e);
                e.a+=a[i];
                pq.add(e);
                ans[i]=e.b;
//                System.out.print((e.b)%m+1+"" "");
            }
            printArray(ans);
            System.out.println();


        }
    }



//        out.flush();



    //------------------------------------if-------------------------------------------------------------------------------------------------------------------------------------------------
    //sieve
    
    
    
    static class Pair implements Comparable<Pair> {
        int a;
        int b;

        public Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }
        //        to sort first part
//        public int compareTo(Pair other) {
//            if (this.a == other.a) return other.b > this.b ? -1 : 1;
//            else if (this.a > other.a) return 1;
//            else return -1;
//        }
//        public int compareTo(Pair other) {
//            if (this.b == other.b) return 0;
//            if (this.b < other.b) return 1;
//            else return -1;
//        }
        //sort on the basis of first part only
        

    }
    
    
    static int mod =(int)(1e9+7);
    static long mod(long x) {
        return ((x % mod + mod) % mod);
    }
    static long add(long x, long y) {
        return mod(mod(x) + mod(y));
    }
    
    //Fast Power(logN)
    
    
    
    static void printArray(int a[]) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "" "");
        }
    }
    
    
    
    
    
    
}
","import java.io.*;
import java.lang.*;
import java.util.*;
public class c
{

 

public static int[] ia(int n)
{
    int ar[]=new int[n];
    return ar;
}


static class pair implements Comparable<pair>{
    int ht;
    int id;
    pair(int ht, int id)
{
    this.ht=ht;
    this.id=id;
}

}
public static void main(String args[]) throws java.lang.Exception
{
FastScanner sc=new FastScanner();
 int t=sc.ni();
while(t-->0)
{
    int n=sc.ni();
    int m=sc.ni();
    int x=sc.ni();
    int ar[]=ia(n);
for(int i=0;i<n;i++)
{
ar[i]=sc.ni();
}
System.out.println(""YES"");
PriorityQueue<pair> pq=new PriorityQueue<>();
 for(int i=0;i<m;i++)
 {
pq.add(new pair(0,i+1));
 }                     
 int i=0;
 while(i<n)
 {
     pair pp=pq.remove();
pp.ht+=ar[i];
System.out.print(pp.id+"" "");
pq.add(pp);
i++;
 }   
System.out.println();
}
}
}
",0,Non-plagiarised
3ff25f43,a195911e,"import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class EDU121C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        while(t-->0){
            int n = scan.nextInt();
            long[] k = new long[n];
            long[] h = new long[n];
            for(int i =0;i<n;i++){
                k[i] = scan.nextInt();
            }
            for(int i = 0;i<n;i++){
                h[i] = scan.nextInt();
            }
            long ans = 0;
            long lastD = 0;
            long lastHP = 0;
            for(int i = 0;i<n;i++){
                long dist = k[i]-lastD;
                long lo = h[i];
                long hi = lastHP+dist;
                long hpComingOut = 0;
                while(lo<=hi){
                    long mid = (lo+hi)/2;
                    boolean check = false;
                    for(int j = i+1;j<n;j++){
                        if(k[j]-k[i]<h[j]-mid){
                            check = true;
                            break;
                        }
                    }
                    if(check){
                        //we're in trouble
                        lo = mid+1;
                    }else{
                        hi = mid-1;
                        hpComingOut = mid;
                    }
                }
                if(hpComingOut>dist){
                    ans+=summ(dist+lastHP)-summ(lastHP);
                    lastHP+=dist;
                }else{
                    long diff = dist-hpComingOut;
                    ans+=summ(hpComingOut);
                    lastHP = hpComingOut;
                }
                lastD = k[i];
            }
            System.out.println(ans);
        }
    }
    static long summ(long a){
        return (a*(a+1))/2;
    }
    
}
","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
5f3a196a,d76e3b9d,"import java.io.*;
import java.util.*;
public class MonstersAndSpells {
	public static PrintWriter out;
	public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        out=new PrintWriter(System.out);
        int t=Integer.parseInt(st.nextToken());
        while(t-->0) {
        	st=new StringTokenizer(br.readLine());
        	int n=Integer.parseInt(st.nextToken());//monsters
        	int time[]=new int[n];//time
        	int health[]=new int[n];//health
        	st=new StringTokenizer(br.readLine());
        	for(int i=0;i<n;i++) {
        		time[i]=Integer.parseInt(st.nextToken());
        	}
        	st=new StringTokenizer(br.readLine());
        	for(int i=0;i<n;i++) {
        		health[i]=Integer.parseInt(st.nextToken());
        	}
        	State a[]=new State[n];
        	for(int i=0;i<n;i++) {
        		a[i]=new State(time[i]-health[i], time[i]);
        	}
        	Arrays.sort(a);
        	long ans=0;
        	for(int i=0;i<n;i++) {
        		int j=i+1;
        		int max=a[i].time;
        		while(j<n&&a[j].x<max) {
        			max=Math.max(max, time[j]);
        			j++;
        		}
        		ans+=((long)(max-a[i].x)*(long)(max-a[i].x+1))/2;
        		i=j-1;
        	}
        	out.println(ans);
        }
        out.close();
	}
	static class State implements Comparable<State>{
		int x, time;
		public State(int x, int time) {
			this.x=x;this.time=time;
		}
		
	}
}
","import java.io.*;
import java.util.*;

public class c {
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int numcases = Integer.parseInt(in.readLine());
        for(int casenum = 0; casenum < numcases; casenum++){
            int n = Integer.parseInt(in.readLine());
            long[] t = new long[n];
            long[] h = new long[n];
            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
            for(int i = 0; i < n; i++){
                t[i] = Integer.parseInt(tokenizer.nextToken());
            }
            tokenizer = new StringTokenizer(in.readLine());
            for(int i = 0; i < n; i++){
                h[i] = Integer.parseInt(tokenizer.nextToken());
            }
            long mana = 0;
            int index = 0;
            while(index < n){
                long start = t[index] - h[index];
                long end = t[index];
                for(int i = index+1; i < n; i++){
                    if(t[i] - h[i] < start){
                        start = t[i] - h[i];
                        end = t[i];
                        index = i;
                    }
                    else if(t[i] - end < h[i]){
                        end = t[i];
                        index = i;
                    }
                }
                mana += (end - start + 1) * (end - start) / 2;
                index++;
            }
            System.out.println(mana);
        }
        in.close();
        out.close();
    }
}
",0,Non-plagiarised
b55888de,d3a0b8d2,"import java.lang.reflect.Array;
import java.util.*;
public class Rough {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);   
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            sc.nextLine();
            String s[] = new String[n];
            int f[][] = new int[n][5];
            for (int i = 0; i < n; i++) {
                s[i]  = sc.nextLine();

                for (int j = 0; j < s[i].length(); j++) {
                    f[i][s[i].charAt(j)-'a']++;
                }
            }

            int ans = 0;
            for ( int i = 0; i < 5; i++) {
                ArrayList<Integer> al = new ArrayList<>();

                for (int j = 0; j < n; j++) {
                    int o = 0;
                    for (int k = 0; k < 5; k++) {
                        if(k != i)
                            o+=f[j][k];
                    }
                    al.add(f[j][i]-o);
                }

                Collections.sort(al,Collections.reverseOrder());

                int max = 0;
                int x = 0;
                for (int j = 0; j < n; j++) {
                    x+=al.get(j);
                    if(x<=0)break;
                    max++;
                }
                ans = Math.max(max,ans);
            }

            System.out.println(ans);
        }
        sc.close();
    }
}
","import java.io.File;
import java.io.IOException;
import java.util.*;

public class C {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- > 0){
            int n = in.nextInt();
            int[][] cnt = new int[n][5];
            int[] len = new int[n];
            for (int i = 0; i < n; i++){
                String s = in.next();
                len[i] = s.length();
                for (char c : s.toCharArray()) cnt[i][c-'a']++;
            }
            int max = 0;
            for (int i = 0; i < 5; i++){
                int[] diff = new int[n];
                for (int j = 0; j < n; j++) diff[j] = cnt[j][i] - (len[j] - cnt[j][i]);
                Arrays.sort(diff);
                int j = n-2, sum = diff[n-1];
                while (j>=0 && sum > 0){
                    max = Math.max(max, n - 1 - j);
                    sum += diff[j]; j--;
                }
                if (sum > 0) max = Math.max(max, n);
            }
            System.out.println(max);
        }
    }
}
",0,Non-plagiarised
3afcc566,90dc2b20,"import java.io.*;
import java.util.*;

import static java.lang.Math.*;

//Think through the entire logic before jump into coding!
//If you are out of ideas, take a guess! It is better than doing nothing!
//Read both C and D, it is possible that D is easier than C for you!

//Be aware of integer overflow!
//If you find an answer and want to return immediately, don't forget to flush before return!

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

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

    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            int n = in.nextInt();
            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
            for(int i = 0; i < n; i++) {
                if(a[i] == b[i]) {
                    if(a[i] == '0') match0++;
                    else match1++;
                }
                else {
                    if(a[i] == '0') mismatch01++;
                    else mismatch10++;
                }
            }
            if(mismatch01 + mismatch10 == 0) out.println(0);
            else {
                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
                    out.println(min(match0 + match1, mismatch01 + mismatch10));
                }
                else if(match1 - match0 == 1) {
                    out.println(match0 + match1);
                }
                else if(mismatch01 == mismatch10) {
                    out.println(mismatch01 + mismatch10);
                }
                else out.println(-1);
            }
        }
        out.close();
    }

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

    
}
","import java.util.*;
import java.io.*;
public class C1615{
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-->0) {
			int n = fs.nextInt();
			String a = fs.next();
			String b = fs.next();
			char ch1[] = a.toCharArray();
			char ch2[] = b.toCharArray();
			int c00 = 0;
			int c01 = 0;
			int c10 = 0;
			int c11 = 0;
			for(int i=0;i<n;i++){
				if(ch1[i]=='0'){
					if(ch2[i]=='0'){
						c00+=1;
					}
					else{
						c01+=1;
					}
				}
				else{
					if(ch2[i]=='0'){
						c10+=1;
					}
					else{
						c11+=1;
					}
				}
			}
			int ans = -1;
			if((c11-c00)==1 || c10==c01){
				int s1 = (int)1e7; 
				int s2 = (int)1e7;
				if((c11-c00)==1){
					s1 = c11+c00;
				}
				if(c10==c01)
				s2 = c10+c01;
				ans = Math.min(s1,s2); 
			}
			out.println(ans);
		}
		out.close();
	}
	
	
}
",0,Non-plagiarised
ba8800f5,d8e4eb5e,"import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;

public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int ar[] = new int[n];
        for(int i = 0; i < n; i++){
            ar[i] = Integer.parseInt(st.nextToken());
        }
        ArrayList<Integer> ones = new ArrayList<Integer>();
        ArrayList<Integer> zeroes = new ArrayList<Integer>();
        for(int i = 0; i < n; i++){
            if(ar[i] == 1)
                ones.add(i);
            else
                zeroes.add(i);
        }
        int r = ones.size();
        int c = zeroes.size();
        int time[][] = new int[r][c];
        System.out.println(calculateTime(time, r, c, 0, 0, ones, zeroes));
    }
    public static int calculateTime(int time[][], int r, int c, int currR, int currC, ArrayList<Integer> ones, ArrayList<Integer> zeroes){
        // System.out.println(currR + "" "" + currC);
        if(currR == r)
            return 0;
        if(currC == c)
            return (int)1e9;
        if(time[currR][currC] != 0)
            return time[currR][currC];
        return time[currR][currC] = Math.min((calculateTime(time, r, c, currR + 1, currC + 1, ones, zeroes) + Math.abs(ones.get(currR) - zeroes.get(currC))), calculateTime(time, r, c, currR, currC + 1, ones, zeroes));
    }
}
","import java.io.*;
import java.util.*;

public class E {

	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.parseInt(br.readLine());
		int cnt = n;
		boolean[] non = new boolean[n];
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		for(int i = 0; i < n; i++) {
			
			if(Integer.parseInt(st.nextToken()) == 0) {
				non[i] = true;
				cnt--;
			}
			
		}
		
		int x = 0;
		int y = 0;
		int[] location = new int[cnt];
		int[] rlocation = new int[n-cnt];
		
		for(int i = 0; i < n; i++) {
			
			if(!non[i]) {
				
				location[x] = i;
				x++;
				
			}else{
				
				rlocation[y] = i;
				y++;
				
			}
			
		}
		
		int[][] dp = new int[(n-cnt)+1][cnt+1];
		Arrays.fill(dp[0], 100000000);
		dp[0][0] = 0;
		
		for(int i = 0; i < n-cnt; i++) {
			
			//System.out.println(""HIT"");
			
			if(i < (n-cnt))
				Arrays.fill(dp[i+1], 100000000);
						
			for(int j = 0; j < cnt; j++) {
				
				if(i < (n-cnt)) {
					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j] + Math.abs(rlocation[i] - location[j]));			
					//System.out.println(dp[i+1][j+1] + "" "" + dp[i][j] + "" "" + j + "" "" + rlocation[i] + "" "" + location[j]);
				}
				
			}
			
		}
		
		int min = Integer.MAX_VALUE;
		
		for(int i = 0; i < (n-cnt)+1; i++) {
			
			min = Math.min(dp[i][cnt], min);
			
		}
				
		System.out.println(min);
		
	}

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


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

public class CF {
	
	private static FS sc = new FS();
	
	
	
	private static class extra {
		
		static int[] intArr(int size) {
			int[] a = new int[size];
			for(int i = 0; i < size; i++) a[i] = sc.nextInt();
			return a;
		}
		
		
		
		
		
		
		
	}
	
	static long count = 0;
	
	public static void main(String[] args) {
		
		int t = sc.nextInt();
//		int t = 1;
		StringBuilder ret = new StringBuilder();
		while(t-- > 0) {
			int n = sc.nextInt();
			int[] a = extra.intArr(n);
			PriorityQueue<Integer> c = new PriorityQueue<>();
			PriorityQueue<Integer> d = new PriorityQueue<>();
			long sum = 0;
			long min = Long.MAX_VALUE;
			for(int i = 0; i < n; i++) {
				sum += a[i];
				if(i%2 == 0) c.add(a[i]);
				else d.add(a[i]);
				if(i != 0) {
					min = Math.min(min, sum + (n - c.size())*1L*c.peek() + (n-d.size())*1L*d.peek());
				}
			}
			ret.append(min + ""\n"");
 		}
		System.out.println(ret);
	}
}
",1,Plagiarised
268eb6c6,3cf63146,"import java.util.*;
import java.io.*;

public class Test {
  // Fast IO class
  

  static FastReader sc = new FastReader();
  static PrintWriter out = new PrintWriter(System.out);

  public static void main(String[] args) {
    int t = sc.nextInt();
    while (t-- > 0) {
      int n = sc.nextInt();
      int k = sc.nextInt();
      int[] a = new int[k];
      int[] temp = new int[n];
      for (int i = 0; i < k; i++) a[i] = sc.nextInt();
      for (int i = 0; i < k; i++) temp[a[i] - 1] = sc.nextInt();
      int[] left = new int[n];
      int[] right = new int[n];
      Arrays.fill(left, Integer.MAX_VALUE - 1);
      Arrays.fill(right, Integer.MAX_VALUE - 1);
      if (temp[0] > 0) left[0] = temp[0];
      for (int i = 1; i < n; i++) {
        left[i] = Math.min(left[i - 1] + 1, left[i]);
        if (temp[i] > 0) left[i] = Math.min(left[i], temp[i]);
      }
      if (temp[n - 1] > 0) right[n - 1] = temp[n - 1];
      for (int i = n - 2; i >= 0; i--) {
        right[i] = Math.min(right[i + 1] + 1, right[i]);
        if (temp[i] > 0) right[i] = Math.min(right[i], temp[i]);
      }
      for (int i = 0; i < n; i++) out.print(Math.min(left[i], right[i]) + "" "");
      out.println();
    }
    out.flush();
    out.close();
  }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.time.LocalDateTime;
import java.util.*;

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Map.Entry;

import java.util.Random;
import java.util.TreeSet;

public final class CF_724_D2_D2
{


	static boolean verb=true;
	
	
	
	
	
	

	
	
	static void output(Object o){outputWln(""""+o+""\n"");	}
	
	static void outputWln(Object o){try {out.write(""""+ o);} catch (Exception e) {}}


	

	

	



	static long mod=1000000007;



	// Global vars
	static BufferedWriter out;
	static InputReader reader;

	
	
	

	
	static int PX=Integer.MAX_VALUE;
	static int NX=Integer.MIN_VALUE;

	static void process() throws Exception {


		out = new BufferedWriter(new OutputStreamWriter(System.out));
		reader = new InputReader(System.in);

		int T=reader.readInt();
		int CX=26;
		for (int t=0;t<T;t++) {
		
		
			int n=reader.readInt();
		
			int[] b=new int[n];
			for (int i=0;i<n;i++) {
				b[i]=reader.readInt();
			}
			TreeSet<Integer> ts=new TreeSet<Integer>();
			ts.add(b[0]);
			ts.add(NX);
			ts.add(PX);
			int core=b[0];
			boolean ok=true;
			for (int i=1;i<n;i++) {
				int x=b[i];
				if (x==core) {
					//ok
				} else if (x<core) {
					int y=ts.lower(core);
					if (y>x) {
						ok=false;
						//log(""fail 1"");

						break;
					}
					//log(""core:""+core+"" x:""+x+"" y:""+y);
					core=x;
					ts.add(x);
						
					
				} else {
					int y=ts.higher(core);
					if (y<x) {
						ok=false;
						//log(""fail 2"");
						break;
						
					}
					//log(""core:""+core+"" x:""+x+"" y:""+y);
					core=x;
					ts.add(x);
					
				}
			}
			
			
			if (ok)
				output(""YES"");
			else
				output(""NO"");
			
			
		
		}


		try {
			out.close();
		} catch (Exception Ex) {
		}

	}


	public static void main(String[] args) throws Exception {
		process();

	}

	

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

public class D {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int test = scn.nextInt();
        for (int t = 0; t < test; t++) {
            int n = scn.nextInt();
            int[] b = new int[n];
            TreeSet<Integer> ts = new TreeSet<>();
            int lastAdded = -1;
            boolean ans = true;
            for (int i = 0; i < n; i++) {
                b[i] = scn.nextInt();
            }
            for (int val : b) {
                if (t == 4) {
                    int x = 2;
                }
                if (val > lastAdded) {
                    Integer between = ts.higher(lastAdded);
                    if (between != null && between < val) {
                        ans = false;
                        break;

                    }

                }
                if (val < lastAdded) {
                    Integer between = ts.lower(lastAdded);
                    if (between != null && between > val) {
                        ans = false;
                        break;
                    }
                }
                ts.add(val);
                lastAdded = val;
            }
            if (ans) System.out.println(""YES"");
            else System.out.println(""NO"");
        }

    }

    


}
",0,Non-plagiarised
ac7187d8,b7a6c59c,"import java.io.*;
import java.util.*;
public class C {
    public static void main (String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int t = Integer.parseInt(st.nextToken());
        while (t-->0) {
            st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(f.readLine());
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Long.parseLong(st.nextToken());
            }
            solve(n, arr);
        }
    }
    static void solve(long n, long[] arr) {
        long minEven = Integer.MAX_VALUE;
        long minOdd = arr[0];
        long evenSum = 0;
        long oddSum = arr[0];
        long finans = Long.MAX_VALUE;
        long oddAns, evenAns;
        long oddcount=1;
        long evencount=0;
        for (int k = 1; k < n; k++) {
            if (k%2==1) {
                evenSum+=arr[k];
                evencount++;
                minEven = Math.min(minEven, arr[k]);
            } else {
                oddSum+=arr[k];
                oddcount++;
                minOdd = Math.min(minOdd, arr[k]);
            }
            oddAns = oddSum+(n-oddcount)*minOdd;
            evenAns = evenSum+(n-evencount)*minEven;
            finans = Math.min(finans, oddAns+evenAns);
        }
        System.out.println(finans);
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MinimumGridPath {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = br.readLine();
		int cases = Integer.parseInt(line);
		for(int i = 0; i<cases; i++) {
			int n = Integer.parseInt(br.readLine());
			
			long[] segments = new long[n];
			Scanner sc = new Scanner(br.readLine());
			for(int k = 0; k<n; k++) {
				segments[k] = sc.nextLong();
			}
			
			long minHor = segments[0], minVer = Long.MAX_VALUE;
			long sumHor = segments[0], sumVer = 0;
			long best = Long.MAX_VALUE;
			for(int k = 1; k<n; k++) {
				if(k % 2 == 1) {
					minVer = Long.min(minVer, segments[k]);
					sumVer += segments[k];
				}else {
					minHor = Long.min(minHor, segments[k]);
					sumHor += segments[k];
				}
				long cost = sumVer + sumHor + minVer * (n - (k+1)/2) + minHor * (n- (1+k/2));
				best = Long.min(best, cost);
			}
			
			System.out.println(best);
		}
	
	}
}
",0,Non-plagiarised
402aff07,f229aa7f,"import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t-- > 0){
            int n = s.nextInt();
            String a = s.next();
            String b = s.next();
            int a1 = 0, b1 = 0;
            for (char c: a.toCharArray()){
                if (c == '1') a1++;
            }
            for (char c: b.toCharArray()){
                if (c == '1') b1++;
            }
            int ans = Integer.MAX_VALUE;
            int res = 0;
            for (int i = 0; i < n; i++) {
                if (a.charAt(i) != b.charAt(i)) res++;
            }
            if (a1 == b1) ans = Math.min(ans, res);
            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
            if (ans == Integer.MAX_VALUE){
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
    }
}
","import java.util.*;
import java.io.*;
import java.math.*;

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

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

	

	

	

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



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


public final class A
{    
	static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	//	static node1 seg[];
	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
	public static void main(String args[])throws IOException
	{				


	
		int T=i();
		outer:while(T-->0)
		{
			int N=i();
			int size[]=new int[N];
			PriorityQueue<node1> q[]=new PriorityQueue[6];
			for(int i=0; i<5; i++)q[i]=new PriorityQueue<node1>();
			for(int i=0; i<N; i++)
			{
				char X[]=in.next().toCharArray();
				int s=X.length;
				size[i]=s;
				int f[]=new int[5];
				for(char x:X)f[x-'a']++;
				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
			}
			
			int max=0;
			for(int i=0; i<5; i++)
			{
				PriorityQueue<node1> q_new=new PriorityQueue<>();
				q_new=q[i];
				int c=0;
				long f=0;
				while(q_new.size()>0)
				{
					node1 x=q_new.remove();
//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
					f+=x.a;
					if(f>0)
					{
						c++;
						max=Math.max(max, c);
					}
					else break;
				}
			}
			out.println(max);
		}
		out.close();

	}
	
	
	

	
	
	
	


	
	
	//	static 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[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

",1,Plagiarised
a3e272af,f7fc2e94,"import java.io.*;
import java.util.*;

public class Asd {

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

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

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


public class test {
	 
	   
	  
	    
	 
	   
	
	   
	     
	   public static void main(String args[]) throws Exception { 
		
		   Scanner sc = new Scanner();
		   StringBuffer res = new StringBuffer();
		   
		   int tc = 1;
		   
		   while(tc-->0) { 
			
			    int n = sc.nextInt();
			    
			    ArrayList<Integer> one = new ArrayList<>();
			    ArrayList<Integer> zero = new ArrayList<>();
			    
			    for(int i=0;i<n;i++) { 
			    	
			    	int x = sc.nextInt();
			    	
			    	if(x==1) { 
			    		one.add(i);
			    	}
			    	else { 
			    		zero.add(i);
			    	}
			    }
			    
			    int dp[][] = new int[one.size()+1][zero.size()+1];
			    
			     for(int i=1;i<=one.size();i++)
			     {
			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
			         for(int j=i+1;j<=zero.size();j++)
			         {
			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
			         }
			     }
			     System.out.println(dp[one.size()][zero.size()]);
		   }
			System.out.println(res);
	   }
}
","import java.util.*;

public class Longjumps {
	 public static void main(String[] args){
		 Scanner sc=new Scanner(System.in);
			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
			int n = sc.nextInt();
			for(int i=1;i<=n;i++){
				int x=sc.nextInt();
				if(x==1)o.add(i);
				else e.add(i);
			}
			int dp[][]=new int[o.size()+1][e.size()+1];
			for(int i=1;i<=o.size();i++){
				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
				for(int j=i+1;j<=e.size();j++)
					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
			System.out.println(dp[o.size()][e.size()]);
	 }
}
",1,Plagiarised
2120328e,6de04ee2,"import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static int mod=10000007;
   static StringBuilder sb=new StringBuilder();
    /* start */
       public static void main(String [] args)
    {
            int t = i();
            while(t-->0)
            {
                int n = i();
                int a[] = input(n);
                char c[] = inputC();
                ArrayList<Integer> b = new ArrayList<>();
                ArrayList<Integer> r = new ArrayList<>();
                for(int i=0;i<n;i++)
                {
                    if(c[i]=='R')
                    r.add(a[i]);
                    else 
                    b.add(a[i]);
                }
                Collections.sort(b);
                Collections.sort(r,Collections.reverseOrder());
                boolean is = true;
                int cnt = 1;
                for(int i=0;i<b.size();i++)
                {
                    if(b.get(i)<cnt)
                    {
                        is = false;
                        break;
                    }
                    cnt++;
                }
                for(int i=0;i<r.size();i++)
                {
                    if(r.get(i)>n-i)
                    {
                        is = false;
                        break;
                    }
                }

                out.println(is==true?""YES"":""NO"");
            }
            out.close();
    }

    
    /* end */
     

    
    static int i() {
        return sc.nextInt();
    }

    static String s() {
        return sc.next();
    }

    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

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

    

    

    
      
     

      

     
    
     

     
    
    

    
    
    
    
    
    
    
    
    

    

    

    

    

    

    

     

      
        //pair class
        
}
","import java.util.*;
public class Solution{
    public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();

    while(t-->0) {
        int n=sc.nextInt();
        int[] a=new int[n];
        for(int i=0;i<n;i++)
             a[i]=sc.nextInt();

     char[] c=sc.next().toCharArray();

        Vector<Integer> l=new Vector<>(), r=new Vector<>();
        for(int i=0;i<n;i++)
            (c[i] == 'B' ? l : r).add(a[i]);
        Collections.sort(l);
        Collections.sort(r,Collections.reverseOrder());

        boolean ok = true;
        for(int i=0;i<l.size();i++)
            if (l.get(i) < i + 1)
                ok = false;
        for(int i=0;i<r.size();i++)
            if (r.get(i) > n - i)
                ok = false;

         System.out.print((ok ? ""YES"" : ""NO"")+'\n');
    }
    }
}
",1,Plagiarised
2a655afe,692a4496,"import java.io.*;
import java.util.*;

public class c {
    public static BufferedReader in;

    public static void main(String[] args) throws Exception {
        in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int numcases = Integer.parseInt(in.readLine());
        for (int casenum = 0; casenum < numcases; casenum++) {
            int n = Integer.parseInt(in.readLine());
            int[] p = new int[n];
            Arrays.fill(p, -1);
            for (int i = 0; i < n; i++) {
                if (p[i] != -1)
                    continue;
                ArrayList<Integer> cycle = new ArrayList<>();
                cycle.add(query(i));
                while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
                    cycle.add(query(i));
                }
                cycle.remove(cycle.size() - 1);
                for (int j = 0; j < cycle.size() - 1; j++) {
                    p[cycle.get(j)] = cycle.get(j + 1);
                }
                p[cycle.get(cycle.size() - 1)] = cycle.get(0);
                // System.out.println(Arrays.toString(p));
            }
            StringBuilder b = new StringBuilder();
            b.append(""! "");
            for (int i = 0; i < n; i++) {
                b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
            }
            System.out.print(b);
            System.out.flush();
        }
        in.close();
        out.close();
    }

    public static int query(int i) throws Exception {
        System.out.println(""? "" + (i + 1));
        System.out.flush();
        int k = Integer.parseInt(in.readLine());
        return k - 1;
    }
}
","import java.io.*;
import java.util.*;

public class c {
	public static BufferedReader in;

	public static void main(String[] args) throws Exception {
		in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		int numcases = Integer.parseInt(in.readLine());
		for (int casenum = 0; casenum < numcases; casenum++) {
			int n = Integer.parseInt(in.readLine());
			int[] p = new int[n];
			Arrays.fill(p, -1);
			for (int i = 0; i < n; i++) {
				if (p[i] != -1)
					continue;
				ArrayList<Integer> cycle = new ArrayList<>();
				cycle.add(query(i));
				while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
					cycle.add(query(i));
				}
				cycle.remove(cycle.size() - 1);
				for(int j = 0; j < cycle.size() - 1; j++){
					p[cycle.get(j)] = cycle.get(j + 1);
				}
				p[cycle.get(cycle.size() - 1)] = cycle.get(0);
				//System.out.println(Arrays.toString(p));
			}
			StringBuilder b = new StringBuilder();
			b.append(""! "");
			for (int i = 0; i < n; i++) {
				b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
			}
			System.out.print(b);
			System.out.flush();
		}
		in.close();
		out.close();
	}

	public static int query(int i) throws Exception {
		System.out.println(""? "" + (i + 1));
		System.out.flush();
		int k = Integer.parseInt(in.readLine());
		return k - 1;
	}
}
",1,Plagiarised
643e22cc,bd7281dc,"import java.io.*;
import java.util.*;

public class C {

	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

	public static void main(String[] args) throws IOException {
		readInput();
		out.close();
	}
	
	static class Tower implements Comparable<Tower>{
		int i, w;
		public Tower(int a, int b) {
			i=a;
			w=b;
		}
		
	}
	
	static class Block implements Comparable<Block>{
		int i, w;
		public Block(int a, int b) {
			i=a;
			w=b;
		}
		
	}

	static PriorityQueue<Tower> towers;
	static PriorityQueue<Block> blocks;
	static int[] par;
	
	static void solve() {
		while (!blocks.isEmpty()) {
			Block h = blocks.poll();
			Tower t = towers.poll();
			par[h.i] = t.i;
			t.w += h.w;
			towers.add(t);
		}
		List<Tower> res = new ArrayList<Tower>(towers);
		Collections.sort(res);
		boolean works = true;
		for (int i =1 ; i < m; i++) {
			if (Math.abs(res.get(i-1).w - res.get(i).w) > x) works = false;
		}
		if (works) {
			out.println(""YES"");
			for (int i = 0; i < n; i++) out.print(par[i] + 1 + "" "");
			out.println();
		}
		else out.println(""NO"");
	}
	static int n,m,x;
	public static void readInput() throws IOException {
		// br = new BufferedReader(new FileReader("".in""));
		// out = new PrintWriter(new FileWriter("".out""));
		int t = Integer.parseInt(br.readLine());
		while (t-->0) {
			StringTokenizer st=  new StringTokenizer(br.readLine());
			n = Integer.parseInt(st.nextToken());
			m = Integer.parseInt(st.nextToken());
			x = Integer.parseInt(st.nextToken());
			towers = new PriorityQueue<Tower>();
			blocks = new PriorityQueue<Block>();
			par = new int[n];
			st = new StringTokenizer(br.readLine());
			for (int i= 0 ; i < n; i++) {
				blocks.add(new Block(i,Integer.parseInt(st.nextToken())));
			}
			for (int i =0 ; i < m; i++) {
				towers.add(new Tower(i, 0));
			}
			solve();
		}
	}
}
","import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class x1515C
{
    public static void main(String hi[]) throws Exception
    {
        BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(infile.readLine());
        int T = Integer.parseInt(st.nextToken());
        StringBuilder sb = new StringBuilder();
        while(T-->0)
        {
            st = new StringTokenizer(infile.readLine());
            int N = Integer.parseInt(st.nextToken());
            int M = Integer.parseInt(st.nextToken());
            int X = Integer.parseInt(st.nextToken());
            int[] arr = readArr(N, infile, st);
            ArrayList<Unit> ls = new ArrayList<Unit>();
            for(int i=0; i < N; i++)
                ls.add(new Unit(arr[i], i));
            Collections.sort(ls);
            int[] res = new int[N];
            PriorityQueue<Unit> pq = new PriorityQueue<Unit>(Comparator.reverseOrder());
            for(int i=1; i <= M; i++)
                pq.add(new Unit(0, i));
            for(Unit add: ls)
            {
                Unit tower = pq.poll();
                tower.height += add.height;
                res[add.id] = tower.id;
                pq.add(tower);
            }
            int min = pq.poll().height;
            int max = min;
            while(pq.size() > 0)
                max = max(max, pq.poll().height);
            if(max-min > X)
                sb.append(""NO\n"");
            else
            {
                sb.append(""YES\n"");
                for(int x: res)
                    sb.append(x+"" "");
                sb.append(""\n"");
            }
        }
        System.out.print(sb);
    }
    public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
    {
        int[] arr = new int[N];
        st = new StringTokenizer(infile.readLine());
        for(int i=0; i < N; i++)
            arr[i] = Integer.parseInt(st.nextToken());
        return arr;
    }
}
class Unit implements Comparable<Unit>
{
    public int id;
    public int height;

    public Unit(int h, int i)
    {
        height = h;
        id = i;
    }
    
}
",0,Non-plagiarised
04ed33a5,6b83b22e,"import java.util.Scanner;

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

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
","import java.util.Scanner;

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

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
",1,Plagiarised
26e699de,e99c14b9,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

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



        }

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

import java.util.*;
/*




*/

 
 public class A{
	static FastReader sc=null;
	
	public static void main(String[] args) {
		sc=new FastReader();
		int t=sc.nextInt();
		
		for(int tt=0;tt<t;tt++) {
			int n=sc.nextInt();
			char a[]=sc.next().toCharArray(),b[]=sc.next().toCharArray();
			
			int fa=0,fb=0,da=0,db=0,sum=0;
			boolean dif=false;
			for(int i=0;i<n;i++) {
				sum+=a[i]-'0';
				if(a[i]!=b[i]) {
					dif=true;
					if(a[i]=='1')fa++;
					else fb++;
				}
				else {
					if(a[i]=='1')da++;
					else db++;
				}
			}
			
			if(sum==0) {
				System.out.println(dif?-1:0);
				continue;
			}
			
			int ans=n+1;
			
			if(fa==fb) ans=(fa+fb);
			if(da==db+1) ans=Math.min(da+db, ans);
			
			System.out.println(ans==(n+1)?-1:ans);
		}
	}
	
	
	
	
	
	
	
	
}
",0,Non-plagiarised
692a4496,f7006f16,"import java.io.*;
import java.util.*;

public class c {
	public static BufferedReader in;

	public static void main(String[] args) throws Exception {
		in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		int numcases = Integer.parseInt(in.readLine());
		for (int casenum = 0; casenum < numcases; casenum++) {
			int n = Integer.parseInt(in.readLine());
			int[] p = new int[n];
			Arrays.fill(p, -1);
			for (int i = 0; i < n; i++) {
				if (p[i] != -1)
					continue;
				ArrayList<Integer> cycle = new ArrayList<>();
				cycle.add(query(i));
				while (cycle.size() == 1 || !cycle.get(0).equals(cycle.get(cycle.size() - 1))) {
					cycle.add(query(i));
				}
				cycle.remove(cycle.size() - 1);
				for(int j = 0; j < cycle.size() - 1; j++){
					p[cycle.get(j)] = cycle.get(j + 1);
				}
				p[cycle.get(cycle.size() - 1)] = cycle.get(0);
				//System.out.println(Arrays.toString(p));
			}
			StringBuilder b = new StringBuilder();
			b.append(""! "");
			for (int i = 0; i < n; i++) {
				b.append((p[i] + 1) + (i < n - 1 ? "" "" : ""\n""));
			}
			System.out.print(b);
			System.out.flush();
		}
		in.close();
		out.close();
	}

	public static int query(int i) throws Exception {
		System.out.println(""? "" + (i + 1));
		System.out.flush();
		int k = Integer.parseInt(in.readLine());
		return k - 1;
	}
}
","import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;


public class C {

    private static StringTokenizer st;
    private static BufferedReader br;
    private static PrintWriter out;

    static boolean[]used;
    static int[]p;

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

        int t = nextInt();
        while (t --> 0) {
            int n = nextInt();
            used = new boolean[n+1];
            p = new int[n+1];
            for (int i = 1; i <= n; i++) {
                if (!used[i]) {
                    go(i);
                }
            }
            System.out.print(""! "");
            for (int i = 1; i <= n; i++) {
                System.out.print(p[i]+"" "");
            }
            System.out.println();
        }
        out.close();
    }

    private static void go(int i) throws IOException {
        List<Integer> inCycle = new ArrayList<>();
        int first = -1;
        while (true) {
            System.out.println(""? "" + i);
            int x = nextInt();
            used[x] = true;
            if (x == first) {
                break;
            }
            if (first == -1) {
                first = x;
            }
            inCycle.add(x);
        }
        List<Integer> numbers = new ArrayList<>();
        for (int j = 0; j < inCycle.size(); j++) {
            if (inCycle.get(j) == i) {
                for (int k = j; k < inCycle.size(); k++) {
                    numbers.add(inCycle.get(k));
                }
                for (int k = 0; k < j; k++) {
                    numbers.add(inCycle.get(k));
                }
                break;
            }
        }
        if (numbers.size() == 1) {
            p[numbers.get(0)] = numbers.get(0);
        } else {
            for (int j = 0; j < numbers.size()-1; j++) {
                p[numbers.get(j)] = numbers.get(j+1);
            }
            p[numbers.get(numbers.size()-1)] = numbers.get(0);
        }
    }

    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    

    

    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

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

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

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



        }

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

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

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

	

	

	

}
",0,Non-plagiarised
853acff9,929b98f0,"import java.lang.*;
import java.util.*;
import java.io.*;
public class C {
	final static int mod = (int)(1e9 + 7);
	static LinkedList<Integer>[] adj;
	static int arr[][] ;
	static long dp[][] ;
	public static void main(String[] args) {
		FastReader fs = new FastReader();
		int testcase = 1;
		testcase = fs.nextInt();
		//int i = 1;
		while (testcase-- > 0) {
			//System.out.print(""Case #"" + Integer.toString(i) + "": "");
			solve(fs);
			//i++;
		}

	}
	public static void solve(FastReader fs) {
		int n = fs.nextInt();
		arr = new int[n + 1][2];
		adj = new LinkedList[n + 1];
		dp = new long[n + 1][2];
		for (int i = 0; i < adj.length; i++) {
			adj[i] = new LinkedList<Integer>();
		}
		for (int i = 1; i < arr.length; i++) {
			arr[i][0] = fs.nextInt();
			arr[i][1] = fs.nextInt();
		}
		for (int i = 0; i < n - 1; i++) {
			int u = fs.nextInt();
			int v = fs.nextInt();
			adj[u].add(v);
			adj[v].add(u);
		}
		dfs(1, -1);

		System.out.println(Math.max(dp[1][0], dp[1][1]));
	}

	static void dfs(int source , int parent) {
		for (int val : adj[source]) {
			if (val == parent)
				continue;
			dfs(val, source);
			dp[source][0] += Math.max(dp[val][0] + Math.abs(arr[source][0] - arr[val][0]),
			                          dp[val][1] + Math.abs(arr[source][0] - arr[val][1]));
			dp[source][1] += Math.max(dp[val][0] + Math.abs(arr[source][1] - arr[val][0]),
			                          dp[val][1] + Math.abs(arr[source][1] - arr[val][1]));
		}
	}


//IO operation
	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.*;

public class Main {

    public static long[] ans(List<List<Integer>> edges, long[][] range, int root, boolean[] visited, PrintStream out) {
        if (visited[root]) {
            return new long[2];
        }
        visited[root] = true;
        long[] ans = new long[2];
        for (int x : edges.get(root)) {
            if (!visited[x]) {
                long[] temp = ans(edges, range, x, visited, out);
                ans[0] += Math.max(Math.abs(range[root][0] - range[x][0]) + temp[0], Math.abs(range[root][0] - range[x][1]) + temp[1]);
                ans[1] += Math.max(Math.abs(range[root][1] - range[x][0]) + temp[0], Math.abs(range[root][1] - range[x][1]) + temp[1]);
            }
        }
        return ans;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintStream out = new PrintStream(System.out);
        int t = Integer.parseInt(reader.readLine());
        while (t-->0) {
            int n = Integer.parseInt(reader.readLine());
            long[][] range = new long[n][2];
            for (int i = 0; i < n; i++) {
                String[] input = reader.readLine().split("" "");
                range[i][0] = Integer.parseInt(input[0]);
                range[i][1] = Integer.parseInt(input[1]);
            }
            List<List<Integer>> edges = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                edges.add(new ArrayList<>());
            }
            for (int i = 0; i < n - 1; i++) {
                String[] input = reader.readLine().split("" "");
                int u = Integer.parseInt(input[0]) - 1, v = Integer.parseInt(input[1]) - 1;
                edges.get(u).add(v);
                edges.get(v).add(u);
            }
            int root = 0;
            for (int i = 0; i < n; i++) {
                if (edges.get(i).size() > 1) {
                    root = i;
                    break;
                }
                if (edges.get(i).size() == 1) {
                    root = i;
                }
            }
            long[] ans = ans(edges, range, root, new boolean[n], out);
            out.println(Math.max(ans[0], ans[1]));
        }
        out.close();
    }
}
",0,Non-plagiarised
2c7a0000,4201fdf7,"import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//int cases = Integer.parseInt(br.readLine());
		//while(cases-- > 0) {
			int n = Integer.parseInt(br.readLine());
			String[] str = br.readLine().split("" "");
			int[] a = new int[n];
			int k = 0;
			ArrayList<Integer> pos = new ArrayList<>();
			for(int i=0; i<n; i++) {
				a[i] = Integer.parseInt(str[i]);
				if(a[i] == 1) {
					k++;
					pos.add(i);
				}
			}
			int[][] dp = new int[n+1][k+1];
			for(int i=0; i<=n; i++) {
				Arrays.fill(dp[i], Integer.MAX_VALUE);
			}
			dp[0][0] = 0;
			for(int i=0; i<n; i++) {
				for(int j=0; j<=k; j++) {
					if(dp[i][j] == Integer.MAX_VALUE) {
						continue;
					}
					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
					if(j < k && a[i] == 0) {
						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
					}
				}
			}
			System.out.println(dp[n][k]);
		//}
	}
}
","import java.util.*;
import java.io.*;
public class CF_1525_D{
	public static void main(String[] args) throws Exception{
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st;

		int n = Integer.parseInt(br.readLine());
		int a[] = new int[n];
		ArrayList<Integer> pos = new ArrayList<Integer>();

		st = new StringTokenizer(br.readLine());
		for(int i=0;i<n;i++){
			a[i] = Integer.parseInt(st.nextToken());
			if(a[i]==1)
				pos.add(i);
		}

		int z = pos.size();
		int dp[][] = new int[n+1][z+1];
		for(int i=0;i<=n;i++)
			Arrays.fill(dp[i], Integer.MAX_VALUE);

		dp[0][0] = 0;
		for(int i=0;i<n;i++){
			for(int j=0;j<=z;j++){
				if(dp[i][j] == Integer.MAX_VALUE)
					continue;
				dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);

				if(j<z && a[i]==0)
					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
			}
		}


		pw.print(dp[n][z]);
		pw.flush();
		pw.close();
	}
}
",1,Plagiarised
80407703,99e059b8,"import java.util.Scanner;
import java.util.Arrays;
public class B {
    public static int[] sort(int[] arr,int low,int high){
        int[] sortedArray;
        if (low==high) {
            sortedArray=new int[]{arr[low]};
            return sortedArray;
        }
        int mid=(low+high)/2;
        int[] arr1=sort(arr,low,mid);
        int[] arr2=sort(arr,mid+1,high);

        sortedArray=merge(arr1,low,mid,arr2,mid+1,high);
        return sortedArray;

    }

    public static int[] merge(int[] arr1,int low1,int high1,int[] arr2,int low2,int high2){

        int size1=high1-low1+1;
        int size2=high2-low2+1;
        
        int[] arr=new int[size1+size2];
        int pointer=0;
        low1=0;low2=0;
        while (low1<size1 && low2<size2){
            if (arr1[low1] <= arr2[low2]) {
                arr[pointer++]=arr1[low1++];
            }
            else{
                arr[pointer++]=arr2[low2++];
            }

        }

        while(low1<size1) arr[pointer++]=arr1[low1++];
        while(low2<size2) arr[pointer++]=arr2[low2++];
        return arr;
    }
    
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t-- > 0){
            int n=sc.nextInt();
            long k=sc.nextLong();
            int[] arr=new int[n];
            long sum=0;
            for(int i=0;i<n;i++) {
                arr[i]=sc.nextInt();
                sum+=arr[i];
            }
            if (sum<=k){
                System.out.println(0);
                continue;
            }
            long s[]=new long[n];
            arr=sort(arr,0,n-1);
            s[n-1]=arr[n-1]-arr[0];
            long ans=sum-k;
        
            for(int i=n-2;i>=0;i--) s[i]=s[i+1]+arr[i]-arr[0];
           
            for(int i=n-1;i>=1;i--) {
                
                long caseAns=(sum-k-s[i]+n-i)/(n-i+1);
                
                caseAns=Math.max(caseAns,0);
                caseAns+=n-i;
                ans=Math.min(caseAns,ans);
            }
            System.out.println(ans);
        }
        sc.close();
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
import java.text.DecimalFormat;

public final class Solution {

    static int inf = Integer.MAX_VALUE;
    static long mod = 1000000000 + 7;
  
 static void ne(Scanner sc, BufferedWriter op) throws Exception {
    int n=sc.nextInt();
    long k=sc.nextLong();
    long[] arr= new long[n];
    long sum=0;
    for(int i=0;i<n;i++){
        arr[i]=sc.nextLong();
        sum+=arr[i];
    }
    if(sum<=k){
        op.write(""0\n"");
        return;
    }
    sort(arr);
    long min=sum-k;
    long ss=0;
    
    int cc=0;
    for(int i=n-1;i>=1;i--){
          sum-=arr[i];
          sum+=arr[0];
          cc++;
        if(sum<=k){
          min=Math.min(min,cc);
          break;
        }
    }
   long val=Math.abs(arr[0]-(k/n))+(n-1);
    min=Math.min(val,min);
 
    for(int i=1;i<n;i++){
        ss+=arr[i];
        long no=((k-ss)/(long)(n-i));
     
        if(k-ss<0 && (k-ss)%(n-i)!=0){
            no--;
        }
       long count=(n-i-1)+Math.abs(arr[0]-no);
     
        min=Math.min(count,min);
    }
    op.write(min+""\n"");




 }
 
  
    
  

    public static void main(String[] args) throws Exception {
        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
        // Reader sc = new Reader();
     
        Scanner sc= new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0){ ne(sc, op); }
        
        // ne(sc,op);
           
                   
        op.flush();
    }

    
    

    static void  sort(int[] arr){
        ArrayList<Integer> list= new ArrayList<>();
        for(int i=0;i<arr.length;i++){
            list.add(arr[i]);

        }
        Collections.sort(list);
        for(int i=0;i<arr.length;i++){
            arr[i]=list.get(i);
        }
    }
       static void  sort(long[] arr){
        ArrayList<Long> list= new ArrayList<>();
        for(int i=0;i<arr.length;i++){
            list.add(arr[i]);

        }
        Collections.sort(list);
        for(int i=0;i<arr.length;i++){
            arr[i]=list.get(i);
        }
    }

}

// return -1 to put no ahed in array










 
",0,Non-plagiarised
28d8c381,417833c3,"import java.io.*;
import java.sql.SQLOutput;
import java.util.*;

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


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


public final class B
{    
	static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<Integer> g[];
	static long mod=(long)998244353,INF=Long.MAX_VALUE;
	//	static boolean set[]; 
	static int par[],partial[];
	static int Days[],P[][];
	static int sum=0,size[];
	static int seg[],col[];
	//	static ArrayList<Long> A;
	static char X[][];
	static boolean set[][];
	static int D[],min[],A[];
	static long dp[][];
	//	static HashSet<Integer> visited,imposters;
	//	static HashSet<Integer> set;
	//	static node1 seg[];
	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
	public static void main(String args[])throws IOException
	{	
		/*
		 * star,rope,TPST
		 * BS,LST,MS,MQ
		 */
		int T=i();
		outer:while(T-->0)
		{
			int N=i();
			int f[]=new int[N+5];
			int ask=ask(1);
			HashSet<Integer> set=new HashSet<>();
			int cnt=0;
			for(int i=1; i<=N; i++)
			{
				if(cnt+1==N)
				{
					set=new HashSet<>();
					for( i=0; i<=N; i++)set.add(i);
					for( i=1; i<=N; i++)set.remove(f[i]);
					int a=-1;
					for(int v:set)
					{
						a=v;
					}
					for(i=1; i<=N; i++)
					{
						if(f[i]==0)f[i]=a;
					}
					break;
				}
				if(f[i]==0)
				{
					int last=0;
					set=new HashSet<>();
					while(true)
					{
						int a=ask(i);
						f[last]=a;
						if(set.contains(a))
						{
							break;
						}
						last=a;
						set.add(a);
					}
					cnt+=set.size();
				}
				
			}
			for(int i=1; i<=N; i++)
			{
				ans.append(f[i]+"" "");
			}
			System.out.println(""! ""+ans);
			ans=new StringBuilder();
		}
		out.println(ans);
		out.close();
	}
	static int ask(int a)
	{
		System.out.println(""? ""+a);
		//		out.flush();
		return i();
	}
	
	
	

	
	
	
	
	
	
	
	
	
	
	
	
	static long fact[];
	
	
	

	
	
	
	
	static int ask(int v,int tl,int tr,int l,int r)
	{
		//		System.out.println(v);
		//		if(v>100)return 0;
		if(l>r)return Integer.MAX_VALUE;
		if(tl==l && tr==r)return seg[v];
		int tm=(tl+tr)/2;
		int a=ask(v*2,tl,tm,l,Math.min(tm, r));
		//		System.out.println(""for--> ""+(v)+"" tm--> ""+(tm+1)+"" tr--> ""+tr+"" l--> ""+Math.max(l, tm+1)+"" r--> ""+r);
		int b=ask(v*2+1,tm+1,tr,Math.max(l, tm+1),r);
		return Math.min(a, b);
	}
	
	
	static int ask(int a,int b)
	{
		System.out.println(""? ""+a+"" ""+b);
		return i();
	}




	
	
	
	
	
	
	


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

	





	
	



	
	
	



	

	    



	 

	

	

	

	  

	



	

	

	

	

	

	

	
	
	
	
	
	
	
	
	

	static int i()
	{
		return in.nextInt();
	}

	

	

	

	

}



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

",0,Non-plagiarised
4f7af821,8f6421f3,"import java.util.*;

public class contestA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        int inf = 1000300300;
        while (t-->0){
            int n = scanner.nextInt();
            int k = scanner.nextInt();
            int[] c = new int[n];
            Arrays.fill(c,inf);
            int[] a = new int[k];
            int[] b = new int[k];
            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
            for(int i=0;i<k;++i) c[a[i]] = b[i];
            for(int i=1;i<n;++i){
                c[i] = Math.min(c[i],c[i-1]+1);
            }
            for(int i=n-2;i>=0;--i){
                c[i] = Math.min(c[i],c[i+1]+1);
            }
            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
            System.out.println();
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
public class Main{  
    public static void main (String[] args){
        FastReader s = new FastReader();
        int t=1;t=s.ni();
        for(int test=1;test<=t;test++){
        int n=s.ni(),k=s.ni();
        int position[]=s.readArray(k),temp[]=s.readArray(k);
        int ans[]=new int[n];
        Arrays.fill(ans,Integer.MAX_VALUE/2);
        for(int i=0;i<k;i++){
            ans[position[i]-1]=temp[i];
        }
        for(int i=1;i<n;i++){
            ans[i]=Math.min(ans[i-1]+1,ans[i]);
        }
        for(int i=n-2;i>=0;i--){
            ans[i]=Math.min(ans[i],ans[i+1]+1);
        }
        for(int i=0;i<n;i++)
        System.out.print(ans[i]+"" "");
        System.out.println();
        }
    }
    
    
    
}
",1,Plagiarised
a7e7f371,f8e7b886,"import java.io.*;
import java.util.*;


public class cp {
	static int mod=(int)1e9+7;
	
//	static  Reader sc=new Reader();
	static FastReader sc=new FastReader(System.in);
	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.util.*;
import java.io.*;
import java.time.*;
import static java.lang.Math.*;

@SuppressWarnings(""unused"")
public class C {
	static boolean DEBUG = false;

	static Reader fs;
	static PrintWriter pw;

	static void solve() {
		int n = fs.nextInt(), k[] = fs.readArray(n), h[] = fs.readArray(n);
		int prev_h = h[0], prev_k = k[0];
//		int ans = 0;
		ArrayList<pair> intervals = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int start = k[i] - h[i] + 1;
			int end = k[i];
			intervals.add(new pair(start, end));
		}
//		pw.println(intervals);
		Collections.sort(intervals);
		ArrayList<pair> merged = new ArrayList<>();
		merge(intervals, merged);
		long ans = 0;
		for(int i = 0 ; i < merged.size() ; i++) {
			ans += sum(merged.get(i).len());
		}
		pw.println(ans);
	}
	
	static void merge(ArrayList<pair>a1, ArrayList<pair>a2) {
		int n = a1.size();
		int index = 0;
		for(int i =1 ; i < n ; i++) {
			if(a1.get(index).s >= a1.get(i).f) {
				a1.get(index).s = max(a1.get(index).s, a1.get(i).s);
			}
			else {
				index++;
				a1.set(index, a1.get(i));
			}
		}
		for(int i = 0 ; i <= index ; i++) {
			a2.add(a1.get(i));
		}
//		pw.println(a1);
	}
	
//	int index = 0; // Stores index of last element 
//    // in output array (modified arr[]) 
//
//    // Traverse all input Intervals 
//    for (int i=1; i<arr.length; i++) 
//    { 
//        // If this is not first Interval and overlaps 
//        // with the previous one 
//        if (arr[index].end >=  arr[i].start) 
//        { 
//               // Merge previous and current Intervals 
//            arr[index].end = Math.max(arr[index].end, arr[i].end); 
//        } 
//        else {
//            index++;
//            arr[index] = arr[i]; 
//        }    
//    }
	
	
	
	static pair merge(pair p1, pair p2) {
		return new pair(min(p1.f, p2.f), max(p1.s, p2.s));
	}

	static long sum(long n) {
		return (n * (n + 1) / 2);
	}

	static class pair implements Comparable<pair>{
		int f, s;

		pair(int f, int s) {
			this.f = f;
			this.s = s;
		}

		
		
		
		
		public int len() {
			return s - f + 1;
		}
	}

	public static void main(String[] args) throws IOException {
		Instant start = Instant.now();
		if (args.length == 2) {
			System.setIn(new FileInputStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\input.txt"")));
			// System.setOut(new PrintStream(new File(""output.txt"")));
			System.setErr(new PrintStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\error.txt"")));
			DEBUG = true;
		}
		fs = new Reader();
		pw = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-- > 0) {
			solve();
		}
		Instant end = Instant.now();
		if (DEBUG) {
			pw.println(Duration.between(start, end));
		}
		pw.close();
	}

	static void sort(int a[]) {
		ArrayList<Integer> l = new ArrayList<Integer>();
		for (int x : a)
			l.add(x);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++) {
			a[i] = l.get(i);
		}
	}

	

	
}
",0,Non-plagiarised
810cf242,968c1e7e,"import java.util.*;
import java.io.*;
public class E1547{
	static int inf = 2*(int)Math.pow(10,9);
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		int t = fs.nextInt();
		while(t-->0){
			int n = fs.nextInt();
			int k = fs.nextInt();
			int pos[] = new int[k];
			for(int i=0;i<k;i++){
				pos[i] = fs.nextInt();
			}	
			int time[] = new int[n];
			Arrays.fill(time,inf);
			for(int i=0;i<k;i++){
				time[pos[i]-1] = fs.nextInt();
			}
			for(int i=0;i<n;i++){
				if(i==0){
					continue;
				}
				else{
					time[i] = Math.min(time[i],time[i-1]+1);
				}
			}
			for(int i=n-2;i>=0;i--){
				time[i] = Math.min(time[i],1+time[i+1]);
			}
			for(int i=0;i<n;i++){
				System.out.print(time[i]+"" "");
			}
			System.out.println();			
		}
	}
	
	
}
","import java.util.*;
import java.io.*;

public class E_Air_Conditioners{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        int k=s.nextInt();
        int pos[]= new int[k];
        int temp[]= new int[k];
        int min=Integer.MAX_VALUE;
        int ans[]= new int[n];
        HashMap<Integer,ArrayList<Integer>> map = new HashMap<Integer,ArrayList<Integer>>();
            HashMap<Integer,Integer> count1 = new  HashMap<Integer,Integer> ();
        for(int i=0;i<k;i++){
            pos[i]=s.nextInt();
        }
        for(int i=0;i<k;i++){
            temp[i]=s.nextInt();
            ans[pos[i]-1]=temp[i];
            min=Math.min(temp[i],min);
            if(map.containsKey(temp[i])){
                map.get(temp[i]).add(pos[i]-1);
                int a=count1.get(temp[i]);
                a++;
                count1.remove(temp[i]);
                count1.put(temp[i],a);
            }
            else{
                ArrayList<Integer> obj = new ArrayList<Integer>();
                obj.add(pos[i]-1);
                map.put(temp[i],obj);
                count1.put(temp[i],1);
            }
        }
     
        int num=min;
       
        while(true){
           
        
           if(!map.containsKey(num)){
               break;
           }
          ArrayList<Integer> obj2 = map.get(num);
          
          for(int i=0;i<obj2.size();i++){
              int index=obj2.get(i);
              if(ans[index]!=0){
                  if(ans[index]<num){
                     
                    if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
                        ans[index+1]=num+1;
                       
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index+1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index+1);
                            map.put(num+1,object);
                        }
                    }

                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
                        ans[index-1]=num+1;
                     
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index-1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index-1);
                            map.put(num+1,object);
                        }
                    }

                  }
                  else if(ans[index]==num){
                   
                      if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
                        ans[index+1]=num+1;
                   
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index+1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index+1);
                            map.put(num+1,object);
                        }
                    }

                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
                        ans[index-1]=num+1;
                    
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index-1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index-1);
                            map.put(num+1,object);
                        }
                    }
                  }

              }
            
            }
           num++;
        }
        for(int i=0;i<ans.length;i++){
            res.append(ans[i]+"" "");
        }
        res.append(""\n"");
        p++;
    }
    System.out.println(res);


    }
    




}
",0,Non-plagiarised
8e990c75,96b3758b,"import java.util.Scanner;

public class Armchairs {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int[] chairs = new int[num];
        int numOne = 0;
        for (int i = 0; i < num; i++) {
            chairs[i] = scanner.nextInt();
            if (chairs[i] == 1) numOne++;
        }
        if (numOne == 0) {
            System.out.println(0);
            return;
        }
        int one = 0;
        int zero = 0;

        int[] ones = new int[numOne];
        int[] zeros = new int[num - numOne];

        for (int i = 0; i < num; i++) {
            if (chairs[i] == 0) zeros[zero++] = i;
            else ones[one++] = i;
        }

        long[][] nums = new long[numOne][num - numOne];
        for (int c = 0; c < num - numOne; c++)
            nums[0][c] = Math.abs(ones[0] - zeros[c]);

        for (int r = 1; r < numOne; r++) {
            long min = nums[r - 1][r - 1];
            for (int c = r; c < num - numOne; c++) {
                min = Math.min(nums[r - 1][c - 1], min);
                nums[r][c] = min + Math.abs(ones[r] - zeros[c]);
            }
        }

        Long result = Long.MAX_VALUE;
        for (long min: nums[numOne - 1]) {
            if (min > 0) result = Math.min(result, min);
        }
        System.out.println(result);
    }
}
","import java.io.*;
import java.util.*;

public class D {
	
	static int[][] dp;
	
	static int solve(int i,int j,ArrayList<Integer> A,ArrayList<Integer> B) {
		if(i==A.size()) {
			return 0;
		}
		if(j==B.size()) {
			return 1000000009;
		}
		if(dp[i][j]!=-1) {
			return dp[i][j];
		}
		int ans=1000000009;
		int a=A.get(i);
		int b=B.get(j);
		ans=Math.min(ans, Math.abs(a-b)+solve(i+1,j+1,A,B));
		ans=Math.min(ans, solve(i,j+1,A,B));
		return dp[i][j]=ans;
	}

	public static void main(String[] args){
		FastReader sc=new FastReader();
		int t=1;
		while(t-->0) {
			int n=sc.nextInt();
			int[] a=new int[n];
			ArrayList<Integer> A=new ArrayList<>();
			ArrayList<Integer> B=new ArrayList<>();
			for(int i=0;i<n;i++) {
				a[i]=sc.nextInt();
				if(a[i]==1) {
					A.add(i);
				} else {
					B.add(i);
				}
			}
			dp=new int[5010][5010];
			for(int i=0;i<5010;i++) {
				Arrays.fill(dp[i], -1);
			}
			System.out.println(solve(0,0,A,B));
			
		}
	}
	

}
",0,Non-plagiarised
2d1553b5,656d0f78,"import java.util.*;
import java.io.*; 
public class Interactive{     
    static long MOD=(long)1e9+7;
    //debug
    
    static Scanner sc = new Scanner(System.in);
    //Global variables and functions
    static long query(int l, int r) {
    	System.out.println(""? "" + l + "" "" + r);
    	return sc.nextLong();
    }
    static int query(int i) {
    	System.out.println(""? "" + i);
    	return sc.nextInt();
    }
    //Main function(The main code starts from here)
    public static void main (String[] args) throws java.lang.Exception {
    	int test=1;
    	test=sc.nextInt();
    	while(test-->0) {
    		int n = sc.nextInt();
    		int ans[] = new int[n];
    		for(int i = 1; i <= n; i++) {
    			if(ans[i - 1] != 0) continue;
    			HashSet<Integer> set = new HashSet<>();
    			ArrayList<Integer> arr = new ArrayList<>();
    			while(true) {
    				int x = query(i);
    				if(set.contains(x)) break;
    				set.add(x);
    				arr.add(x - 1);
    			}
    			for(int j = 0; j < arr.size(); j++) {
    				ans[arr.get(j)] = arr.get((j + 1) % arr.size()) + 1;
    			}
    		}
    		System.out.print(""! "");
    		for(int x: ans) System.out.print(x+"" "");
    		System.out.println();
    	}
    }
}
","import java.awt.Container;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

import java.util.*;

public class Main
{
    
   
   
    public static void main(String[] args)
    {
        FastScanner input = new FastScanner();
        int tc = input.nextInt();
        work:
        while (tc-- > 0) {
             int n = input.nextInt();
       int ans[] = new int[n];
        for (int i = 1; i <=n; i++) {
            if(ans[i-1]!=0)
            {
//                System.out.println(""NO"");
                continue ;
            }
            HashSet<Integer> set = new HashSet<>();
            ArrayList<Integer> a = new ArrayList<>();
            while(true)
            {
                System.out.println(""? ""+i);
                int value = input.nextInt();
                if(set.contains(value))
                {
                    break;
                }
                a.add(value-1);
                set.add(value);
                
            }
            for (int j = 0; j <a.size(); j++) {
                ans[a.get(j)] = a.get((j+1)%a.size())+1;
            }
//            System.out.println(a);
        }
        System.out.print(""! "");
        for (int an : ans) {
            System.out.print(an+"" "");
        }
        System.out.println("""");   
        }
    }

    

}
",1,Plagiarised
31cdf5fe,f0801d53,"import java.util.Scanner;

public class Main {

    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while(t-- > 0)
        {
            int n = scanner.nextInt();
            int[] time = new int[n];
            int[] h = new int[n];
            for(int i  = 0; i < n; i++)
            {
                time[i] = scanner.nextInt();
            }
            for(int j = 0; j < n; j++)
            {
                h[j] = scanner.nextInt();
            }
            long prevMTime = time[n-1];
            long prevMHealth = h[n-1];
            long manaRequired = 0;
            long currMTime = time[n-1];
            long currMHealth = h[n-1];
            long spellCastingTime = prevMTime - prevMHealth + 1;

            for(int i = n-2; i >= 0; i--)
            {
                currMHealth = h[i];
                currMTime = time[i];
                //spellCastingTime = prevMTime - prevMHealth + 1;
                if(spellCastingTime <= currMTime && currMTime - spellCastingTime + 1 < currMHealth)
                {
                    spellCastingTime = currMTime - currMHealth + 1;
                }
                else if(spellCastingTime > currMTime)
                {
                    long hm = (prevMTime - spellCastingTime) + 1;
                    manaRequired += (hm * (hm+1)) / 2;
                    prevMTime =currMTime;
                    prevMHealth = currMHealth;
                    spellCastingTime = prevMTime - prevMHealth + 1;
                }
            }
            long hm = (prevMTime - spellCastingTime) + 1;
            manaRequired += (hm * (hm+1)) / 2;
            System.out.println(manaRequired);

        }
    }

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

public class hmm {

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


	public static void main(String[] args) throws Exception {
		int t =sc.nextInt();
		while (t-- > 0) {
             int n = sc.nextInt();
             int []k = sc.nextIntArray(n);
             int h[]=sc.nextIntArray(n);
     
             long mana = 0;
             pair cur = new pair(k[n-1]-h[n-1]+1,k[n-1]);
             for(int i=n-1;i>=0;i--) {
            	 int s = k[i];
            	 int start = s-h[i]+1;
            	 if(s>=cur.x) {
            		 cur.x = Math.min(start, cur.x);
            	 }
            	 else {
            		 long x = cur.y - cur.x +1;
            		 mana += x*(x+1)/2;
            		 cur.x = start;
            		 cur.y = s;
            	 }
             }
       
             long x = cur.y - cur.x +1;
       
    		 mana += x*(x+1)/2;
    		 pw.println(mana);
             
           
		}

		pw.close();

	}

	// -------------- stuff ------------------------------
	static class pair {
		int x ;
		int y;
	
		
		public pair(int n,int c) {
			x= n;
			y = c;
		
			
		}
	
	
		
	}

	

}
",0,Non-plagiarised
abd16ff0,db1ef8b3,"import java.util.*;

public class Solve{

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
       
       
        while(t-->0){
            int n=sc.nextInt();
           long ans=Long.MAX_VALUE;
           long pre=0;
           PriorityQueue<Long> epq=new PriorityQueue<>();
           PriorityQueue<Long> opq=new PriorityQueue<>();
           for(int i=0;i<n;i++){
               long a=sc.nextInt();
               if(i%2==0)opq.add(a);
               else epq.add(a);
               pre+=a;
              if(i>0) ans=Math.min(ans,pre+opq.peek()*(n-opq.size())+epq.peek()*(n-epq.size()));
               
           }
          System.out.println(ans);
        }
    }
}
","import java.util.*;
import java.io.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

public class C {

	private static long INF = 2000000000000000000L;

	public static void process() throws IOException {

		int n = sc.nextInt();
		PriorityQueue<Integer> odd = new PriorityQueue<Integer>();
		PriorityQueue<Integer> even = new PriorityQueue<Integer>();
		int arr[] = sc.readArray(n);
		long min = INF;
		long sumOdd = 0;
		long sumEven = 0;
		for (int i = 0; i < n; i++) {
			int x = arr[i];
			if (i % 2 == 0) {
				even.add(x);
				sumEven += x;
			} else {
				odd.add(x);
				sumOdd += x;
			}
			if (i > 0) {
				long ans = 0;
				ans += 1l * even.peek() * (n - (even.size()));
				ans += 1l * odd.peek() * (n - (odd.size()));
				ans += sumOdd + sumEven;
				min = Math.min(ans, min);
			}
		}
		System.out.println(min);
	}

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

	static FastScanner sc;
	static PrintWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new PrintWriter(System.out);
		} else {
			sc = new FastScanner(100);
			out = new PrintWriter(""output.txt"");
		}
		int t = 1;
		t = sc.nextInt();
		while (t-- > 0) {
			process();
		}
		out.flush();
		out.close();
	}

	

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


	

	

	

	

	

	

	

	

	

	

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

	

	

	
}
",0,Non-plagiarised
2560850b,76791c9f,"import java.util.*;
import java.io.*;

public class notassigning {
	public static void main(String[] args) throws IOException {
		BufferedReader fin = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(fin.readLine());
		StringBuilder fout = new StringBuilder();
		while(t-- > 0) {
			int n = Integer.parseInt(fin.readLine());
			boolean isValid = true;
			int start = -1;
			ArrayList<ArrayList<Integer>> c = new ArrayList<ArrayList<Integer>>();
			for(int i = 0; i < n; i++) {
				c.add(new ArrayList<Integer>());
			}
			HashMap<ArrayList<Integer>, Integer> order = new HashMap<ArrayList<Integer>, Integer>();
			for(int i = 0; i < n - 1; i++) {
				StringTokenizer st = new StringTokenizer(fin.readLine());
				int a = Integer.parseInt(st.nextToken()) - 1;
				int b = Integer.parseInt(st.nextToken()) - 1;
				order.put(new ArrayList<Integer>(Arrays.asList(a, b)), i);
				c.get(a).add(b);
				c.get(b).add(a);
				if((c.get(a).size() == 3 || c.get(b).size() == 3) && isValid) {
					isValid = false;
				}
			}
			if(!isValid) {
				fout.append(""-1\n"");
				continue;
			}
			//locate the start of the chain
			for(int i = 0; i < n; i++) {
				if(c.get(i).size() == 1) {
					start = i;
					break;
				}
			}
			int[] ans = new int[n - 1];
			int cur = start;
			int next = c.get(start).get(0);
			int prime = 2;
			while(true) {
				int index = 0;
				if(order.containsKey(new ArrayList<Integer>(Arrays.asList(cur, next)))) {
					index = order.get(new ArrayList<Integer>(Arrays.asList(cur, next)));
				}
				else {
					index = order.get(new ArrayList<Integer>(Arrays.asList(next, cur)));
				}
				ans[index] = prime;
				if(c.get(next).size() == 1) {
					break;
				}
				prime = prime == 3? 2 : 3;
				int prev = cur;
				cur = next;
				next = c.get(cur).get(0) == prev? c.get(cur).get(1) : c.get(cur).get(0);
			}
			for(int i : ans) {
				fout.append(i).append("" "");
			}
			fout.append(""\n"");
		}
		System.out.print(fout);
	}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

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

    }

    static class TaskA {
        Map<Integer, ArrayList<Integer>> ans;
        Map<Integer,Boolean> visited;
        Map<Integer, List<Integer>> map;
        public void call(InputReader in, PrintWriter out) {
            int n = in.nextInt();
            answer[] arr = new answer[n];
            visited = new HashMap<>();
            ans = new HashMap<>();
            int u, v;
            map = new HashMap<>();
            for (int i = 0; i < n - 1; i++) {
                arr[i] = new answer(in.nextInt(), in.nextInt());
                u = arr[i].a;
                v = arr[i].b;
                map.putIfAbsent(u, new ArrayList<>());
                map.get(u).add(v);
                map.putIfAbsent(v, new ArrayList<>());
                map.get(v).add(u);
            }
            int a = 0;
            for(Integer i : map.keySet()){
                if(map.get(i).size() > 2){
                    out.println(-1);
                    return;
                }
                if(map.get(i).size()==1){
                    a = i;
                }
            }
            dfs(a, -1, 0);

            int[] ans1 = new int[n - 1];

            for(int i = 0; i < n-1; i++){
                u = arr[i].a;
                v = arr[i].b;
                if(ans.getOrDefault(u, null)!=null && ans.get(u).get(0)==v){
                    if(ans.get(u).get(1)==0){
                        ans1[i] = 2;
                    }
                    else{
                        ans1[i] = 5;
                    }
                }
                else{
                    if(ans.get(v).get(1)==0){
                        ans1[i] = 2;
                    }
                    else{
                        ans1[i] = 5;
                    }
                }
            }
            for(Integer i : ans1){
                out.print(i+"" "");
            }
            out.println();
        }
        public void dfs(int child, int par, int c){
            if(par!=-1){
                ans.putIfAbsent(par, new ArrayList<>());
                ans.get(par).add(child);
                ans.get(par).add(c);
            }
            visited.put(child, true);
            for(Integer i : map.get(child)){
                if(!visited.getOrDefault(i, false)){
                    dfs(i, child, c^1);
                }
            }
        }
    }

    

    


    static class answer implements Comparable<answer>{
        int a, b;

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

    }

    

    

    

    static final Random random=new Random();

    

    
}
",0,Non-plagiarised
81fb6415,b3d4c5ca,"import java.math.BigInteger;
import java.util.*;
import java.io.*;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class CodeForces {


    public void run() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        next : while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long k = Long.parseLong(st.nextToken());
            Long[] a = new Long[n];
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                a[i] = Long.parseLong(st.nextToken());
            }
            Arrays.sort(a);
            long ans = Long.MAX_VALUE;
            long[] lsum = new long[n + 1];
            for (int i = 0; i < n; i++) {
                lsum[i + 1] = lsum[i] + a[i];
            }
            for (long y = 0; y < n; y++) {
                long x = 0;
                if ((k - lsum[n - (int)y] + a[0]) >= 0) {
                    x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
                } else {
                    if ((k - lsum[n - (int)y] + a[0]) % (y + 1) == 0) {
                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
                    } else {
                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1) - 1;
                    }
                }
                x = a[0] - x;
                ans = Math.min(ans, Math.max(0, x) + y);
            }
            System.out.println(ans);
        }

    }

    public static void main(String[] args) throws Exception {
        new CodeForces().run();
    }

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

public class Main {
    public static long floor(long a, long b) {
        long res = a / b;
        while(res * b > a) res--;
        return res;
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long k = Long.parseLong(st.nextToken());
            st = new StringTokenizer(br.readLine());
            Long[] p = new Long[n];
            for(int i = 0 ;i<n;i++) {
                p[i] = Long.parseLong(st.nextToken());
            }
            Arrays.sort(p);
            long[] sums = new long[n+1];
            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
            long ans = Long.MAX_VALUE;
            for(int y=0;y<n;y++) {
                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
                ans = Math.min(Math.max(x, 0) + y, ans);
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
51151974,7d12d33c,"import java.io.*;
import java.util.*;
 public class Solution{
    public static void main (String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        int testCase = sc.nextInt();
        while (testCase-->0){
            int n = sc.nextInt();
            String[] strArr = new String[n];
            for(int i=0; i<n; i++) {
                strArr[i]=sc.nextLine();
            }
            int[] total = new int[5];
            ArrayList<int[]> al = new ArrayList<>();
            for(int i=0; i<n; i++){
                int[] arr= new int[5];
                for(int j=0; j<strArr[i].length(); j++){
                    arr[strArr[i].charAt(j)-'a']++;
                }
                for(int j=0; j<5; j++){
                    total[j]+=arr[j];
                }
                al.add(arr);
            }
            int ans=0;
            for(int i=0; i<5; i++){
                ArrayList<Integer> all = new ArrayList<>();
                for(int j=0; j<n; j++){
                    all.add(strArr[j].length()-2*al.get(j)[i]);
                }
                java.util.Collections.sort(all);
                int c=0, d=0;
                for(int j=0; j<n; j++){
                    c+=all.get(j);
                    if(c<0) d=j+1;
                }
                ans = Math.max(ans,d);
            }
            System.out.println(ans);
        }
    }
    // Fast Reader Class
    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.*;
import java.util.*;

import javax.management.Query;
public class Test{
    public static void main(String[] args) throws IOException, InterruptedException{
      Scanner sc = new Scanner(System.in);
     int t = sc.nextInt();
    
     while(t-->0){
      int n = sc.nextInt();
      String [] words = new String[n];
     
      for(int i =0;i<n;i++){
        words[i] = sc.nextLine();
       
      }
      int maxRes =0;
      for(int i =0;i<5;i++){
      int maxChar = 'a' +i;
      
      PriorityQueue<Pair> pq = new PriorityQueue<>();
      for (String word : words){
          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
      }
      int res = 0;
      int curr = 0;
      int maxCharCount = 0;
      int otherCharCount =0;
      while(!pq.isEmpty()){
        String word = pq.poll().x;
        maxCharCount +=occOfMaxChar(word, maxChar);
         otherCharCount += occOfOtherChar(word, maxChar);
         curr ++;
         if(maxCharCount >otherCharCount){
           res = curr;
         }
          
      }
      maxRes = Math.max(maxRes, res);
    }
    System.out.println(maxRes);}
   
  }
  public static int occOfMaxChar (String s, int maxChar){
     int occ = 0;
     for(int i =0 ;i<s.length();i++){
       if(s.charAt(i)==maxChar){
         occ++;
       }
      }
      return occ;
  }
  public static int occOfOtherChar (String s, int maxChar){
    int occ = 0;
    for(int i =0 ;i<s.length();i++){
      if(s.charAt(i)!=maxChar){
        occ++;
      }
     }
     return occ;
 }

    static int w;
    static int n;
    static long [][] memo;
    static int [] depth ;
    static long[] values;
    static ArrayList<Pair> gold ;
    


    static class Pair implements Comparable {
      String x;
      int y;
      public Pair (String x, int y) {
        this.x = x;
        this.y = y;
      }
      
    }
    
     }
",0,Non-plagiarised
3850468c,403e3270,"import java.io.*;
import java.util.*;
public class solution {
	static long cr[][]=new long[1001][1001];
	//static double EPS = 1e-7;
   static long mod=1000000007;
   
public static void main(String[] args)  {
	FScanner sc = new FScanner();
	//Arrays.fill(prime, true);
	//sieve();
	
	//ncr();
	int t=sc.nextInt();
	StringBuilder sb = new StringBuilder();
      while(t-->0) {	
      int n=sc.nextInt();
      long arr[]=new long[n];
      long dp[]=new long[n];
      long sum=0;
      for(int i=0;i<n;i++)
      {
    	  arr[i]=sc.nextInt();
    	  dp[i]=arr[i];
      }
        
      long l=0;long r=1000000000;
      long ans=0;
      while(l<=r)
      {
    	  long mid=(l+r)/2;
    	  dp=Arrays.copyOf(arr, n);
    	  if(solve(arr,dp,mid,n) )
    	  {
    		  ans=mid;
    		  l=mid+1;
    	  }
    	  else
    		  r=mid-1;
    	  
      }
      
      sb.append(ans);
        sb.append(""\n"");
	}
      System.out.println(sb.toString());
}  
 public static boolean solve(long arr[],long dp[],long sum,int n)
 {  
	  
	 for(int i=n-1;i>1;i--)
     {    if(dp[i]<=sum)
   	      continue;
   	  long val=Math.min(arr[i],dp[i]-sum)/3;
   	  dp[i-1]+=val;
   	  dp[i-2]+=2*val;
     }
     long min=Integer.MAX_VALUE;
     for(int i=0;i<n;i++)
     {
   	  min=Math.min(min,dp[i]);
     }
     if(min>=sum)
    	 return true;
     else
     return false;
 }


     
 /* public static void sieve()
{   prime[0]=prime[1]=false;
int n=1000000;
	for(int p = 2; p*p <=n; p++)
    {
        if(prime[p] == true)
        {
          
            for(int i = p*p; i <= n; i += p)
                prime[i] = false;
        }
    }
   */



}
 
  
 
 
","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
	
 
}
",0,Non-plagiarised
6bcc5afd,734a94be,"import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner s=new Scanner(System.in);
     int n=s.nextInt();
     int a[]=new int[n];
     ArrayList<Integer> lt1=new ArrayList<>();
     ArrayList<Integer> lt0=new ArrayList<>();
     for(int i=0;i<n;i++)
     {
         int l=s.nextInt();
         if(l==0)
         lt0.add(i+1);
         else
         lt1.add(i+1);
     }
     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
     for(int i=1;i<=lt1.size();i++)
     {
         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
         for(int j=i+1;j<=lt0.size();j++)
         {
             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
         }
     }
     System.out.println(dp[lt1.size()][lt0.size()]);
     
    }
}
","import java.io.*;
import java.math.*;
import java.util.*;



public class test {
	 
	   
	  
	    
	 
	   
	
	   
	     
	   public static void main(String args[]) throws Exception { 
		
		   Scanner sc = new Scanner();
		   StringBuffer res = new StringBuffer();
		   
		   int tc = 1;
		   
		   while(tc-->0) { 
			
			    int n = sc.nextInt();
			    
			    ArrayList<Integer> one = new ArrayList<>();
			    ArrayList<Integer> zero = new ArrayList<>();
			    
			    for(int i=0;i<n;i++) { 
			    	
			    	int x = sc.nextInt();
			    	
			    	if(x==1) { 
			    		one.add(i);
			    	}
			    	else { 
			    		zero.add(i);
			    	}
			    }
			    
			    int dp[][] = new int[one.size()+1][zero.size()+1];
			    
			     for(int i=1;i<=one.size();i++)
			     {
			         dp[i][i]=dp[i-1][i-1]+Math.abs(zero.get(i-1)-one.get(i-1));
			         for(int j=i+1;j<=zero.size();j++)
			         {
			             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));
			         }
			     }
			     System.out.println(dp[one.size()][zero.size()]);
		   }
			System.out.println(res);
	   }
}
",1,Plagiarised
9069684f,fffc11ee,"import java.io.*;
import java.util.*;

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

    static boolean[] vis;
    static ArrayList<Integer>[] adj;
    static int[] l, r;
    static long[][] dp;

    @SuppressWarnings(""unchecked"")
    public static void main(String[] args) throws IOException {
        int T = readInt();
        for (int t = 0; t < T; t++) {
            int n = readInt();
            l = new int[n + 1];
            r = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                l[i] = readInt();
                r[i] = readInt();
            }

            adj = new ArrayList[n + 1];
            for (int i = 1; i <= n; i++) adj[i] = new ArrayList<>();
            for (int i = 0; i < n - 1; i++) {
                int u = readInt(), v = readInt();
                adj[u].add(v);
                adj[v].add(u);
            }

            dp = new long[n + 1][2];
            vis = new boolean[n + 1];
            vis[1] = true;
            dfs(1);
            System.out.println(Math.max(dp[1][0], dp[1][1]));
        }
    }

    static void dfs(int u) {
        for (int x : adj[u]) {
            if (!vis[x]) {
                vis[x] = true;
                dfs(x);
                dp[u][0] += Math.max(dp[x][0] + Math.abs(l[u] - l[x]), dp[x][1] + Math.abs(l[u] - r[x]));
                dp[u][1] += Math.max(dp[x][0] + Math.abs(r[u] - l[x]), dp[x][1] + Math.abs(r[u] - r[x]));
            }
        }
    }

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine().trim());
        return st.nextToken();
    }

    static int readInt() throws IOException {
        return Integer.parseInt(next());
    }
}
","import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class C {

    private static final boolean TEST_MODE = true;
    private static Node[] tree;
    private static long[] lWt, rWt;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = getInt(br);
        for (int t=0; t<T; t++) {
            int N = getInt(br);

            tree = new Node[N+1];
            for (int v = 1; v <= N; v++) {
                String s = br.readLine();
                tree[v] = new Node(s);
            }

            for (int e=1; e<=N-1; e++) {
                int[] arr = getIntArray(2, br);
                int u = arr[0];
                int v = arr[1];
                tree[u].addNbr(v);
                tree[v].addNbr(u);
            }
            rootTheTree();

            lWt = new long[N + 1];
            rWt = new long[N + 1];
            Arrays.fill(lWt, -1);
            Arrays.fill(rWt, -1);
            getMaxBeauty();
        }
    }

    private static void rootTheTree() {
       // Arbitrarily pick the root as #1.
        Node root = tree[1];
        root.parent = 0;
        Queue<Integer> q = new LinkedList<>();
        q.add(1);

        // Constraint: Every node that is in the queue has parent already assigned.
        while (!q.isEmpty()) {
            int currId = q.poll();
            Node currNode = tree[currId];
            // Add all neighbours as children.
            for (int nbrId : currNode.nbrs) {
                if (nbrId == currNode.parent) {
                    continue;
                }
                tree[nbrId].parent = currId;
                currNode.addChild(nbrId);
                q.add(nbrId);
            }
//            currNode.nbrs.clear();
        }
    }

    private static void getMaxBeauty() throws Exception {
        Stack<Integer> stack = new Stack<>();
        stack.add(1);

        while (!stack.isEmpty()) {
            int currId = stack.pop();
            Node curr = tree[currId];

            // Is leaf ?
            if (curr.children.size() == 0) {
                lWt[currId] = 0;
                rWt[currId] = 0;
                continue;
            }
            // Are all children processed ?
            boolean allChildrenProcessed = (lWt[curr.children.get(0)] >= 0);
            if (allChildrenProcessed) {
                lWt[currId] = 0;
                rWt[currId] = 0;
                // Compute lwt and rwt maximized against each child.
                for (int childId : curr.children) {
                    Node childNode = tree[childId];
                    long ll = Math.abs(curr.left - childNode.left) + lWt[childId];
                    long lr = Math.abs(curr.left - childNode.right) + rWt[childId];
                    lWt[currId] += Math.max(ll, lr);

                    long rl = Math.abs(curr.right - childNode.left) + lWt[childId];
                    long rr = Math.abs(curr.right - childNode.right) + rWt[childId];
                    rWt[currId] += Math.max(rl, rr);
                }
            } else { // Add all unvisited children.
                stack.add(currId);
                stack.addAll(curr.children);
            }
        }
        long res = Math.max(lWt[1], rWt[1]);
        System.out.println(res);
    }

    

    

    private static Integer getInt(BufferedReader br) throws Exception {
        return Integer.parseInt(br.readLine());
    }

    

    private static int[] getIntArray(int N, BufferedReader br) throws Exception {
        String s = br.readLine();
        String[] tokens = s.split("" "");
        int[] result = new int[N];

        for (int i=0; i<N; i++) {
            result[i] = Integer.parseInt(tokens[i]);
        }
        return result;
    }

    

    
}

class Node {
    int parent = -1;
    List<Integer> nbrs = new ArrayList<>();
    List<Integer> children = new ArrayList<>();
    int left, right;

    public Node(int l, int r) {
        this.left = l;
        this.right = r;
    }

    public Node(String s) {
        String[] tokens = s.split("" "");
        this.left = Integer.parseInt(tokens[0]);
        this.right = Integer.parseInt(tokens[1]);
    }

    public void addNbr(int nbr) {
        nbrs.add(nbr);
    }

    public void addChild(int child) {
        children.add(child);
    }
}
",0,Non-plagiarised
54d7c21e,ad4c7a20,"import java.io.*;
import java.util.*;


public class cp {
	
//	static  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...
 */
	
	
	
	
	
	
	
	
	
	
	

	    // function to find last index <= y
    
     
	
	
	
          
	
	
	
	
	 
	// 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
	
	
	
	
	
	 static ArrayList<Integer> ans;
	
	
	
	
	
	
	
	
	
		
	


	

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

public class Main {
	static BufferedReader br;
	static PrintWriter pr;
	static int cin() throws Exception
	{
		return Integer.valueOf(br.readLine());
	}
	static int[] split() throws Exception
	{
		String[] cmd=br.readLine().split("" "");
		int[] ans=new int[cmd.length];
		for(int i=0;i<cmd.length;i++)
		{
			ans[i]=Integer.valueOf(cmd[i]);
		}
		return ans;
	}
	
	
	
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub 
		br=new BufferedReader(new InputStreamReader(System.in));
		pr=new PrintWriter(new OutputStreamWriter(System.out));
		int cases=cin();
		while(cases!=0)
		{
			cases--;
			int[]ar=split();
		    int n=ar[0];
		    int m=ar[1];
		    int[][]mat=new int[n][m];
		    for(int i=0;i<n;i++)
		    {
		    	String s=br.readLine();
		    	for(int j=0;j<m;j++)
		    	{
		    		mat[i][j]=s.charAt(j)-'0';
		    	}
		    }
		    ArrayList<String>ans=new ArrayList<>();
		    for(int i=0;i<n-1;i++)
		    {
		    	for(int j=0;j<m-1;j++)
		    	{
		    		if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+2)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		mat[i][j]=mat[i+1][j]=mat[i][j+1]=mat[i+1][j+1]=0;
		    	}
		    }
		    System.out.println(ans.size());
		    for(int i=0;i<ans.size();i++)
		    {
		    	System.out.println(ans.get(i));
		    }
		}
	}
}
","import java.io.*;
import java.util.*;

public class Main {
	static BufferedReader br;
	static PrintWriter pr;
	static int cin() throws Exception
	{
		return Integer.valueOf(br.readLine());
	}
	static int[] split() throws Exception
	{
		String[] cmd=br.readLine().split("" "");
		int[] ans=new int[cmd.length];
		for(int i=0;i<cmd.length;i++)
		{
			ans[i]=Integer.valueOf(cmd[i]);
		}
		return ans;
	}
	
	
	
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub 
		br=new BufferedReader(new InputStreamReader(System.in));
		pr=new PrintWriter(new OutputStreamWriter(System.out));
		int cases=cin();
		while(cases!=0)
		{
			cases--;
			int[]ar=split();
		    int n=ar[0];
		    int m=ar[1];
		    int[][]mat=new int[n][m];
		    for(int i=0;i<n;i++)
		    {
		    	String s=br.readLine();
		    	for(int j=0;j<m;j++)
		    	{
		    		mat[i][j]=s.charAt(j)-'0';
		    	}
		    }
		    ArrayList<String>ans=new ArrayList<>();
		    for(int i=0;i<n-1;i++)
		    {
		    	for(int j=0;j<m-1;j++)
		    	{
		    		if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		
		    		else if(mat[i][j]==1 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+2)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==1 && mat[i][j+1]==0 && mat[i+1][j]==0 && mat[i+1][j+1]==1)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1));
		    			ans.add((i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		else if(mat[i][j]==0 && mat[i][j+1]==1 && mat[i+1][j]==1 && mat[i+1][j+1]==0)
		    		{
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+1)+"" ""+(j+2)+"" ""+(i+2)+"" ""+(j+2));
		    			ans.add((i+1)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+1)+"" ""+(i+2)+"" ""+(j+2));
		    		}
		    		mat[i][j]=mat[i+1][j]=mat[i][j+1]=mat[i+1][j+1]=0;
		    	}
		    }
		    System.out.println(ans.size());
		    for(int i=0;i<ans.size();i++)
		    {
		    	System.out.println(ans.get(i));
		    }
		}
	}
}
",1,Plagiarised
24afd00e,424c930b,"import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
public class CP {
	  
	 static int mod  = 1000000007;
	 
	 
	 
	
	 

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

		static void TEST_CASE() {
		int n = sc.nextInt();
		 lr = new long[n][2];
		for(int  i =0 ; i < n ; i ++) {
			lr[i][0] = sc.nextLong();
			lr[i][1] = sc.nextLong();
		}
		 adj = new ArrayList<ArrayList<Integer>>();
		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
		
		for(int i = 0 ; i<n-1 ; i++) {
			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
			adj.get(u).add(v);
			adj.get(v).add(u);
		}
		min = new long[n];
		max = new long[n];
		dfs(0,-1);
		sb.append(Math.max(min[0], max[0])).append(""\n"");
		
		}
		static long[] min , max , lr[];
		static ArrayList<ArrayList<Integer>> adj;
		static void dfs(int u , int p  ) {
			
			for(int child:adj.get(u)) {
				if(child == p) continue;
				dfs(child , u);
			}
			long left = lr[u][0] , right = lr[u][1];
			
			long ansl = 0 , ansr = 0;
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
						max[child] +Math.abs(left - rightc)      );
			}
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
						max[child] +Math.abs(right - rightc)      );
			}
			min[u] = ansl;
			max[u] = ansr;
			
		}
		
}
","import java.io.*;
import java.util.*;


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

        double eps= 0.00000001;
        static final int MAXN = 10000001;

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

        Map<Integer,Set<Integer>> dp= new HashMap<>();

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

        // 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
        
        
        long[] dpl, dpr;
        List<Integer>[] adj;
        int[] l,r;
        public void solve(InputReader in, PrintWriter out) {
            int t= in.nextInt();
            while(t-->0){
                int n= in.nextInt();
                l= new int[n];
                r= new int[n];
                adj= new List[n];
                for(int i=0;i<n;i++){
                    l[i]= in.nextInt();
                    r[i]= in.nextInt();
                }
                for(int i=0;i<n;i++) adj[i]= new ArrayList<>();
                for(int i=0;i<n-1;i++){
                    int u= in.nextInt()-1, v= in.nextInt()-1;
                    adj[u].add(v); adj[v].add(u);
                }
                dpl= new long[n]; dpr= new long[n];
                dfs(0,-1);

                out.println(Math.max(dpl[0],dpr[0]));
                
            }
        }

        public void dfs(int u, int p){
            long suml=0, sumr=0;
            for(int v: adj[u] ){
                if(v==p) continue;
                dfs(v,u);
                suml+= Math.max((long)Math.abs((long)l[u]-(long)l[v])+dpl[v], (long)Math.abs((long)l[u]-(long)r[v])+dpr[v]);
                sumr+= Math.max((long)Math.abs((long)r[u]-(long)l[v])+dpl[v],(long) Math.abs((long)r[u]-(long)r[v])+dpr[v]);
            }
            dpl[u]= suml; dpr[u]= sumr;
        }

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

    }

    // static class Data{
    //     List<Integer> arr;
    //     BigInteger prod=new BigInteger(-1);
    //     public Data(List<Integer> arr, BigInteger prod) {
    //         this.arr= arr;
    //         this.prod= prod;
    //     }
    // }

    

    
    // fast input reader class;
    
}
",0,Non-plagiarised
a60fba84,c695a974,"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();
	}
	
}
","import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Solution {
    static PrintWriter fop = new PrintWriter(System.out);


    public static void main(String[] args) {
        FastScanner fsca = new FastScanner();
        int i, j = 0;
        int t = fsca.nextInt();
        u: while (t-- > 0) {
            int n = fsca.nextInt();
            int a[] = new int[n];
            for(i=0;i<n;i++){
                a[i] = fsca.nextInt();
            }
            int y = Integer.MAX_VALUE;
            long sum[] = new long[n];
            long min1[] = new long[n];
            sum[0] = a[0];
            sum[1] = a[1];
            min1[0] = a[0];
            min1[1] = a[1];
            for(i=2;i<n;i++){
                sum[i] = sum[i-2] + a[i];
                min1[i] = Math.min(min1[i-2],a[i]);
            }
            long val = sum[0]*n + sum[1]*n;
            long min = sum[0]*n + sum[1]*n;
            for(i=2;i<n;i++){
                val = sum[i] + min1[i]*(n-(i+2)/2) + sum[i-1] + min1[i-1]*(n-(i+1)/2);
                min = Math.min(min,val);
            }
            fop.println(min);
        }




















        fop.flush();
        fop.close();


    }
    /*-----------------------------------------------------------------------------------------------------------------------------------------------*/
    // template starts from here :

    

    


    static final Random random = new Random();

    

    


    

    

    
}
",0,Non-plagiarised
54488276,f4757480,"import java.io.*;
import java.util.*;

public class C {
	static int n;
	public static void main (String[] args) throws IOException {
		FastReader io = new FastReader();
		int t = io.nextInt();
		for (int ii=0; ii<t; ii++) {
			n = io.nextInt();

			String[] arr = new String[n];

			for (int i=0; i<n; i++) {
				String str = io.next();
				arr[i] = str;
			}

			char[] chars = new char[]{'a','b','c','d','e'};

			int ans = -1;

			for (int i=0; i<5; i++) {
				ans = Math.max(ans, solve(arr, chars[i]));
			}
			System.out.println(ans);
		}
	}

	static int solve(String[] arr, char c) {
		//System.out.println(""Comparing based on "" + c);
		Arrays.sort(arr, new Comp(c));

		int good = 0;
		int total = 0;
		int ret = 0;

		for (int i=0; i<n; i++) {
			//System.out.println(good + "" "" + total);
			for (int j=0; j<arr[i].length(); j++) {
				if (arr[i].charAt(j) == c) good++;
			}
			total += arr[i].length();
			if (2 * good > total) {
				ret++;
			} else {
				return ret;
			}
		}

		return ret;
	}

	static class Comp implements Comparator<String> {
		char c;

		public Comp (char c) {
			this.c = c;
		}

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

public class CF_1551c{
    public static final void main(String[] args){
        Kattio io= new Kattio();
        int t= io.getInt();
        while(t-->0){
            int n= io.getInt();
            int[][] ps= new int[5][n];
            for(int i=0; i<n; i++){
                String w= io.getWord();
                int len= w.length();
                // count letters
                for(int j=0; j<len; j++)
                    ps[w.charAt(j)-'a'][i]++;   
                // calculate diffs letter-!letter
                // e.g. a-!a = a-(a+b+c+d+e-a) = a-(len-a) = a + (a-len) = 2a-len
                for(int k=0; k<5; k++)
                    ps[k][i]+= ps[k][i]-len;   
            }
            //sort diffs
            for(int k=0; k<5; k++)
                //mergeSort(ps[k]);
                Arrays.sort(ps[k]);
            //calculate prefix sums of diffs (until they're non-positive)
            //start from the end as sort is ascending
            //pick largest index out of 5 letter at which sum of diffs is positive
            int max= 0;
            for(int k=0; k<5; k++){
                if(ps[k][n-1]<=0) continue;
                if(max==0) max= 1;
                for(int i=2; i<=n; i++){
                    ps[k][n-i]+= ps[k][n-i+1];
                    if(ps[k][n-i]<=0) break;
                    if(i>max) max= i;
                }
            }
            io.println(max);
        }
        io.close();
    }

    // using mergeSort to avoid Java quicksort TLE hacks
        
    
    static 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
169e34bf,ba468e1f,"import java.util.*;
public class D{
  static Scanner sc;
  public static void solve(){
    int n=sc.nextInt();
    Integer a[]=new Integer[n];
    int flag;
    for(int i=0;i<n;i++) a[i]=sc.nextInt();
    String s=sc.next();
    ArrayList<Integer> x=new ArrayList<>();
    ArrayList<Integer> y=new ArrayList<>();
    for(int i=0;i<n;i++){
      if(s.charAt(i)=='B') x.add(a[i]);
      else y.add(a[i]);
    }
    Collections.sort(x);
    Collections.sort(y);
    int p=n;
    int q=1;
    for(int i=y.size()-1;i>=0;i--){
      if(y.get(i)>p){System.out.println(""NO""); return;}
      p-=1;
    }
    for(int i=0;i<x.size();i++){
      if(x.get(i)<q){System.out.println(""NO""); return;}
      q+=1;
    }
    System.out.println(""YES"");
  }
  public static void main(String args[]){
      sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0) solve();
  }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
",0,Non-plagiarised
42c7b9df,adbb2f71,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class CSbalansirovannieKuchkiKamnei {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            long t1 = 0;
            long t2 = (int) 1e9 + 10;
            long[] b = new long[n];
            while (t1 < t2) {
                long mid = (t1 + t2 + 1) / 2;
                System.arraycopy(a, 0, b, 0, n);
                boolean fine = true;
                for (int i = n - 1; i >= 0; i--) {
                    if (b[i] < mid) {
                        fine = false;
                        break;
                    }
                    if (i >= 2) {
                        long how = Math.min(a[i], (b[i] - mid)) / 3;
                        b[i - 1] += how;
                        b[i - 2] += how * 2;
                    }
                }
                if (fine) {
                    t1 = mid;
                } else {
                    t2 = mid - 1;
                }
            }
            out.println(t1);
        }

    }

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.*;

public class cp {
    public static void main(String args[]) throws Exception {
        FastScanner sc = new FastScanner();
        int T = 1;
        T = sc.nextInt();
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        while (T-- > 0) {
            solve(sc, pw, sb);
        }
        pw.print(sb);
        pw.close();
    }
    public static void solve(FastScanner sc, PrintWriter pw, StringBuilder sb) throws Exception {
       int n=sc.nextInt();
       int[] h=new int[n];
       for(int i=0;i<n;i++){
            h[i]=sc.nextInt();
       }
       long low=0,high=(long)1e12,ans=low;
       while(low<=high){
            long mid=low+(high-low)/2L;
            if(ok(mid,h)){
                ans=mid;
                low=mid+1;
            }
            else{
                high=mid-1;
            }
       }
       sb.append(ans+""\n"");
    }

    public static boolean ok(long value,int[] h){
        int n=h.length;
        int[] copy=new int[n];
        for(int i=0;i<n;i++){
            copy[i]=h[i];
        }
        for(int i=n-1;i-2>=0;i--){
            if(copy[i]<value) return false;
            // we take this condition as the max stones that we can move is the number present in the heap not the copy by the condition di<=hi/3
            long toSub=Math.min(copy[i]-value,h[i])/3L;
            // System.out.println(""i: ""+i+"" toSub:""+toSub);
            copy[i-1]+=toSub;
            copy[i-2]+=toSub*2L;
        }
        // System.out.println(Arrays.toString(copy));
        if(copy[0]<value || copy[1]<value) return false;
        // System.out.println(""YES"");
        return true;
    }

    

    
    
    
}
",0,Non-plagiarised
5a81e159,866a2d52,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;


public class C_CF {

    public static void main(String[] args) {
        FastScanner57 fs = new FastScanner57();
        PrintWriter pw = new PrintWriter(System.out);
        int t = fs.ni();
        //int t = 1;
        for (int tc = 0; tc < t; tc++) {
            int n = fs.ni();
            long[][] lr = new long[n][2];
            for (int i = 0; i < n; i++) {
                lr[i][0] = fs.nl();
                lr[i][1] = fs.nl();
            }
            List<List<Integer>> list = new ArrayList();
            for (int i = 0; i < n;i ++) {
                List<Integer> temp = new ArrayList();
                list.add(temp);
            }
            for (int i = 0; i < n-1; i++) {
                int a = fs.ni()-1, b = fs.ni()-1;
                list.get(a).add(b);
                list.get(b).add(a);
            }
            Long[][] dp = new Long[n][2];
            pw.println(recur(0,0,-1,new long[] {0,0},dp,lr,list));
        }
        pw.close();

    }
    // 0 -> left was chosen
    // 1 -> right was chosen
    public static long recur(int ind, int p,int prev, long[] v, Long[][] dp, long[][] lr,List<List<Integer>> list) {

        long last = v[0];
        long ls = 0L;
        long rs = 0L;
        if (p==1) {
            last = v[1];
        }
        if (ind!=0) ls += (long)Math.abs(last-lr[ind][0]);
        if (ind!=0) rs += (long)Math.abs(last-lr[ind][1]);
        if (dp[ind][p]!=null) return dp[ind][p];
        long[] cur = lr[ind];
        
        List<Integer> temp = list.get(ind);
        for (int val : temp) {
            if (prev==val) continue;
            ls += recur(val,0,ind,cur,dp,lr,list);
            rs += recur(val,1,ind,cur,dp,lr,list);
        }
        return dp[ind][p] = Math.max(ls,rs);
    }

    

    

}




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

public class P1529C {
  public static final int MAX = 100000;

  private static final List<Integer>[] adjacency = new List[MAX];
  private static final int[][] pair = new int[MAX][2];

  public static void main(String[] args) {
    SpeedScanner in = new SpeedScanner();

    for(int i = 0; i < MAX; ++i)
      adjacency[i] = new ArrayList<>();

    int t = in.nextInt();
    while(t-- != 0) {
      int nv = in.nextInt();
      for(int i = 0; i < nv; ++i) {
        pair[i][0] = in.nextInt();
        pair[i][1] = in.nextInt();
      }
      for(int i = 1; i < nv; ++i) {
        int x = in.nextInt() - 1, y = in.nextInt() - 1;
        adjacency[x].add(y);
        adjacency[y].add(x);
      }

      long[] alts = dfsTraverse(0, -1);
      System.out.println(alts[0] >= alts[1] ? alts[0] : alts[1]);

      for(int i = 0; i < nv; ++i)
        adjacency[i].clear();
    }
  }

  private static long[] dfsTraverse(int vertex, int parent) {
    long sumDiffL = 0, sumDiffR = 0;
    for(int child: adjacency[vertex]) {
      if(child == parent)
        continue;
      long[] temp = dfsTraverse(child, vertex);
      sumDiffL += Math.max(Math.abs(pair[vertex][0] - pair[child][0]) + temp[0],
          Math.abs(pair[vertex][0] - pair[child][1]) + temp[1]);
      sumDiffR += Math.max(Math.abs(pair[vertex][1] - pair[child][0]) + temp[0],
          Math.abs(pair[vertex][1] - pair[child][1]) + temp[1]);
    }
    return new long[]{sumDiffL, sumDiffR};
  }
}


",0,Non-plagiarised
0ecf356d,b2bae06a,"import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] h = new int[n];
        int[] dp = new int[n];
        for(int i = 0; i<n; i++){
            h[i] = Integer.parseInt(st.nextToken());
        }
        Stack<Integer> hi = new Stack<>();
        Stack<Integer> lo = new Stack<>();
        hi.push(0);
        lo.push(0);
        for(int i = 1; i<n; i++){
            dp[i] = dp[i-1]+1;
            while(!hi.isEmpty() && h[hi.peek()]<h[i]){
                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
                hi.pop();
            }
            if(!hi.isEmpty()){
                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
                if(h[i] == h[hi.peek()]) hi.pop();
            }
            while(!lo.isEmpty() && h[lo.peek()]>h[i]){
                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
                lo.pop();
            }
            if(!lo.isEmpty()){
                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
                if(h[i] == h[lo.peek()]) lo.pop();
            }
            hi.push(i);
            lo.push(i);
        }
        System.out.println(dp[n-1]);
    }
}
","import java.util.*;
    import java.io.*;
    public class D{
        
        
         
        static int mod = (int)(1e9+7);
        

        public static void main(String[] args) {
            InputReader in = new InputReader(System.in);
            OutputWriter out = new OutputWriter(System.out);
            int n = in.nextInt();
            int[] arr = in.nextIntArray(n);
            Stack<Integer> min = new Stack<>();
            Stack<Integer> max = new Stack<>();
            int[] dp = new int[n];
            // Arrays.fill(dp,(int)1e9);
            dp[0] = 0;
            min.push(0);
            max.push(0);
            for(int i=1;i<n;i++)
            {
                int h=dp[i-1]+1;
                while(!max.isEmpty() && arr[i]>arr[max.peek()])
                {
                    int x = arr[max.peek()];
                    h = Math.min(h,1+dp[max.pop()]);
                    while(!max.isEmpty() && arr[max.peek()]==x)
                    {
                        max.pop();
                    }
                }
                if(!max.isEmpty())
                {
                    h = Math.min(h,1+dp[max.peek()]);
                }
                while(!min.isEmpty() && arr[i]<arr[min.peek()])
                {
                    int x = arr[min.peek()];
                    h = Math.min(h,1+dp[min.pop()]);
                    while(!min.isEmpty() && arr[min.peek()]==x)
                    {
                        min.pop();
                    }
                }
                if(!min.isEmpty())
                {
                    h = Math.min(h,1+dp[min.peek()]);
                }
                dp[i] = h;
                min.push(i);
                max.push(i);
            }
            out.printLine(dp[n-1]);
            out.flush();
            out.close();
        }
    }
",0,Non-plagiarised
66565156,6f393cfe,"import java.io.*;
import java.util.*;

public class A1 {
    static final Reader s = new Reader();
    static final PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        int t  = s.nextInt();
//        int t=1;
        for(int i=1; i<=t; ++i) {
//            out.print(""Case #""+i+"": "");
            new Solver();
        }
        out.close();
    }
    static class Solver {
    	Solver() {
    		int n = s.nextInt();
    		String[] a = new String[n];
    		int[][] cnt = new int[n][5];
    		for(int i=0;i<n;i++) {
    			char[] g = s.next().toCharArray();
    			for(int j=0;j<g.length;j++) {
    				cnt[i][g[j]-'a']++;
    			}
    		}
    		int g=0;
    		for(int i=0;i<5;i++) {
    			List<Integer> l = new ArrayList<>();
    			for(int j=0;j<n;j++) {
    				int sum=0;
    				for(int k=0;k<5;k++) {
    					if(i==k)sum+=cnt[j][k];
    					else sum-=cnt[j][k];
    				}
    				l.add(sum);
    			}
    			Collections.sort(l,Collections.reverseOrder());
    			int f=0;
    			int v=0;
    			for(int h:l) {
    				v += h;
    				if(v > 0)f++;
    				else break;
    			}
    			g = Math.max(g, f);
    		}
    		out.println(g);
    	}
    }
    

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

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
",1,Plagiarised
6f393cfe,d61f51c5,"import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class InterestingStrory {
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        try {
            // Scanner sc=new Scanner(System.in);
            FastReader sc = new FastReader();
            int t =sc.nextInt();
            while (t-- > 0) {
                int n=sc.nextInt();
                int[][] occ=new int[n][5];
                for(int i=0;i<n;i++){
                    char[] warr=sc.next().toCharArray();
                    for(char ch:warr){
                        occ[i][ch-'a']++;
                    }
                }
                int ans=Integer.MIN_VALUE;;
                for(int c=0;c<5;c++){
                    int[] sums=new int[n];
                    for(int i=0;i<n;i++){
                        int sum=0;
                        for(int j=0;j<5;j++){
                            if(c==j){
                                sum+=occ[i][j];
                            }
                            else{
                                sum-=occ[i][j];
                            }
                        }
                        sums[i]=sum;
                    }
                    Arrays.sort(sums);
                    int currSum=0;
                    int l=n-1;
                    for(l=n-1;l>=0;l--){
                        if(currSum+sums[l]<=0){
                            break;
                        }
                        else{
                            currSum+=sums[l];
                        }
                    }
                    ans=Math.max(ans,n-l-1);
                }
                System.out.println(ans);
            }
        } catch (Exception e) {
            return;
        }

    }
    

    

    

    
    
    
    

    
}
",1,Plagiarised
ac2dfc53,c4187a0e,"import java.io.*;

import java.util.*;
/*




*/

 
 public class C{
	static FastReader fs=null;
	static Scanner sc=null;
	
	public static void main(String[] args) {
		sc=new Scanner(System.in);
		int t=sc.nextInt();
		
		for(int tt=0;tt<t;tt++) {
			int n=sc.nextInt();
			
			boolean visited[]=new boolean[n+1];
			int p[]=new int[n+1];
			for(int i=1;i<=n;i++) {
				if(visited[i])continue;
				
				while(true) {
					int val=Query(i);
					if(val==i)break;
				}
				
				int cur=i;
				while(!visited[cur]) {
					int val=Query(i);
					visited[cur]=true;
					p[cur]=val;
					cur=val;
				}
			}
			
			System.out.print(""! "");
			for(int i=1;i<=n;i++)System.out.print(p[i]+"" "");
			System.out.println();
		}
	}
	static int Query(int id) {
		System.out.println(""? ""+id);
		int val=sc.nextInt();
		return val;
	}
	
	
	
	static void print(int a[]) {
		for(int e:a) {
			System.out.print(e+"" "");
		}
		System.out.println();
	}
	
	
	
	
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;

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

    static class CHiddenPermutations {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] arr = new int[n];
            boolean[] vis = new boolean[n];
            for (int i = 0; i < n; i++) {
                if (vis[i]) continue;
                ArrayList<Integer> cycle = new ArrayList<>();
                int ans = query(i, in);
                int now = query(i, in);
                cycle.add(now);
                while (now != ans) {
                    now = query(i, in);
                    cycle.add(now);
                }
                for (int j = 0; j < cycle.size(); j++) {
                    arr[cycle.get(j)] = cycle.get((j + 1) % cycle.size()) + 1;
                    vis[cycle.get(j)] = true;
                }
            }
            out.print(""! "");
            out.println(arr);
            out.flush();
        }

        int query(int ind, InputReader in) {
            System.out.println(""? "" + (ind + 1));
            return in.nextInt() - 1;
        }

    }

    

    
}
",0,Non-plagiarised
1c4d348d,565f77b7,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Solution {
    
    static class SortbyHeight implements Comparator<Struct>
        {
            
        }
    static class Struct{
        int h,ind;
        Struct(int h,int ind){
            this.h=h;
            this.ind=ind;
        }
    }

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

public class Solution {

	static Scanner scn = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static StringBuilder sb = new StringBuilder();

	public static void main(String[] HastaLaVistaLa) {
		int t = scn.nextInt();
		while(t-- > 0) solve();
		out.println(sb);
		out.close();
	}

	public static void solve() {
		// Road To Specialist Day 3
		int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
		int[] a = new int[n], ans = new int[n];
		for(int i = 0; i < n; i++) a[i] = scn.nextInt();
		PriorityQueue<Pair> pq = new PriorityQueue<>();
		for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
		for(int i = 0; i < n; i++) {
			int e = a[i];
			Pair p = pq.poll();
			p.value += e;
			pq.add(p);
			ans[i] = p.id + 1;
		}
		boolean check = false;
		long prev = pq.poll().value;
		while(!pq.isEmpty()) {
			long cur = pq.poll().value;
			if(Math.abs(cur - prev) > x) check = true;
			prev = cur;
		}
		if(check) sb.append(""NO"");
		else {
			sb.append(""YES\n"");
			for(int i : ans) sb.append(i + "" "");
		}
		sb.append(""\n"");
	}
	static class Pair implements Comparable<Pair> {
		int id;
		long value;
		public Pair(long value, int id) {
			this.id = id;
			this.value = value;
		}
		
	}
}
",0,Non-plagiarised
5449d33c,dff5ff0a,"import java.io.*;
import java.util.*;
import java.lang.*;

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

  static class Solver {
    public void Main(InputReader in, PrintWriter out) {
      int T = in.nextInt();
      for (int t = 0; t < T; t++) {
        int n = in.nextInt();
        String[] A = new String[n];
        for (int i = 0; i < n; i++) {
          A[i] = in.next();
        }
        int ans = 0;
        for (char c = 'a'; c <= 'e'; c++) {
          int[] ls = new int[n];
          for (int i = 0; i < n; i++) {
            int delta = 0;
            for (int j = 0; j < A[i].length(); j++) {
              if (A[i].charAt(j) == c) {
                delta += 1;
              } else {
                delta -= 1;
              }
            }
            ls[i] = delta;
          }
          Arrays.sort(ls, 0, n);
          int cur = 0;
          int score = 0;
          for (int i = n - 1; i >= 0; i--) {
            if (cur + ls[i] >= 1) {
              cur += ls[i];
              score += 1;
            }
          }
          ans = Math.max(ans, score);
        }
        out.println(ans);
      }
    }
  }

  
}
","import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;

public class Main {

    private static void run() throws IOException {
        int n = in.nextInt();
        char[][] a = new char[n][];
        for (int i = 0; i < n; i++) {
            a[i] = in.next().toCharArray();
        }
        int ans = Integer.MIN_VALUE;
        for (char now = 'a'; now <= 'e'; now++) {
            ans = Math.max(ans, check(a, now));
        }
        out.println(ans);
    }

    private static int check(char[][] a, char target) {
        int[] count = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            for (char c : a[i]) {
                if (c == target) {
                    count[i]++;
                } else {
                    count[i]--;
                }
            }
        }
        Arrays.sort(count);
        int ans = 0;
        int sum = 0;
        for (int i = a.length - 1; i >= 0; i--) {
            if (count[i] <= 0) break;

            ans++;
            sum += count[i];
        }

        if (ans == 0) return 0;

        for (int i = a.length - 1; i >= 0; i--) {
            if (count[i] > 0) continue;

            if (sum > -count[i]) {
                sum += count[i];
                ans++;
            }
        }
        return ans;
    }

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

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

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

    

    static final long mod = 1000000007;

    

    

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

    

    

    

    

    
}
",0,Non-plagiarised
47d54299,da0b7cb2,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class a {

   static int depth[];
   static ArrayList<Integer> tree[];
   static int diameter=0;

    public static void main(String[] args) {
        FastReader input=new FastReader();
        int t=input.nextInt();
        while (t-->0){
            diameter=0;
            int n=input.nextInt();
            int a=input.nextInt();
            int b=input.nextInt();
            int da=input.nextInt();
            int db=input.nextInt();
            depth=new int[n+1];
            tree=new ArrayList[n+1];
            for (int i = 0; i <=n ; i++) {
                tree[i]=new ArrayList<>();
            }
            for (int i = 0; i <n-1 ; i++) {
                int x=input.nextInt();
                int y=input.nextInt();
                tree[x].add(y);
                tree[y].add(x);
            }
            dfs(a,0);
//            System.out.println(depth[b]);
            if (2 * da >= Math.min(diameter, db) ||depth[b]<=da){
                System.out.println(""Alice"");
            }else {
                System.out.println(""Bob"");
            }



       }

    }

    private static int dfs(int root, int p) {
        int len=0;

        for(int child:tree[root]){
            if (child!=p){
                depth[child]=depth[root]+1;

                int curr=1+dfs(child,root);
                diameter=Math.max(diameter,curr+len);
                len=Math.max(len,curr);

            }
        }
        return len;

    }
    

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Codeforces {
    public static void main(String[] args) throws IOException {
        // InputStream inputStream = new FileInputStream(""input.txt"");
        // OutputStream outputStream = new FileOutputStream(""output.txt"");
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(in.nextInt(), in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(1000000007);
        long fact[];
        int depth[];
        int parentTable[][];
        int degree[];
        ArrayList<Integer> leaves;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        int diam = 0;

        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
                int n = in.nextInt();
                int a = in.nextInt();
                int b = in.nextInt();
                int na = in.nextInt();
                int nb = in.nextInt();

                ArrayList<ArrayList<Integer>> g = new ArrayList<>();
                for(int i=0;i<=n;i++)
                    g.add(new ArrayList<>());
                for(int i=1;i<n;i++){
                    int u = in.nextInt();
                    int v = in.nextInt();
                    g.get(u).add(v);
                    g.get(v).add(u);
                }

                if(2*na>=nb){
                    out.println(""Alice"");
                    continue;
                }

                // parentTable = new int[n+1][31];
                depth = new int[n+1];
                diam = 0;
                dfs(g , a , 0);

                int distance = depth[b];
                // out.println(distance);

                if(distance <= na){
                    out.println(""Alice"");
                    continue;
                }

                if(2*na >= min(nb , diam))
                    out.println(""Alice"");
                else
                    out.println(""Bob"");

                // max = Integer.MIN_VALUE;
                // int diameter = diameter(g , 1 , 0);
                // int height = 0;
                // for(int i=1;i<=n;i++)
                //     height = max(height , depth[i]);

                // // out.println(""diameter"" + diameter);
                // // out.println(""height"" + height);
                // // out.println(""max"" + max);

                // diameter = max(diameter-1 , height-1);
                // // diameter = max(diameter , max-1);

                // nb = min(nb , diameter);

                // na = min(na , diameter);


                // if(na*2 >= nb)
                //     out.println(""Alice"");
                // else
                //     out.println(""Bob"");


            }
        }

 
        int dfs(ArrayList<ArrayList<Integer>> a , int x, int p) {
            int len = 0;
            for(int y : a.get(x)) {
                if(y != p) {
                    depth[y] = depth[x] + 1;
                    int cur = 1 + dfs(a , y, x);
                    diam = max(diam, cur + len);
                    len = max(len, cur);
                }
            }
            return len;
        }

        

        // public void dfs(ArrayList<ArrayList<Integer>> a , int index , int parent){
        //     parentTable[index][0] = parent;
        //     for(int i=1;i<31;i++)
        //         parentTable[index][i] = parentTable[parentTable[parent][i-1]][i-1];

        //     depth[index] = 1+depth[parent];

        //     int l = a.get(index).size();
        //     for(int i=0;i<l;i++){
        //         if(a.get(index).get(i) == parent)
        //             continue;
        //         dfs(a , a.get(index).get(i) , index);
        //     }

        // }

        

        

        


        
        

        

        

        

        

        // for the min max problems
        
        

        // for printing purposes
        
        
        
        


        

        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    }

    
}
",1,Plagiarised
0b04b41e,fdd41565,"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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
     FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0)
     {
      Solve solve=new Solve();
      t--;
      int n=s.nextInt();
      String str[]=new String[n];
      for(int i=0;i<n;i++)
      str[i]=s.nextLine();
      char array[]=new char[]{'a','b','c','d','e'};
      int arr[]=new int[n];
      int ans=0;
      for(int i=0;i<5;i++)
      {
        Arrays.fill(arr,0);
          for(int j=0;j<n;j++)
          {
                 for(int k=0;k<str[j].length();k++)
                 {
                     if(str[j].charAt(k)==array[i])
                     arr[j]++;
                     else
                     arr[j]--;
                 }
          }
          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
      }
      System.out.println(ans);
     }
    }
}
class Solve{
    public int solve(int arr[],int n)
    {
        int ans=0;
        int sum=0;
        Arrays.sort(arr);
        for(int i=n-1;i>=0;i--)
        {
            if(sum+arr[i]>0)
            {
                sum+=arr[i];
                ans++;
            }
            else
            break;
        }
        return ans;
    }
}

",0,Non-plagiarised
9069684f,bf85ab7b,"import java.io.*;
import java.util.*;

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

    static boolean[] vis;
    static ArrayList<Integer>[] adj;
    static int[] l, r;
    static long[][] dp;

    @SuppressWarnings(""unchecked"")
    public static void main(String[] args) throws IOException {
        int T = readInt();
        for (int t = 0; t < T; t++) {
            int n = readInt();
            l = new int[n + 1];
            r = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                l[i] = readInt();
                r[i] = readInt();
            }

            adj = new ArrayList[n + 1];
            for (int i = 1; i <= n; i++) adj[i] = new ArrayList<>();
            for (int i = 0; i < n - 1; i++) {
                int u = readInt(), v = readInt();
                adj[u].add(v);
                adj[v].add(u);
            }

            dp = new long[n + 1][2];
            vis = new boolean[n + 1];
            vis[1] = true;
            dfs(1);
            System.out.println(Math.max(dp[1][0], dp[1][1]));
        }
    }

    static void dfs(int u) {
        for (int x : adj[u]) {
            if (!vis[x]) {
                vis[x] = true;
                dfs(x);
                dp[u][0] += Math.max(dp[x][0] + Math.abs(l[u] - l[x]), dp[x][1] + Math.abs(l[u] - r[x]));
                dp[u][1] += Math.max(dp[x][0] + Math.abs(r[u] - l[x]), dp[x][1] + Math.abs(r[u] - r[x]));
            }
        }
    }

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine().trim());
        return st.nextToken();
    }

    static int readInt() throws IOException {
        return Integer.parseInt(next());
    }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.io.DataInputStream;
import java.io.FileInputStream;

import java.io.IOException;

public class ParsasHumongousTree {

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

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

class Graph {

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

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

    void addEdge(int u, int v) {

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

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

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

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

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

}


",0,Non-plagiarised
ba468e1f,fb312dc6,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
    
    public static void main(String[] args)
    {
        FastScanner sc=new FastScanner();
        int t=sc.nextInt();
        PrintWriter pw=new PrintWriter(System.out);
        while(t-->0) {
            int n=sc.nextInt();
            int[] a=sc.readArray(n);
            char[] s=sc.next().toCharArray();
            boolean ok=true;
            ArrayList<Integer> blues=new ArrayList<>();
            ArrayList<Integer> reds=new ArrayList<>();
            for(int i=0;i<n;i++){
                if(s[i]=='B'){
                    blues.add(a[i]);
                } else {
                    reds.add(a[i]);
                }
            }
            Collections.sort(blues);
            Collections.sort(reds);
            for(int i=0;i<blues.size();i++){
                if(blues.get(i)<(i+1)){
                    ok=false;
                    break;
                }
            }
            int start=blues.size()+1;
            for(int i=0;i<reds.size();i++){
                if(reds.get(i)>(start++)){
                    ok=false;
                    break;
                }
            }
            if(ok){
               pw.println(""YES"");
            } else {
                pw.println(""NO"");
            }
        }
        pw.flush();
    }

    
}
",0,Non-plagiarised
505f8562,ed37ba7d,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.lang.System.out;
import static java.lang.Long.MAX_VALUE;

public final class Main{

    FastReader in;
    StringBuffer sb;
    public static void main(String[] args) {
        new Main().run();
    }

    void run(){
        in= new FastReader();
        start();
    }

    void start(){
        sb= new StringBuffer();
        for(int t=in.nextInt();t>0;t--)
            solve();
        out.print(sb);
    }

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

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

    

    

    long[] longArr(int n){
        long[] res= new long[n];
        for(int i=0;i<n;i++){
            res[i]= in.nextLong();
        }
        return res;
    }

    long MAX= MAX_VALUE;
    int[] precomp= new int[(int) (MAX+1)];
    

    

    

    

    
    

    

    

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

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

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

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

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

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

    // Pair

    

    // FastReader Class

    

    // Req Functions
    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    // debug

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

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    
}
",0,Non-plagiarised
d3a96420,ff34fab2,"import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc= new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0;i<n;i++)a[i]=sc.nextInt();
      String x=sc.next();
      Vector<Integer> R=new Vector<>();
      Vector<Integer> B=new Vector<>();
      for(int i=0;i<n;i++){
        if(x.charAt(i)=='B') R.add(a[i]);
        else B.add(a[i]);
      }
      Collections.sort(R);
      Collections.sort(B);
      boolean yes=true;
      for(int i=0;i<R.size();i++){
        if(R.get(i)-i<1){System.out.println(""NO"");yes=false;break;}
      }
      if(yes)
        {
          int s=B.size();
          for(int j=0;j<s;j++){
            if(B.get(j)+s-j>n+1){System.out.println(""NO"");yes=false;break;}
          }
        }
        if(yes)System.out.println(""YES"");
    }
    sc.close();
  }
}
","import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.*;
 
public class Div2 {
	
	

	 public static String solution(int [] arr, int n, String st) 
	 {
        ArrayList<Integer> red = new ArrayList<>();
        ArrayList<Integer> blue = new ArrayList<>();
        
        for(int i = 0; i<n; i++)
        {
        	if(st.charAt(i)=='R')
        		red.add(arr[i]);
        	else
        		blue.add(arr[i]);
        }
	    	
        Collections.sort(red);
        Collections.sort(blue);
        int cb = 1;
        
        for(int j = 0; j<blue.size(); j++)
        {
            if(blue.get(j)<cb)
            	return ""NO"";
            cb++;
        }
        
        int cr = n;
        for(int j = red.size()-1; j>=0; j--)
        {
            if(red.get(j)>cr)
            	return ""NO"";
            cr--;
        }
        
        return ""YES"";

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

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
	  
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	String st = s.next();
   
    	out.println(solution(arr,n, st));
    }
    
		     
    out.flush();
    out.close();
    
}
}
",0,Non-plagiarised
018c15bd,378bb1ca,"import java.util.*;
import java.util.Map.Entry;


import java.io.*;
import java.math.*;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Hey
{
	public static void main (String[] args) throws IOException
	{
		final long mod=(long) (1e9+7);  
		
		Reader s=new Reader();
		  PrintWriter pt=new PrintWriter(System.out);
//		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		  int T=s.nextInt();
//		  int T=Integer.parseInt(br.readLine());
//		  int T=1;
		  while(T-->0)
		  {
			  int n=s.nextInt();
			  int c[]=new int[n];
			  for(int i=0;i<n;i++) {
				  c[i]=s.nextInt();
			  }
			  long mo[]=new long[n];
			  long me[]=new long[n];
			  mo[0]=-1;
			  me[0]=-1;
			  mo[1]=c[0];
			  me[1]=c[1];
			  long so[]=new long[n];
			  long se[]=new long[n];
			  so[1]=c[0];
			  se[1]=c[1];
			  for(int i=2;i<n;i++) {
				  if(i%2==0) {
					  mo[i]=Math.min(c[i], mo[i-1]);
					  me[i]=me[i-1];
					  so[i]=so[i-1]+c[i];
					  se[i]=se[i-1];
				  }
				  else {
					  mo[i]=mo[i-1];
					  me[i]=Math.min(c[i], me[i-1]);
					  so[i]=so[i-1];
					  se[i]=se[i-1]+c[i];
				  }
			  }
			  
//			  pa(mo);
//			  pa(me);
//			  pa(so);
//			  pa(se);
			  long min=Long.MAX_VALUE;
			  for(int i=1;i<n;i++) {
				  long k1=0, k2=0;
				  if(i%2==1) {
					  k1=i/2+1;
					  k2=i/2+1;
				  }
				  else {
					  k2=i/2;
					  k1=k2+1;
				  }
				  min=Math.min((n-k1)*mo[i]+so[i]+(n-k2)*me[i]+se[i], min);
			  }
			  pt.println(min);
		  }
		  pt.close();
	}
	
	
	
	

	

	

	

	
	
	
	
	
	
	

	

	

			 //S%N, N is a power of 2

	
	
	
	
	 
	
	
	 
	 




	

	  
	  
	 
	
	
	  

	
	 
	
	
	
	     
	
	
	
	  

	 
     
     
	



	 
	
	
	
	
	 
  
    // Main function that sorts arr[l..r] using 
    // merge() 
     
	 
  
    // Main function that sorts arr[l..r] using 
    // merge() 
     
    
	 
}
","import java.util.*;

public class test {
    static final long mod = (long) 1e9 + 7;

    

    public static void main(String args[]) {

        Scanner sc = new Scanner(System.in);
        int t = 1;
        t = sc.nextInt();
        while (t-- > 0) {
            // Start code
            int n = sc.nextInt();
            long[] cost = new long[n];
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                cost[i] = sc.nextLong();
                a[i] = cost[i];
                if (i > 1)
                    a[i] = Math.min(a[i], a[i - 2]);
            }
            long sum = cost[0];
            long res = Long.MAX_VALUE;

            for (int i = 1; i < n; i++) {
                sum += cost[i];
                long cur = sum - a[i] - a[i - 1];
                int p = (i + 1) / 2;
                int q = (i + 1) - p;
                int x = n - p + 1;
                int y = n - q + 1;
                cur += (a[i - 1] * x + a[i] * y);
                res = Math.min(res, cur);
            }
            println(res);
        }
        sc.close();
    }

    

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

    

    

    

    

    

    
}
",0,Non-plagiarised
07043d35,97a7fab5,"import java.util.*;
import java.io.*;
 public class C{
     
    static int MOD=1000000007;
    static PrintWriter pw;
    static FastReader sc;
    
       


     
     
    

    
    
    
    // int [] arr=sc.intArr(n);
    static int Max=2*100005;

    // static int [][] arr= new int [Max][5];
    // static int [] tot= new int [Max];
    static ArrayList<ArrayList<Integer>> arr= new ArrayList<>();
    static ArrayList<Integer> tot= new ArrayList<>();
    static int fun(int ch , int n){
    	ArrayList<Integer> list= new ArrayList<>();
    	for(int i=0;i<n;i++){
    		list.add( (arr.get(i).get(ch))-(tot.get(i)-(arr.get(i).get(ch))) );
    	}
    	Collections.sort(list,Collections.reverseOrder());
    	int count=0,sum=0;
    	for(Integer x: list){
    		sum+=x;
    		if(sum>0){
    			count++;
    		}
    	}
    	return count;
    }

    static void solve() throws Exception{
    	int n=sc.nextInt();
    	arr= new ArrayList<>();
    	tot= new ArrayList<>();
    	for(int i=0;i<n;i++){
            arr.add( new ArrayList<>());
    		tot.add(0);
    		for(int j=0;j<5;j++){
    			ArrayList<Integer> list=arr.get(i);
    			list.add(0);
    		}
    	}
    	// pw.println(tot);
    	// pw.println(arr);
    	// return;
    	for(int i=0;i<n;i++){
    		String s=sc.next();
    		tot.set(i,s.length());
    		for(int j=0;j<s.length();j++){
    			ArrayList<Integer> list=arr.get(i);
    			list.set((s.charAt(j)-'a'),list.get((s.charAt(j)-'a'))+1);
    			// list.set((s.charAt(j)-'a'),1);
    		}
    	}
    	int ans =0;
    	for(int i=0;i<5;i++){
    		ans = Math.max(ans,fun(i,n));
    	}
    	pw.println(ans);
 }
    
   public static void main(String[] args) throws Exception{
        try {
            System.setIn(new FileInputStream(""input.txt""));
            System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
        } catch (Exception e) {
            System.err.println(""Error"");
        }
        sc= new FastReader();
        pw = new PrintWriter(System.out);

   
        int tc=1;
        tc=sc.nextInt();
        for(int i=1;i<=tc;i++) {
//            pw.printf(""Case #%d: ""b, i);
            solve();
        }
       
        pw.flush();

    

    }

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;


public class Main{

	static InputStream inputStream = System.in;
	static OutputStream outputStream = System.out;
	static InputReader in = new InputReader(inputStream);
	static PrintWriter out = new PrintWriter(outputStream);

	public static void main(String[] args) {

		int t = in.nextInt();

		while (t-- > 0) {
			int n = in.nextInt();
			String[] v = new String[n];

			for (int i = 0; i < n; i++) {
				v[i] = in.next();
			}

			ArrayList<ArrayList<Integer>> v1 = new ArrayList<>();

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

				for (int j = 0; j < 5; j++) {

					list.add(0);
				}
				v1.add(list);
			}

			for (int i = 0; i < n; i++) {
				String s = v[i];
				for (int j = 0; j < s.length(); j++) {
					int val = v1.get(i).get(s.charAt(j) - 'a');
					val++;
					v1.get(i).set(s.charAt(j) - 'a', val);

				}

			}
			int ret = 0;
			for (int i = 0; i < 5; i++) {
				ArrayList<Integer> v3 = new ArrayList<>();

				for (int j = 0; j < n; j++) {
					String s1 = v[j];
					int n2 = s1.length();
					int cnt = v1.get(j).get(i);
					int diff = cnt - (n2 - cnt);
					v3.add(diff);
				}
				Collections.sort(v3);
				Collections.reverse(v3);

				int till = 0;
				for (int k = 0; k < n; k++) {
					till += v3.get(k);
					if (till > 0) {
						ret = Math.max(ret, k + 1);
					}
				}

			}
			out.println(ret);

		}

		out.close();
	}

	

}
",0,Non-plagiarised
24b20554,43b10dec,"import java.util.*;
import java.lang.*;
public class Codeforces {
    static Scanner sr=new Scanner(System.in);
    public static void main(String[] args) throws java.lang.Exception {
        StringBuilder ans = new StringBuilder("""");
        int T = sr.nextInt();
        while (T-- > 0) {
            int n=sr.nextInt();
            int m=sr.nextInt();
            int x=sr.nextInt();
            TreeMap<Integer,ArrayList<Integer>>h=new TreeMap<>();
            for(int i=0;i<n;i++)
            {
                int a=sr.nextInt();
                if(!h.containsKey(a))
                    h.put(a,new ArrayList<>());
                h.get(a).add(i);
            }
            ans.append(""YES"");
            ans.append('\n');
            int an[]=new int[n];
            int q=0;
            for(int z:h.keySet())
            {
                for(int i=0;i<h.get(z).size();i++)
                {
                    an[h.get(z).get(i)]=(q++)%m+1;
                }
            }
            for(int i=0;i<n;i++)
                ans.append(an[i]+"" "");
            ans.append('\n');
        }
        System.out.println(ans);
    }
}
","import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.StringTokenizer;
import java.util.concurrent.TimeUnit;

public class C101 {

    static HritikScanner sc = new HritikScanner();
    static PrintWriter pw = new PrintWriter(System.out, true);

    public static void main(String[] args) {

        int t = ni();
        while (t-- > 0) {
            solve();
        }
    }

     static void solve() {
         int n = ni();
         int m = ni(), x = ni();
         Map<Integer, ArrayList<Integer>> map = new TreeMap<>();
         System.out.println(""YES"");
         for(int i = 0; i < n; i++)
         {
             int num = ni();
             if(!map.containsKey(num))
             {
                 map.put(num, new ArrayList<Integer>());
             }
             map.get(num).add(i);
         }
         int[] ans = new int[n];
         int q = 0;
         for(int block : map.keySet())
         {
             for(int i = 0; i < map.get(block).size(); i++)
             {
                 ans[map.get(block).get(i)] = (q++)%m+1;
             }
         }
         for(int ele : ans)
         {
             System.out.print(ele + "" "");
         }
     }
    
    
    /////////////////////////////////////////////////////////////////////////////////
    

    

    

    /////////////////////////////////////////////////////////////////////////////////
    static int ni() {
        return sc.nextInt();
    }

    

    

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

    

    

    

    

    

    

    

    

    

    

    

    

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

    /////////////////////////////////////////////////////////////////////////////////
    //-----------HritikScanner class for faster input----------//
    

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

    //////////////////////////////////////////////////////////////////
    // Function to return gcd of a and b time complexity O(log(a+b))
    

    // method to return LCM of two numbers 
    

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

    

    

    

    

    //////////////////////////////////////////////////////////////////
    // method returns Nth power of A 
    

}
",1,Plagiarised
1a6f8b20,77448a05,"import java.io.*;
import java.util.*;
public class Main
{
	public static void main(String[] args)throws Exception
	{
	    Main ob=new Main();
	    ob.fun();
	}
	public void fun()throws Exception
	{
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter pw=new PrintWriter(System.out);
	    int t=Integer.parseInt(br.readLine());
	    while(t-->0)
	    {
	        int n=Integer.parseInt(br.readLine());
	        int ar[][]=new int [n][5];
	        int len[]=new int[n];
	        for(int i=0;i<n;i++)
	        {
	            String s=(br.readLine());
	            for(int j=0;j<s.length();j++)
	            {
	                ar[i][s.charAt(j)-'a']++;
	                len[i]=s.length();
	            }
	        }
	        int max=0;
	        for(int i=0;i<5;i++)
	        {
	            int num=fun2(ar,len,i);
	            max=Math.max(num,max);
	        }
	        pw.println(max);
	        
	    }
	    pw.flush();
	}
	public int fun2(int ar[][],int len[],int col)
	{
	    int ct=0;
	    int n=ar.length;
	    PriorityQueue<Integer> pq=new PriorityQueue<Integer>(Collections.reverseOrder());
	    for(int i=0;i<n;i++)
	    {
	        int dif=2*ar[i][col]-len[i];
	        pq.add(dif);
	    }
	    int sum=0;
	    while(pq.size()>0)
	    {
	        int num=(int)(pq.poll());
	        if((sum+num)>0)
	        {
	            ct++;
	            sum+=num;
	        }
	    }
	    return ct;
	}
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.StringTokenizer;

public class P4 {
	static int N = 1000001;

	// Array to store inverse of 1 to N
	static long[] factorialNumInverse = new long[N + 1];

	// Array to precompute inverse of 1! to N!
	static long[] naturalNumInverse = new long[N + 1];

	// Array to store factorial of first N numbers
	static long[] fact = new long[N + 1];

	// Function to precompute inverse of numbers
	

	// Function to precompute inverse of factorials
	

	// Function to calculate factorial of 1 to N
	

	// Function to return nCr % p in O(1) time
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader sc = new FastReader();
		int t;
		t = sc.nextInt();
		StringBuilder st = new StringBuilder();
//		int p = 998244353;
//	    InverseofNumber(p);
//	    InverseofFactorial(p);
//	    factorial(p);
		// System.out.println(3|1);
		while (t-- != 0) {
			int n=sc.nextInt();
			String s[]=new String[n];
			for(int i=0;i<n;i++) {
				s[i]=sc.nextLine();
			}
			int max=0;
			ArrayList<Integer> freq=new ArrayList<>();
			for(int i=0;i<5;i++) {
				int f1=0;
				freq=new ArrayList<>();
				for(int j=0;j<n;j++) {
					f1=0;
					for(int k=0;k<s[j].length();k++) {
						if(s[j].charAt(k)==i+'a') {
							f1++;
						}else {
							f1--;
						}
					}
					freq.add(f1);
				}
				Collections.sort(freq);
				int x=0;
				int total=0;
				for(int j=n-1;j>=0;j--) {
					total=total+freq.get(j);
					if(total>0) {
						x++;
					}else {
						break;
					}
				}
				max=Math.max(max, x);
			}
			st.append(max+""\n"");
		}
		System.out.println(st);
	}

	static FastReader sc = new FastReader();

	

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

	

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

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

	

	

	

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

	public static void main(String[] args)throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int T = Integer.parseInt(br.readLine());
		while(T-- > 0) {
			int N = Integer.parseInt(br.readLine());
			char[] curr = br.readLine().toCharArray();
			char[] sol = br.readLine().toCharArray();
//			int oddP = 0;
//			int evenP = 0;
//			int even1 = 0;
//			int odd1 = 0;
//			int even0 = 0;
//			int odd0 = 0;
//			boolean alreadySolved = true;
//			for(int i = 0;i < N;i++) {
//				if(curr[i] == sol[i]) {
//					evenP++;
//					if(curr[i] == '1') even1++;
//					else even0++;
//				}
//				else {
//					oddP++;
//					if(curr[i] == '1') odd1++;
//					else odd0++;
//					alreadySolved = false;
//				}
//			}
//			
//			if(alreadySolved) {
//				System.out.println(0);
//				continue;
//			}
//			int minSwaps = Integer.MAX_VALUE;
//			if(N % 2 == 1) {
//				if(evenP % 2 == 1 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
//					minSwaps = Math.min(minSwaps, oddP);
//				}
//				if(oddP % 2 == 0 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
//					minSwaps = Math.min(minSwaps, evenP);
//				}
//			}
//			else {
//				if(evenP % 2 == 0 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
//					minSwaps = Math.min(minSwaps, oddP);
//				}
//				if(oddP % 2 == 1 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
//					minSwaps = Math.min(minSwaps, evenP);
//				}
//			}
//			System.out.println((minSwaps == Integer.MAX_VALUE) ? -1: minSwaps);
			
			int curr1 = 0;
			int sol1 = 0;
			int mismatch = 0;
			for(int i = 0;i < N;i++) {
				if(curr[i] == '1') curr1++;
				if(sol[i] == '1') sol1++;
				if(curr[i] != sol[i]) mismatch++;
			}
			
			int minAns = Integer.MAX_VALUE;
			//even operations
			if(curr1 == sol1 && mismatch % 2 == 0) {
				minAns = Math.min(mismatch, minAns);
			}
			//odd operations
			for(int i = 0;i < N;i++) {
				if(curr[i] == '1') {
					int tempcurr1 = N - curr1 + 1;
					int tempmismatch;
					if(sol[i] == '0') {
						tempmismatch = N - mismatch;
					}
					else {
						tempmismatch = N - mismatch - 1;
					}
					if(tempcurr1 == sol1 && tempmismatch % 2 == 0) {
						minAns = Math.min(minAns, tempmismatch + 1);
					}
				}
			}
			
			System.out.println((minAns == Integer.MAX_VALUE) ? -1 : minAns);
		}

	}

}
",0,Non-plagiarised
7f42483d,c9a316ca,"import java.io.*;
import java.util.*;

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

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

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

	static long[][] dp;

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


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

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

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

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

	}

	

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



import static javax.swing.UIManager.get;
import static javax.swing.UIManager.getString;


public class Main {


    static class Pair implements Comparable<Pair> {
        int x = 0;
        int y = 0;

        public Pair(int x1, int y1) {
            x = x1;
            y = y1;
        }


        
    }

    


    

    

    static int min = Integer.MAX_VALUE;

    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
//(1)very very important**(never take the first problem for granted, always check the test cases) take 5 minutes more and check the edge cases
        // 5 minutes will not decreases rating as much as a wrong submission does it is easy u just think with an open mind and u will surely get the answer
        //(2)let ur brain consume the problem don't just jump to the solution. after reading the problem take a pause 1 minute
        //(3)go through the example test cases and also at least two of ur own test cases.Think of testcases which are difficult(edge cases).dry run ur concept
 //(4) sometimes if else condition is not required but due to if else you miss some points and get wrong answer


        int t = sc.nextInt();
        while (t-- > 0) {

            int n =sc.nextInt();
            ArrayList<ArrayList<Integer>> list = new ArrayList<>();
            for(int i=0;i<n;i++)
                list.add(new ArrayList<Integer>());

            ArrayList<Pair> list1 = new ArrayList<>();

            for(int i=0;i<n;i++)
            list1.add(new Pair(sc.nextInt(),sc.nextInt()));

            for(int i=0;i<n-1;i++)
            {
                int a =sc.nextInt()-1,b=sc.nextInt()-1;
                list.get(a).add(b);
                list.get(b).add(a);
            }

            long[][] dp = new long[2][n];

            dfs(0,-1,dp,list,list1);


System.out.println(Math.max(dp[0][0],dp[1][0]));
        }



}

static void dfs(int u,int p,long[][] dp,ArrayList<ArrayList<Integer>> list,ArrayList<Pair> list1)
{
    for(int v:list.get(u))
    {  if(v==p)
        continue;
        dfs(v,u,dp,list,list1);
        dp[1][u]+= Math.max(Math.abs(list1.get(u).y-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).y-list1.get(v).y)+dp[1][v]);
        dp[0][u]+=Math.max(Math.abs(list1.get(u).x-list1.get(v).x)+dp[0][v],Math.abs(list1.get(u).x-list1.get(v).y)+dp[1][v]);

    }

}


//static int lcs( int[] X, int[] Y, int m, int n )
//{
//    int L[][] = new int[m+1][n+1];
//
//    /* Following steps build L[m+1][n+1] in bottom up fashion. Note
//        that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
//    for (int i=0; i<=m; i++)
//    {
//        for (int j=0; j<=n; j++)
//        {
//            if (i == 0 || j == 0)
//                L[i][j] = 0;
//            else if (X[i-1] == Y[j-1])
//                L[i][j] = L[i-1][j-1] + 1;
//            else
//                L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
//        }
//    }
//    return L[m][n];
//}























// syntax of conditional operator y=(x==1)?1:0;
//Things to check when u r getting wrong answer
// 1-  check the flow of the code
//2- If ur stuck read the problem once again
//3- before submitting always check the output format of ur code
//4- don't check standings until problem B is done
//5- if u r thinking ur concept is correct but still u r getting wrong answer try to implement it in another way
//6- By default, java interpret all numeral literals as 32-bit integer values.
// If you want to explicitely specify that this is something bigger then 32-bit integer you should use suffix L for long values.    example   long a = 600851475143L

//All the functions




    

    










    

    //collections.sort use merge sort instead of quick sort but arrays.sort use quicksort whose worst time complexity is O(n^2)
    

    //function to print an array for debugging
    

    


    //normal gcd function, always put the greater number as a and the smaller number as b
    

    


    //to find gcd and lcm for numbers of long data type
    

    


    //Input Reader to read faster input
    



}
",0,Non-plagiarised
0d4d22e0,f898cee0,"import java.util.*;
public class CodeForces {
	static ArrayList<String>res;
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int test = input.nextInt();
		while(test-->0){
			int n = input.nextInt();
			int m = input.nextInt();
			char arr[][] = new char[n][m];
			res = new ArrayList<>();
			for(int i =0;i<n;i++){
				for(int j =0;j<1;j++){
					arr[i] = input.next().toCharArray();
				}
			}
			for(int i =0;i<n-1;i++){
				for(int j =0;j<m-1;j++){
					int count =0;
					if(arr[i+1][j] == '1')count++;
					if(arr[i][j+1] == '1')count++;
					if(arr[i][j] == '1')count++;
					if(arr[i+1][j+1] == '1')count++;
					if(count == 0)continue;
					if(count == 1)one(arr,i,j);
					if(count == 2)two(arr,i,j);
					if(count == 3)three(arr,i,j);
					if(count == 4)four(arr,i,j);
				}
			}
			System.out.println(res.size());
			for(String it:res)System.out.println(it);
		}	
	}
	public static void one(char arr[][],int i,int j){
		int row = i+2;
		int col = j+2;
		int count =0;
		StringBuilder sb = new StringBuilder();
		for(int x=i;x<row;x++){
			for(int y = j;y<col;y++){
				if(arr[x][y] == '1' ){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '0';
					sb.append("" "");
				}else if(arr[x][y] == '0' && count<2){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '1';
					sb.append("" "");
					count++;
				}
			}
		}
		res.add(sb.toString());
		two(arr,i,j);
	}
	public static void two(char arr[][],int i,int j){
			int row = i+2;
			int col = j+2;
			boolean ok = true;
			StringBuilder sb = new StringBuilder();
			for(int x=i;x<row;x++){
				for(int y = j;y<col;y++){
					if(arr[x][y] == '1' && ok){
						sb.append(x+1);
						sb.append("" "");
						sb.append(y+1);
						arr[x][y] = '0';
						sb.append("" "");
						ok = false;
					}else if(arr[x][y] == '0'){
						sb.append(x+1);
						sb.append("" "");
						sb.append(y+1);
						arr[x][y] = '1';
						sb.append("" "");
					}
				}
			}
			res.add(sb.toString());
			three(arr,i,j);
		}
	public static void three(char arr[][],int i,int j){
		StringBuilder sb = new StringBuilder();
		if(arr[i][j] == '1'){
			sb.append(i+1);
			sb.append("" "");
			sb.append(j+1);
			arr[i][j] = '0';
			sb.append("" "");
		}
		if(arr[i+1][j] == '1'){
			sb.append(i+2);
			sb.append("" "");
			sb.append(j+1);
			arr[i+1][j] = '0';
			sb.append("" "");
		}
		if(arr[i][j+1] == '1'){
			arr[i][j+1] ='0';
			sb.append(i+1);
			sb.append("" "");
			sb.append(j+2);
			sb.append("" "");
		}
		if(arr[i+1][j+1] == '1'){
			arr[i+1][j+1] = '0';
			sb.append(i+2);
			sb.append("" "");
			sb.append(j+2);
		}
		res.add(sb.toString());
	}
	public static void four(char arr[][],int i,int j){
		int row = i+2;
		int col = j+2;
		int count =0;
		StringBuilder sb = new StringBuilder();
		for(int x=i;x<row;x++){
			for(int y = j;y<col;y++){
				if(count<3){
					sb.append(x+1);
					sb.append("" "");
					sb.append(y+1);
					arr[x][y] = '0';
					sb.append("" "");
					count++;
				}
			}
		}
		res.add(sb.toString());
		one(arr,i,j);
	}
}
","import java.util.*;
import java.io.*;
public class C{
    
    
     
    static int mod = (int)(1e9+7);
    
    
    static void flip(char[][] arr,int i,int j)
    {
        if(arr[i][j]=='1')
            arr[i][j] = '0';
        else
            arr[i][j] = '1';
    }
    static void add2s(StringBuilder sb,int n,int m)
    {
        sb.append((n) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m) + "" ""  +(n) + "" "" + (m)+""\n"");
        sb.append((n-1) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m) + "" ""  +(n) + "" "" + (m)+""\n"");
    }
    static void add3s(StringBuilder sb,int n,int m)
    {
        sb.append((n) +"" "" + (m-1) + "" ""  +(n-1) + "" "" + (m-1) + "" ""  +(n) + "" "" + (m)+""\n"");
        sb.append((n-1) +"" "" + (m-1) + "" ""  +(n) + "" "" + (m-1) + "" ""  +(n-1) + "" "" + (m)+""\n"");
    }
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        OutputWriter out = new OutputWriter(System.out);
        int t = in.nextInt();
        while(t-- >0)
        {
            // out.printLine(""UAShd"");
            int n = in.nextInt(),m = in.nextInt();
            char[][] arr = new char[n][m];
            for(int i=0;i<n;i++)
                arr[i] = in.nextLine().toCharArray();
            // boolean[][] flip = new boolean[n][m];
            int nops = 0;
            StringBuilder res = new StringBuilder();
            //do till row n-1
            for(int i=0;i<n-1;i++)
            {
                for(int j=0;j<m;j++)
                {
                    if(arr[i][j]=='1')
                    {
                        nops++;
                        if(j==m-1)
                        {
                            res.append((i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j) + ""\n"");
                            flip(arr,i,j);
                            flip(arr,i+1,j);
                            flip(arr,i+1,j-1);
                        }
                        else
                        {
                            res.append((i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
                            flip(arr,i,j);
                            flip(arr,i+1,j);
                            flip(arr,i+1,j+1);
                        }
                    }
                }
            }
            // out.printLine(nops);
            int i = n-2;
            for(int j=0;j<m-1;j++)
            {
                char a = arr[i][j],b = arr[i+1][j];
                if(a=='0' && b=='0')
                {
                    continue;
                }
                else if(a=='0' && b=='1')
                {
                    nops++;
                    res.append((i+2) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+2) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
                    flip(arr,i+1,j);
                    flip(arr,i,j+1);
                    flip(arr,i+1,j+1);
                }
                else if(a=='1' && b=='0')
                {
                    nops++;
                    res.append((i+1) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+2) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
                    flip(arr,i,j);
                    flip(arr,i,j+1);
                    flip(arr,i+1,j+1);
                }
                else
                {
                    nops++;
                    res.append((i+2) + "" "" + (j+1) + "" "" + (i+1) + "" "" + (j+1) + "" "" + (i+2) + "" "" + (j+2) + ""\n"");
                    flip(arr,i+1,j);
                    flip(arr,i,j);
                    flip(arr,i+1,j+1);
                }
            }
            // out.printLine(nops);
            char a = arr[n-2][m-1];
            char b = arr[n-1][m-1];
            if(a=='0' && b=='0')
            {

            }
            else if(a=='1' && b=='0')
            {
                nops+=3;
                res.append((n-1) + "" "" + (m) + "" "" + (n-1) + "" "" + (m-1) + "" "" + (n) + "" "" + (m-1)+""\n"");
                add2s(res,n,m);
            }
            else if(a=='0' && b=='1')
            {
                nops+=3;
                res.append((n) + "" "" + (m) + "" "" + (n-1) + "" "" + (m-1) + "" "" + (n) + "" "" + (m-1)+""\n"");
                add2s(res,n,m);
            }
            else
            {
                nops+=2;
                add3s(res,n,m);
            }
            // out.printLine(""UAShd"");
            // for(i=0;i<n;i++)
                // out.printLine(new String(arr[i]));
            // if(nops>0)
                // res.deleteCharAt(res.length()-1);
            out.printLine(nops);
            if(nops>0)
                out.print(res);
        }
        out.flush();
        out.close();
    }
}
",0,Non-plagiarised
6db218a2,90b71536,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main{
    
 
    
    
    public static void sortbyColumn(int arr[][], int col) 
    { 
        
        Arrays.sort(arr, new Comparator<int[]>() { 
            
           
        });  
    } 
    
    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;
    
        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }
    
        
    
        
    
        
    
        
    
    }
    
    
    
    
    
    
    
    // static void calc(int n){
    //     int i,j;
    //     dp[n-1]=0;
    //     if(n>1)
    //     dp[n-2]=1;
    //     for(i=n-3;i>=0;i--){
    //         long ind=n-i-1;
    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
    //     }
    // }
    
    static long dist[],dp[][],left[],right[];
    static int visited[],isit[];
    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
    //static int dp[][][];
    static int MOD=1000000007;
    static char ch[];
    static int[] sieve,is_sieve;
    static TreeSet<Integer> tr;
    static long mat[][];
    
    
    static void dfs(int node,int par, Pair<Long,Long> p[]){
        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
            if(pp.x!=par){
                //sum+=Math.abs(selected[node]-selected[pp.x]);
                dfs(pp.x,node,p);
                //System.out.println(node+"" ""+pp.x);
                long x=Math.abs(p[node].x-p[pp.x].x);
                long y=Math.abs(p[node].x-p[pp.x].y);
                long z=Math.abs(p[node].y-p[pp.x].x);
                long w=Math.abs(p[node].y-p[pp.x].y);
                
                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
                
            }
        }
    }
    
    public static void main(String args[]){
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter w = new PrintWriter(outputStream);
        int t,i,j,tno=0,tte;
        
        t=in.nextInt();
        //t=1;
        //tte=t;
        
        while(t-->0){
            //sum=0;
            int n=in.nextInt();
            adj=new ArrayList[n+1];
            left=new long[n+1];
            right=new long[n+1];
            visited=new int[n+1];
            for(i=0;i<n+1;i++){
                adj[i]=new ArrayList<>();
            }
            Pair<Long,Long> p[]=new Pair[n+1];
            for(i=1;i<=n;i++){
                p[i]=new Pair<>(in.nextLong(),in.nextLong());
            } 
            for(i=0;i<n-1;i++){
                int u,v;
                u=in.nextInt();
                v=in.nextInt();
                adj[u].add(new Pair<>(v,p[v]));
                adj[v].add(new Pair<>(u,p[u]));
            }
            
            dfs(1,-1,p);
            // for(i=0;i<n+1;i++){
            //     w.print(selected[i]+"" "");
            // }
            // w.println();
            w.println((long)Math.max(left[1],right[1]));
        }
        w.close();
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main{
    
 
    
    
    public static void sortbyColumn(int arr[][], int col) 
    { 
        
        Arrays.sort(arr, new Comparator<int[]>() { 
            
           
        });  
    } 
    
    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;
    
        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }
    
        
    
        
    
        
    
        
    
    }
    
    
    
    
    
    
    
    // static void calc(int n){
    //     int i,j;
    //     dp[n-1]=0;
    //     if(n>1)
    //     dp[n-2]=1;
    //     for(i=n-3;i>=0;i--){
    //         long ind=n-i-1;
    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
    //     }
    // }
    
    static long dist[],dp[][],left[],right[];
    static int visited[],isit[];
    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
    //static int dp[][][];
    static int MOD=1000000007;
    static char ch[];
    static int[] sieve,is_sieve;
    static TreeSet<Integer> tr;
    static long mat[][];
    
    // static void bfs(int node,int par,Pair<Long,Long> p[],long taken){
    //     LinkedList<Integer> li=new LinkedList<>();
    //     li.add(node);
        
    //     while(!li.isEmpty()){
    //         int x=li.pollFirst();
    //         long lowNode=p[x-1].x;
    //         long highNode=p[x-1].y;
    //         int left=0,right=0;
    //         visited[x]=1;
    //         for(Pair<Integer,Pair<Long,Long>> pp:adj[x]){
                    
    //                 long max=0;
                    
    //                 if(selected[pp.x]==0){
    //                     max=Math.max(Math.abs(lowNode-pp.y.y),Math.abs(highNode-pp.y.x));
                        
    //                     if(max==Math.abs(lowNode-pp.y.y)){
                            
    //                         left++;
    //                     }else{
                            
    //                         right++;
    //                     }
    //                 }else{
    //                     max=Math.max(Math.abs(lowNode-selected[pp.x]),Math.abs(highNode-selected[pp.x]));
    //                     if(max==Math.abs(lowNode-selected[pp.x])){
                            
    //                         left++;
    //                     }else{
                            
    //                         right++;
    //                     }
    //                 }
    //                 if(visited[pp.x]==0)
    //                 li.add(pp.x);
                
    //         }
    //         if(left>=right){
    //             selected[x]=lowNode;
    //         }else{
    //             selected[x]=highNode;
    //         }
    //     }
    // }
    static void dfs(int node,int par, Pair<Long,Long> p[]){
        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
            if(pp.x!=par){
                //sum+=Math.abs(selected[node]-selected[pp.x]);
                dfs(pp.x,node,p);
                //System.out.println(node+"" ""+pp.x);
                long x=Math.abs(p[node].x-p[pp.x].x);
                long y=Math.abs(p[node].x-p[pp.x].y);
                long z=Math.abs(p[node].y-p[pp.x].x);
                long w=Math.abs(p[node].y-p[pp.x].y);
                
                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
                
            }
        }
    }
    
    public static void main(String args[]){
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter w = new PrintWriter(outputStream);
        int t,i,j,tno=0,tte;
        
        t=in.nextInt();
        //t=1;
        //tte=t;
        
        while(t-->0){
            //sum=0;
            int n=in.nextInt();
            adj=new ArrayList[n+1];
            left=new long[n+1];
            right=new long[n+1];
            visited=new int[n+1];
            for(i=0;i<n+1;i++){
                adj[i]=new ArrayList<>();
            }
            Pair<Long,Long> p[]=new Pair[n+1];
            for(i=1;i<=n;i++){
                p[i]=new Pair<>(in.nextLong(),in.nextLong());
            } 
            for(i=0;i<n-1;i++){
                int u,v;
                u=in.nextInt();
                v=in.nextInt();
                adj[u].add(new Pair<>(v,p[v]));
                adj[v].add(new Pair<>(u,p[u]));
            }
            //bfs(1,-1,p,Long.MAX_VALUE);
            dfs(1,-1,p);
            // for(i=0;i<n+1;i++){
            //     w.print(selected[i]+"" "");
            // }
            // w.println();
            w.println((long)Math.max(left[1],right[1]));
        }
        w.close();
    }
}
",1,Plagiarised
60c85a4f,8926151a,"import java.util.*;
import java.io.*;
import java.lang.*;

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

    String next() {
        if (!st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {

            }
        }
        return st.nextToken();
    }

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

    

    public static void main(String[] args) {
        new Solution().solve();
    }

    long res = Long.MAX_VALUE;
    List<Integer> l = new ArrayList<>(), r = new ArrayList<>();
    long dp[][];

    long ok(int i, int j) {
        if (dp[i][j] != -1)
            return dp[i][j];
        if (i >= l.size()) {
            return 0;
        }
        if (j >= r.size())
            return Integer.MAX_VALUE;
        long op1 = ok(i + 1, j + 1) + Math.abs(l.get(i) - r.get(j));
        long op2 = ok(i, j + 1);

        return dp[i][j] = Math.min(op1, op2);
    }

    void solve() {
        int t = 1;
        // t = nextInt();
        for (int tt = 0; tt < t; tt++) {
            int n = nextInt();
            int arr[] = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
                if (arr[i] == 0)
                    r.add(i + 1);
                else
                    l.add(i + 1);
            }
            dp = new long[n][n];
            for (int i = 0; i < n; i++)
                Arrays.fill(dp[i], -1);
            out.println(ok(0, 0));
        }
        out.close();
    }
}
","import java.util.*;
import java.io.*;

public class _1525_D {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int n = Integer.parseInt(in.readLine());
        int[] a = new int[n];
        StringTokenizer line = new StringTokenizer(in.readLine());
        int c = 0;
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(line.nextToken());
            if (a[i] == 1)
                c++;
        }
        int[] pos = new int[c];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] == 1) {
                pos[count] = i;
                count++;
            }
        }
        int[][] dp = new int[c + 1][n];
        for (int i = 1; i <= c; i++) {
            Arrays.fill(dp[i], Integer.MAX_VALUE);
        }
        for (int i = 1; i <= c; i++) {
            for (int j = 0; j < n; j++) {
                if (j > 0) {
                    if (a[j] == 0) {
                        if (dp[i - 1][j - 1] != Integer.MAX_VALUE) {
                            dp[i][j] = dp[i - 1][j - 1] + Math.abs(j - pos[i - 1]);
                        }
                    }
                    dp[i][j] = Math.min(dp[i][j], dp[i][j - 1]);
                } else {
                    if (a[j] == 0 && i == 1) {
                        dp[i][j] = Math.abs(j - pos[i - 1]);
                    }
                }
            }
        }
        out.println(dp[c][n - 1]);
        in.close();
        out.close();
    }
}
",0,Non-plagiarised
a4d6775d,cb87df79,"import java.io.*;
import java.util.*;
 
public class ArmChairs {
    
 
    public static int solution(int n, int[] arr) {
 
        ArrayList<Integer> one = new ArrayList<Integer>();
        ArrayList<Integer> zero = new ArrayList<Integer>();
 
        for (int i = 0; i < n; i++) {
            if (arr[i] == 1) {
                one.add(i);
            } else {
                zero.add(i);
            }
        }
 
        int[][] dp = new int[one.size() + 1][zero.size() + 1];
 
        for (int i = 1; i <= one.size(); i++) {
            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
            for (int j = i + 1; j <= zero.size(); j++) {
                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
            }
        }
 
        return dp[one.size()][zero.size()];
    }
 
 
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int n = Integer.parseInt(br.readLine());
 
        String[] s = br.readLine().split("" "");
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(s[i]);
        } 
 
        log.write(Integer.toString(solution(n, arr)) + ""\n"");
        log.flush();
        
    }
 
}
","import java.util.*;

public class Longjumps {
	 public static void main(String[] args){
		 Scanner sc=new Scanner(System.in);
			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
			int n = sc.nextInt();
			for(int i=1;i<=n;i++){
				int x=sc.nextInt();
				if(x==1)o.add(i);
				else e.add(i);
			}
			int dp[][]=new int[o.size()+1][e.size()+1];
			for(int i=1;i<=o.size();i++){
				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
				for(int j=i+1;j<=e.size();j++)
					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
			System.out.println(dp[o.size()][e.size()]);
	 }
}
",1,Plagiarised
7d9b95c0,9d33ca79,"import java.util.*;
import java.math.*;
public class Main {
	
	public static class Edge{
		int u;
		int v;
//		int wt;
		Edge(int u, int v){
			this.u = u;
			this.v = v;
//			this.wt = wt;
		}
	}

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

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

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

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

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

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

            }
        }


    static class Pair implements Comparable<Pair>{
        int x;
        int y ;
        Pair(int x , int y ){
            this.x=x;
            this.y=y;
        }

        
    }
    
}
",0,Non-plagiarised
354d060f,e1c4f3db,"import java.util.*;
import java.io.*;
public class CodeForces {
	// For fast input output
	

	// end of fast i/o code
	public static void main(String[] args) {
		FastReader in = new FastReader();
		OutputStream op = System.out;
		PrintWriter out = new PrintWriter(op);
		int t = in.nextInt();
		for (int i = 1; i <= t; i++) {
			int n=in.nextInt();
			int arr[]=new int[n];
			for(int j = 0; j < n; j++)
				arr[j]=in.nextInt();
			helper(n,arr,out);
			out.println();
		}
		out.close();

	}

public static void helper(int n,int arr[],PrintWriter o) 
	{
		int max=Integer.MIN_VALUE;
		for(int i=2;i<n;i++)
				max=Math.max(max,arr[i]);
		int ans=1,low=1,high=max;
		while(low<=high)
		{
			int mid=low+(high-low)/2;
			if(canFit(mid,arr))
				{
					ans=mid;
					low=mid+1;
				}
				else 
					high=mid-1;
		}
		o.print(ans);
	}
	static	boolean canFit(int mid,int arr[])
	{
		int copy[]=Arrays.copyOf(arr, arr.length);
		for(int i=arr.length-1;i>=0;i--)
		{
			if(copy[i]<mid)
				return false;
			int min=Math.min(copy[i]-mid,arr[i])/3;
			if(i>=2){
			copy[i-1]+=min;
			copy[i-2]+=2*min;
		}}
		return true;
	}
}
","import java.util.*;

public class BalancedStoneHeaps {

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

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

public class Practice {
    static int[][] vals;
    static ArrayList<ArrayList<Integer>> adjList;
    static long[][] ans;
    public static void main(String[] args) throws IOException {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(bu.readLine());
        while (t-- > 0) {
            Integer n = Integer.parseInt(bu.readLine());
            vals = new int[2][n];
            adjList = new ArrayList<>();
            for(int i=0;i<n;i++){
                String st[]=bu.readLine().split("" "");
                vals[0][i] = Integer.parseInt(st[0]);
                vals[1][i] = Integer.parseInt(st[1]);
                adjList.add(new ArrayList<>());
            }
            for(int i=0;i<n-1;i++){
                String st[]=bu.readLine().split("" "");
                int source = Integer.parseInt(st[0]);; int dest = Integer.parseInt(st[1]);;
                adjList.get(source-1).add(dest-1);
                adjList.get(dest-1).add(source-1);
            }
            ans = new long[2][n];
            DFS(0, adjList, -1, ans, vals);
            System.out.println(Math.max(ans[0][0], ans[1][0]));
        }
    }

    private static void DFS(Integer current, ArrayList<ArrayList<Integer>> adjList, Integer prev, long[][] ans, int[][] vals) {
        ans[0][current] = 0L; ans[1][current] = 0L;
        for(Integer node: adjList.get(current)){
            if(node.equals(prev)) continue;
            DFS(node, adjList, current, ans, vals);
            ans[0][current] += Math.max(ans[0][node] + Math.abs(vals[0][current] - vals[0][node]), ans[1][node] + Math.abs(vals[0][current] - vals[1][node]));
            ans[1][current] += Math.max(ans[0][node] + Math.abs(vals[1][current] - vals[0][node]) , ans[1][node] + Math.abs(vals[1][current] - vals[1][node]));
        }
    }
}
","import java.util.*;
import java.io.*;
import java.lang.*;

public class CodeChef {
	static long dp[][];
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(br.readLine());
		while(t-->0)
		{
			int n=Integer.parseInt(br.readLine());
			int arr[][]=new int[n+1][2];
			for(int i=1;i<=n;i++)
			{
				String str[]=br.readLine().split("" "");
				int l=Integer.parseInt(str[0]);int r=Integer.parseInt(str[1]);
				arr[i][0]=l;arr[i][1]=r;
			}
			dp=new long[n+1][2];
			Set<Integer>adj[]=new HashSet[n+1];
			for(int i=0;i<=n;i++)adj[i]=new HashSet();
			for(int i=0;i<n-1;i++)
			{
				String str[]=br.readLine().split("" "");
				int src=Integer.parseInt(str[0]);  int dest=Integer.parseInt(str[1]);
				adj[src].add(dest);
				adj[dest].add(src);
			}
			fun(1,adj,arr);System.out.println(Math.max(dp[1][0], dp[1][1]));
		}
	}
	static void fun(int root,Set<Integer>[] adj,int arr[][])
	{
		dp[root][0]=dp[root][1]=0;
		Iterator<Integer>iter=adj[root].iterator();
		while(iter.hasNext())
		{
			int i=iter.next();
			adj[i].remove(root);
			fun(i,adj,arr);
			dp[root][0]+=Math.max(Math.abs(arr[root][0]-arr[i][0])+dp[i][0], Math.abs(arr[root][0]-arr[i][1])+dp[i][1]);
			dp[root][1]+=Math.max(Math.abs(arr[root][1]-arr[i][0])+dp[i][0], Math.abs(arr[root][1]-arr[i][1])+dp[i][1]);
		}
		
	}
}
",1,Plagiarised
1097b326,f1f600d9,"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.Math;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.management.Query;
import java.io.*;
import java.math.BigInteger;

public class Main {
    static int mod = 1000000007;

    /* ======================DSU===================== */
    

    /* ======================================================== */
    

    

    static FastReader f = new FastReader();
    static BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));

    

    

    

    

    

    

    

    

    

    

    /*
     * ===========Modular Operations==================
     */
    

    

    

    

    /*
     * ===============================================
     */
    

    

    

    /*
     * ===========Dynamic prog Recur Section===========
     */

    static int DP[][];
    static ArrayList<ArrayList<Integer>> g;
    static int count = 0;

    

    /*
     * ====================================Main=================================
     */
    public static void main(String args[]) throws Exception {
        // File file = new File(""D:\\VS Code\\Java\\Output.txt"");
        // FileWriter fw = new FileWriter(""D:\\VS Code\\Java\\Output.txt"");
        Random rand = new Random();
        int t = 1;
        t = f.nextInt();
        int tc = 1;
        while (t-- != 0) {
            int n = f.nextInt();
            int c[] = new int[n];
            long minOdd = 0, minEven = 0;
            long sumEven = 0, sumOdd = 0;
            for (int i = 0; i < n ; i++) {
                c[i] = f.nextInt();
                // if (i % 2 == 0) {
                //     minEven = (c[minEven] > c[i]) ? i : minEven;
                //     sumEven += c[i];
                // } else {
                //     minOdd = (minOdd > c[i]) ? i : minOdd;
                //     sumOdd += c[i];
                // }
            }
            minEven = c[0];
            minOdd = c[1];
            sumEven=c[0];
            sumOdd=c[1];
            long min=minEven*n + minOdd*n;//for k=2
            int even=1,odd=1;
            for (int k = 3; k <= n; k++) {
                if(k%2==1){
                    sumEven+=c[k-1];
                    minEven=Math.min(minEven, c[k-1]);
                    even++;
                }else{
                    sumOdd+=c[k-1];
                    minOdd=Math.min(minOdd, c[k-1]);
                    odd++;
                }
                min=Math.min(min, sumEven-minEven+minEven*(n-even+1) + sumOdd-minOdd+minOdd*(n-odd+1));
            }
            w.write(min+""\n"");

        }
        w.flush();
    }
}
",0,Non-plagiarised
085ddefc,1500a4fa,"import java.io.*;
import java.util.*;

public class a {

    public static void main(String[] args){

        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-- > 0){

            int n = sc.nextInt();
            String a = sc.next();
            String b = sc.next();

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

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

            }

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

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

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

                // both ways possible

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

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

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

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

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

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

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

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

            }

        }

    }

}


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

public class GFG {
	public static void main (String[] args) {
	Scanner sc=new Scanner(System.in);
	int t=sc.nextInt();
	while(t-->0){
	    int n=sc.nextInt();
	    String a=sc.next();
	    String b=sc.next();
	   int i;
	   int zero=0,one=0;
	     int x=0,y=0,x1=0,y1=0;
	    for(i=0;i<n;i++){
	        if(a.charAt(i)=='0')
	        zero++;
	        else
	        one++;
	    }
	    if(one==0){
	        if(a.equals(b))
	        System.out.println(""0"");
	        else
	        System.out.println(""-1"");
	    }
	    else{
	        int same=0,diff=0;
	        for(i=0;i<n;i++){
	            if(a.charAt(i)==b.charAt(i)){
	                same++;
	                x++;
	                if(a.charAt(i)=='1'){
	                    x1++;
	                    
	                }
	            }
	            else{
	                diff++;
	                y++;
	                if(a.charAt(i)=='1'){
	                    y1++;
	                    
	                }
	            }
	            
	        }
	        int ans=Integer.MAX_VALUE;
    if(x%2!=0&&(x+1)/2==x1){
        ans=x;
        
    }
    if(y%2==0&&(y/2)==y1){
ans=Math.min(ans,y);
    }
    if(ans==Integer.MAX_VALUE){
        
        System.out.println(""-1"");
        
    }else{
        
        System.out.println(ans);
    }
	       
	    }
	    
	}
	    
	}
    
}
",0,Non-plagiarised
11373c16,7011024d,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{ 
	public static void main (String[] args) throws java.lang.Exception
	{
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int n = scan.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            int x = scan.nextInt();
            if(x==1)
            a.add(i);
            else
            b.add(i);  
        }
        int x = a.size();
        if(x==0){
            pw.println(0);
            pw.flush();
            return;
        }
        int y = b.size();
        int dp[][] = new int[x][y];
        int min = Integer.MAX_VALUE;
        for(int i=0;i<y;i++){
            min = Math.min(Math.abs(a.get(0) - b.get(i)),min);
            dp[0][i] = min;
        }
        for(int i=1;i<x;i++){
            min = Integer.MAX_VALUE;
            for(int j=i;j<y;j++){
                min = Math.min(Math.abs(a.get(i)-b.get(j))+dp[i-1][j-1],min);
                dp[i][j] = min;
            }
        }
        pw.println(dp[x-1][y-1]);
        pw.flush();
	}
   
}
","import java.util.*;

public class D {

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

        Solution Solution = new Solution(occupied, vacant);

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

class Solution {

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

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

    

    

    int memoization() {
        int[][] dp = new int[x][y];
        for (int i = 0; i < x; i++) {
            Arrays.fill(dp[i], -1);
        }
        return memoization(dp, x-1, y-1);
    }

    int memoization(int[][] dp, int n, int m) {
        if(n < 0) {
            return 0;
        }
        if(m < n) {
            return Integer.MAX_VALUE;
        }
        if(dp[n][m] != -1) {
            return dp[n][m];
        }
        int first = memoization(dp, n, m-1);
        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
        dp[n][m] = Math.min(first, second);
        return dp[n][m];
    }
}
",0,Non-plagiarised
41e69083,54eb1a6b,"import java.util.*;
public class Solution {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
          Scanner io =new Scanner (System.in);
          int t = io.nextInt();
  		for (int iii=0; iii<t; iii++) {
  			int n = io.nextInt();
  			long k = io.nextLong();
   
  			Long[] arr = new Long[n];
  			for (int i=0; i<n; i++) {
  				arr[i] = io.nextLong();
  			}
   
  			Arrays.sort(arr);
  			long[] psum = new long[n];
  			psum[0] = arr[0];
  			for (int i=1; i<n; i++) {
  				psum[i] = psum[i-1] + arr[i];
  			}
   
  			if (psum[n-1] <= k) {
  				System.out.println(0);
  				continue;
  			}
  			//System.out.println(psum[n-1]);
   
  			long ans = Long.MAX_VALUE;
  			
  			for (int i=0; i<n; i++) {
  				long sum = psum[i] + (n-i-1)*arr[0];
  				if (sum <= k) {
  					ans = Math.min(ans, n-1-i);
  					continue;
  				}
  				long ops = (long) Math.ceil((double) (sum - k)/(double) (n-i));
   
  				ans = Math.min(ans, n-1-i + ops);
  				//System.out.println(sum);
  			}
  			System.out.println(ans);
  			
  		}

        	  }
        	   
	
	


}
","import java.util.*;
public class Solution {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
          Scanner io =new Scanner (System.in);
          int t = io.nextInt();
  		for (int iii=0; iii<t; iii++) {
  			int n = io.nextInt();
  			long k = io.nextLong();
   
  			Long[] arr = new Long[n];
  			for (int i=0; i<n; i++) {
  				arr[i] = io.nextLong();
  			}
   
  			Arrays.sort(arr);
  			long[] psum = new long[n];
  			psum[0] = arr[0];
  			for (int i=1; i<n; i++) {
  				psum[i] = psum[i-1] + arr[i];
  			}
   
  			if (psum[n-1] <= k) {
  				System.out.println(0);
  				continue;
  			}
  			//System.out.println(psum[n-1]);
   
  			long ans = Long.MAX_VALUE;
  			
  			for (int i=0; i<n; i++) {
  				long sum = psum[i] + (n-i-1)*arr[0];
  				if (sum <= k) {
  					ans = Math.min(ans, n-1-i);
  					continue;
  				}
  				long ops = (long) Math.ceil((double) (sum - k)/(double) (n-i));
   
  				ans = Math.min(ans, n-1-i + ops);
  				//System.out.println(sum);
  			}
  			System.out.println(ans);
  			
  		}
 
        	  }
        	   
	
	
 
 
}
",1,Plagiarised
00af3420,f4d6d28d,"import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }

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

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

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

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

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

            String[] words = new String[n];
            int i=0;
            while(n-- >0){
                words[i] = br.readLine();
                i++;
            }

            answer.add(new Solver().solve(words));
        }

        for (int ans : answer ) System.out.println(ans);

    }

    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
    
    
    
    

    
    

    
    

}


class Solver{
    public int solve(String[] words) throws IOException{

        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};

        int[][] arr = new int[5][words.length];

        int i=0;
        for(String s : words) {
            char[] wordArr = s.toCharArray();
            int j=0;
            for (char alpha : alphabets) {
                int counter = 0;
                for(char letter : wordArr){
                    if(alpha == letter)
                        counter++;
                }
                arr[j][i] = 2*counter - s.length();
                j++;
            }
            i++;
        }

        int[] ans = new int[5];

        int m=0;
        for (int[] ar : arr) {
            Arrays.sort(ar);
            int val=0;
            int counter=0;
            for(i=ar.length-1; i>=0; i--){
                val += ar[i];
                if(val>0) counter++;
                else break;
            }
            ans[m] = counter;
            m++;
        }

        return Arrays.stream(ans).max().getAsInt();
    }
}
",0,Non-plagiarised
0951d079,0ecf356d,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;

public class D {

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

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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] h = new int[n];
        int[] dp = new int[n];
        for(int i = 0; i<n; i++){
            h[i] = Integer.parseInt(st.nextToken());
        }
        Stack<Integer> hi = new Stack<>();
        Stack<Integer> lo = new Stack<>();
        hi.push(0);
        lo.push(0);
        for(int i = 1; i<n; i++){
            dp[i] = dp[i-1]+1;
            while(!hi.isEmpty() && h[hi.peek()]<h[i]){
                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
                hi.pop();
            }
            if(!hi.isEmpty()){
                dp[i] = Math.min(dp[i], dp[hi.peek()]+1);
                if(h[i] == h[hi.peek()]) hi.pop();
            }
            while(!lo.isEmpty() && h[lo.peek()]>h[i]){
                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
                lo.pop();
            }
            if(!lo.isEmpty()){
                dp[i] = Math.min(dp[i], dp[lo.peek()]+1);
                if(h[i] == h[lo.peek()]) lo.pop();
            }
            hi.push(i);
            lo.push(i);
        }
        System.out.println(dp[n-1]);
    }
}
",1,Plagiarised
1be078c4,f339ef6f,"import java.util.*;
import java.io.*;

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

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;
 
public class Main {
	static FastReader fr;
	static int arrForIndexSort[];
	
	
	
	
	
	
	public static void main(String[] args) {
		fr = new FastReader();
		int T = 1;
		T = fr.nextInt();
		int t1 = T;
		while (T-- > 0) {
			solve();
		}
	}
	public static void solve() {
		int n=fr.nextInt();
		int k=fr.nextInt();
		int[] a = new int[k];
		int[] map = new int[n];
		int[] temp = new int[n];
		Arrays.fill(temp, Integer.MAX_VALUE);
		Arrays.fill(map, Integer.MAX_VALUE);
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		for(int i=0;i<k;i++) {
			a[i] = fr.nextInt()-1;
			min = Math.min(a[i], min);
			max = Math.max(a[i], max);
		}
		for(int i=0;i<k;i++) {
			map[a[i]] = fr.nextInt();
		}
		int diff = 0;
		int curr = map[min];
		for(int i=min;i<n;i++) {
			int airConditioner = map[i];
			if(airConditioner<curr+diff) {
				temp[i] = airConditioner;
				diff = 1;
				curr = airConditioner;
			}
			else {
				temp[i] = curr+diff;
				diff++;
			}
			
		}
		diff = 0;
		curr = map[max];
		for(int i=max;i>=0;i--) {
			int airConditioner = map[i];
			if(airConditioner<curr+diff) {
				temp[i] = Math.min(temp[i], airConditioner);
				diff = 1;
				curr = airConditioner;
			}
			else {
				temp[i] =  Math.min(temp[i], curr+diff);
				diff++;
			}
			
		}
		System.out.println(Arrays.toString(temp).replaceAll("",|\\[|\\]"",""""));
		
	}

}
",0,Non-plagiarised
1386da0e,f87eb1b3,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;


public class Solution {

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

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


	

	static class Solver {

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

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

					if(segment>1){

						{

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

				System.out.println(ans);
			}
		}


	} 

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

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.PrintStream;
import java.io.PrintWriter;
public class A {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	

	
	
	
	
	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
		
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		
		
		
		
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   /*
		    * 
		    * >=         <=
		   0 1 2 3 4 5 6 7  
		   5 5 5 6 6 6 7 7
		   lower_bound for 6 at index 3 (>=)
		   upper_bound for 6 at index 6(To get six reduce by one) (<=)
		   */
		
		   
		
		   
					
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out);
		
		int t = sc.nextInt();
		while(t-- > 0)
		{
			long INF = 1000000000000000007L;
			int n = sc.nextInt();
			
			long[] c = new long[n+1];
			for(int i = 1;i<=n;i++) c[i] = sc.nextLong();
			
			long ans = INF;
			long mo = INF,  so = 0, co = 0;
			long me = INF,  se = 0, ce = 0;
			
			for(int i=1;i<=n;i++)
			{
				if(i%2 == 1)
				{
					mo = min(mo,c[i]);
					so += c[i];
					co++;
				}
				else
				{
					me = min(me,c[i]);
					se += c[i];
					ce++;
				}
				if(i>=2)
				{
					long x = so + (n - co) * mo + se + (n - ce) * me;
					ans=min(ans,x);
				}
			}
			fout.println(ans);
		}
			
		fout.close();
	}
}
",0,Non-plagiarised
3b498a39,e6b7a899,"import java.util.*;


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

public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];
	 static int max;
	  public static void main(String[] args)
{
		   PrintWriter out=new PrintWriter(System.out);
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		   //ttt =i();
		 
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int A[]=input(n);
	        	dp=new long[n+1][n+1];
	        	for(int i=0;i<=n;i++) {
	        		Arrays.fill(dp[i],-1);
	        	}
		        	
	        	
	        	ArrayList<Integer> l=new ArrayList<Integer>();
	        	ArrayList<Integer> m=new ArrayList<Integer>();
	        	for(int i=0;i<n;i++) {
	        		if(A[i]==0) {
	        			l.add(i+1);
	        		}
	        		else {
	        			m.add(i+1);
	        		}
	        	}
	        	A=new int[m.size()];
	        	int B[]=new int[l.size()];
	        	for(int i=0;i<l.size();i++) {
	        		B[i]=l.get(i);
	        	}
	        	for(int i=0;i<m.size();i++) {
	        		A[i]=m.get(i);
	        	}
	        	n=m.size();
	        	int o=l.size();
		        	System.out.println(go(A,B,0,0,n,o));
	        	
			}

	     //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	//CHECK FOR N=1
       	//CHECK FOR N=1
		        
		     
    }
	  
	 
	  
	  
	
	 
	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
		if(i==n)
			return 0;
		if(j==m)
			return Integer.MAX_VALUE;
		if(dp[i][j]!=-1)
			return dp[i][j];
		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
		long op2=go(A, B, i, j+1, n, m);
		return dp[i][j]=Math.min(op1, op2);
	
		
		
		
		
		}








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

















     static int i() {
    	 return sc.nextInt();
     }
     
     static long l() {
    	 return sc.nextLong();
     }  
     
     
  
  
  
      
      
      
      
     
        
     
}
","import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

public class Main {
	static final long MOD=1000000007;
	static final long MOD1=998244353;
	static long ans=0;
	//static ArrayList<Integer> ans=new ArrayList<>();
	public static void main(String[] args){
		PrintWriter out = new PrintWriter(System.out);
		InputReader sc=new InputReader(System.in);
		int N = sc.nextInt();
		int[] A = sc.nextIntArray(N);
		ArrayList<Integer> a1 = new ArrayList<Integer>();
		ArrayList<Integer> a2 = new ArrayList<Integer>();
		for (int i = 0; i < A.length; i++) {
			if (A[i]==0) {
				a1.add(i);
			}else {
				a2.add(i);
			}
		}
		int[][] dp = new int[a1.size()+1][a2.size()+1];
		for (int i = 0; i < dp.length; i++) {
			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
		}
		dp[0][0] = 0;
		for (int i = 1; i <= a1.size() ; i++) {
			int pos1 = a1.get(i-1);
			for (int j = 0; j <= a2.size(); j++) {
				dp[i][j] = dp[i-1][j];
				if (j-1>=0) {
					int pos2 = a2.get(j-1);
					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
				}
			}
		}
		System.out.println(dp[a1.size()][a2.size()]);
	}
	
}
",0,Non-plagiarised
1a6f8b20,f6ed6826,"import java.io.*;
import java.util.*;
public class Main
{
	public static void main(String[] args)throws Exception
	{
	    Main ob=new Main();
	    ob.fun();
	}
	public void fun()throws Exception
	{
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter pw=new PrintWriter(System.out);
	    int t=Integer.parseInt(br.readLine());
	    while(t-->0)
	    {
	        int n=Integer.parseInt(br.readLine());
	        int ar[][]=new int [n][5];
	        int len[]=new int[n];
	        for(int i=0;i<n;i++)
	        {
	            String s=(br.readLine());
	            for(int j=0;j<s.length();j++)
	            {
	                ar[i][s.charAt(j)-'a']++;
	                len[i]=s.length();
	            }
	        }
	        int max=0;
	        for(int i=0;i<5;i++)
	        {
	            int num=fun2(ar,len,i);
	            max=Math.max(num,max);
	        }
	        pw.println(max);
	        
	    }
	    pw.flush();
	}
	public int fun2(int ar[][],int len[],int col)
	{
	    int ct=0;
	    int n=ar.length;
	    PriorityQueue<Integer> pq=new PriorityQueue<Integer>(Collections.reverseOrder());
	    for(int i=0;i<n;i++)
	    {
	        int dif=2*ar[i][col]-len[i];
	        pq.add(dif);
	    }
	    int sum=0;
	    while(pq.size()>0)
	    {
	        int num=(int)(pq.poll());
	        if((sum+num)>0)
	        {
	            ct++;
	            sum+=num;
	        }
	    }
	    return ct;
	}
}
","import java.util.*;


import java.io.*;
 public class Solution {
		static FastScanner scr=new FastScanner();
//		static Scanner scr=new Scanner(System.in);
		static PrintStream out=new PrintStream(System.out);
		static StringBuilder sb=new StringBuilder();
		
		
		
		
		
		
		
		
		static HashMap<Character,ArrayList<Integer>>hm=new HashMap<>();
		static void solve() {
			int n=scr.nextInt();
			
			int count[]=new int[5];
			int store[][]=new int[n][5];
			int max=MIN;
			int length[]=new int[n];
			for(int i=0;i<n;i++) {
				String s=scr.next();
				length[i]=s.length();
				for(int j=0;j<s.length();j++) {
					store[i][s.charAt(j)-'a']++;
					count[s.charAt(j)-'a']++;
				}
			}
			
			for(int j=0;j<5;j++) {
				
				ArrayList<Integer>a=new ArrayList<>();
				for(int i=0;i<n;i++) {
					a.add((store[i][j]*2)-length[i]);
				}
				
				Collections.sort(a,Collections.reverseOrder());
				
				long sum=0;
				int ans=0;
				for(int i=0;i<a.size();i++) {
					sum+=a.get(i);
					if(sum>0) {
						ans++;
					}else {
						break;
					}
				}
				max=Math.max(max, ans);
			}
			out.println(max);
			
		}
		static int  MAX = Integer.MAX_VALUE;
		static int  MIN = Integer.MIN_VALUE;
		public static void main(String []args) {
			int t=scr.nextInt();
			while(t-->0) {
				solve();
			}
//			solve();
//			out.println(sb);
		}
	}
",0,Non-plagiarised
55ab9b5d,ae4d5b49,"import java.io.*;
import java.util.*;

public class Main {

    static int solve(char ch, char[][] str, int N) {
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            int c1 = 0, c2 = 0;
            for (char x : str[i]) {
                if (x == ch) c1++;
                else c2++;
            }
            a[i] = c1 - c2;
        }

        int sum = 0, count = N;
        for (int x : a) sum += x;

        Arrays.sort(a);
        for (int i = 0; i < N; i++) {
            if (sum > 0) break;
            count--;
            sum -= a[i];
        }
        return count;
    }

    public static void main(String[] args) throws IOException {
        // System.out.println(""===== input ====="");
        // BufferedReader br = new BufferedReader(new FileReader(""input/input1.txt""));
        // BufferedReader br2 = new BufferedReader(new FileReader(""input/input1.txt""));
        // String s;
        // while ((s = br2.readLine()) != null) {
        //     System.out.println(s);
        // }
        // System.out.println(""===== output ====="");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder out = new StringBuilder();
        int T = Integer.parseInt(st.nextToken());
        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine().trim());
            char[][] str = new char[n][];
            for (int i = 0; i < n; i++) {
                str[i] = br.readLine().trim().toCharArray();
            }

            int ans = 0;
            for (char ch = 'a'; ch <= 'e'; ch++) {
                ans = Math.max(ans, solve(ch, str, n));
            }
            out.append(ans).append(""\n"");
        }
        System.out.println(out);
    }
}
","import java.io.*;
import java.util.*;

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

/**
 *
 * @Har_Har_Mahadev
 */

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

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

	public static void process() throws IOException {

		int n = sc.nextInt();
		int arr[] = sc.readArray(n);
		lis1 = new ArrayList<Integer>();
		lis0 = new ArrayList<Integer>();
		for(int i = 0; i<n; i++) {
			if(arr[i] == 1)lis1.add(i+1);
			else lis0.add(i+1);
		}
		Collections.sort(lis0);
		Collections.sort(lis1);
		int n0 = lis0.size();
		int n1 = lis1.size();
		dp = new long[n0+1][n1+1];
		for(int i = 0; i<=n0; i++) {
			Arrays.fill(dp[i], -1);
		}
		long ans = solve(0,0,n0,n1);
		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.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
23594fdf,b185d034,"import java.io.*;
import java.util.*;

public class Main {

  public static class StringPair implements Comparable{
    String s;
    Integer charCount;
    public StringPair(String s, Integer charCount){
      this.s = s;
      this.charCount = charCount;
    }

    
  }


  public static void main(String[] args) throws IOException {
    Scanner sc = new Scanner(System.in);
    int t = sc.nextInt();
    while (t-- > 0) {

      int n = sc.nextInt();

      String[] s = new String[n];

      for(int i = 0 ; i < n ; i++){
        s[i] = sc.next();
      }

      Integer[][] count = new Integer[n][5];
      Integer[] totalCount = new Integer[5];

      for(int i = 0 ; i < n ; i++){
        for(int j = 0 ; j < 5 ; j++){
          count[i][j]=0;
        }
      }
      for(int i = 0 ; i < 5 ; i++){
        totalCount[i] = 0;
      }


      Integer total = 0;

      for(int i = 0 ; i < n ; i++){
        for(int j = 0 ; j < s[i].length() ; j++){
          int val = s[i].charAt(j) - 'a';
          count[i][val]++;
          totalCount[val]++;
          total++;
        }
      }

      //2*count[]char > len of total


      int ans = -1;
      for(int ch = 0 ; ch < 5 ; ch++){
        List<StringPair> ls = new ArrayList<>();
        for(int i = 0 ; i < n ; i++){
          int c = s[i].length() - (2 * count[i][ch]);
          ls.add(new StringPair(s[i],c));
        }
        Collections.sort(ls);

        int finalCount = n;

        int thisTotal = total;

        int thisTotalCharcount = totalCount[ch];

        int idx = n-1;

        while(finalCount > ans && 2*thisTotalCharcount <= thisTotal && idx >= 0){//condition true){
          thisTotal -= ls.get(idx).s.length();

          thisTotalCharcount -= (ls.get(idx).s.length() - ls.get(idx).charCount)/2;
          idx--;
          finalCount--;
        }
        ans = Integer.max(ans,finalCount);
      }

      System.out.println(ans);
    }
  }
}
","import java.io.*;
import java.util.*;
public class A734C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        loop:while(t-->0){
            int n = scan.nextInt();
            String[] arr= new String[n];
            Integer[][] counts = new Integer[5][n];
            for(int i = 0;i<5;i++){
                for(int j = 0;j<n;j++){
                    counts[i][j] = 0;
                }
            }
            for(int i =0;i<n;i++){
                arr[i] = scan.next();
                int[] freq =new int[5];
                for(int j = 0;j<arr[i].length();j++){
                    freq[arr[i].charAt(j)-'a']++;
                }
                for(int j = 0;j<5;j++){
                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
                }
            }
            int best = 0;
            for(int i = 0;i<5;i++){
                Arrays.sort(counts[i]);
                int curr = 0;
                int extra = 0;
                for(int j = n-1;j>=0;j--){
                    extra+=counts[i][j];
                    if(extra>0)curr++;
                }
                best = Math.max(best,curr);
            }
            System.out.println(best);

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

public class Main{
    static final Random random=new Random();
    static long mod=1000000007L;
    static HashMap<String,Integer>map=new HashMap<>();

    
    
    public static void main(String[] args) {
        try {
            FastReader in=new FastReader();
            FastWriter out = new FastWriter();
            int testCases=in.nextInt();
            //out.println(""hee"");
            //int testCases=1;
            while(testCases-- > 0){
                solve(in);
            }
            out.close();
        } catch (Exception e) {
            return;
        }
    }
    public static void solve( FastReader in){
        int n=in.nextInt();
                List<List<Pair>> graph=new ArrayList<>();
                for(int i=0;i<n;i++){
                    graph.add(new ArrayList<>());
                }
                //out.println(""hee"");
                for(int i=0;i<n-1;i++){
                    int u=in.nextInt();
                    int v=in.nextInt();
                    u--;v--;
                    graph.get(u).add(new Pair(v,i));
                    graph.get(v).add(new Pair(u,i));
                }
                int start=0;
                for(int i=0;i<n;i++){
                    if(graph.get(i).size()>2){
                        System.out.println(""""+-1);
                        return;
                    }
                    else if(graph.get(i).size()==1){
                        start=i;
                    }
                }
                int[] ans=new int[n-1];
                int[] vis=new int[n+1];
                vis[start]=1;
                int w=2;
                Queue<Integer> q=new LinkedList<>();
                q.add(start);
                while(!q.isEmpty()){
                    int x=q.poll();
                    for(Pair p:graph.get(x)){
                        if(vis[p.node]==0){
                            vis[p.node]=1;
                            q.add(p.node);
                            int idx=p.eg_indx;
                            ans[idx]=w;
                            if(w==2)w=5;
                            else w=2;    
                        }
                    }
                }
                for(int i:ans){
                    System.out.print(i+"" "");
                }
                System.out.println("""");
    }
    static class Pair{
        int node;
        int eg_indx;
        Pair(int node,int eg_indx){
            this.node=node;
            this.eg_indx=eg_indx;
        }
    }
    
}
",0,Non-plagiarised
d8a171a3,f229aa7f,"import java.io.*;
import java.util.*;

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

}
","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
54d7c21e,80881cae,"import java.io.*;
import java.util.*;


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

	    // function to find last index <= y
    
     
	
	
	
          
	
	
	
	
	 
	// 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
	
	
	
	
	
	 static ArrayList<Integer> ans;
	
	
	
	
	
	
	
	
	
		
	


	

	//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 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;			
//		}
	}
}
",1,Plagiarised
45e38fad,ec8566b8,"import java.util.*;
import java.io.*;



public class C_Not_Assigning {
    // For fast input output
    

    static class Edge{
        public int node;
        public int next;
        Edge(int node, int next){
            this.node = node;
            this.next = next;
        }    
    }
    public static void dfs(int u, ArrayList<ArrayList<Edge>> g,int[] vis, int flag, int[] weight){
        vis[u] = 1;
        for(Edge e : g.get(u)){
            if(vis[e.node] == 0){
                if(flag == 0)
                {
                    weight[e.next] = 2;
                    dfs(e.node, g, vis, 1, weight);
                }
                else
                {
                    weight[e.next] = 5;
                    dfs(e.node, g, vis, 0, weight);
                }
            }
        }
    }
    // end of fast i/o code
    public static void main(String[] args) {
        FastReader reader = new FastReader();
        int t = reader.nextInt();
        while(t-->0){
            int n = reader.nextInt();
            int[] order = new int[n+1];
            int flag = 0; 
            //ArrayList<ArrayList<Integer>> adj = new ArrayList<>(n+1);
            //Map<Integer, List<Integer>> adj = new HashMap<>();
            ArrayList<ArrayList<Edge>> graph= new ArrayList<>();
            for(int i=0;i<n+1;i++){
                graph.add(new ArrayList<>());
            }
            for(int i=0;i<n-1;i++){
                int u = reader.nextInt();
                int v = reader.nextInt();
                order[u]++;
                order[v]++;
                graph.get(u).add(new Edge(v, i));
                graph.get(v).add(new Edge(u, i));

                if(order[u]==3 || order[v]==3){
                    flag = 1;
                }
            }
            if(flag == 1)
                System.out.println(-1);
            else{
                for(int i=1;i<=n;i++){
                    if(order[i] == 1){
                        int[] vis = new int[n+1];
                        int[] weight = new int[n];
                        dfs(i, graph, vis, 0, weight);
                        for(int j =0;j<n-1;j++){
                            System.out.print(weight[j] + "" "");
                        }
                        break;
                    }
                }
                System.out.println();
            }
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

public class A {
    private static void sport(List<Integer>[] g, Map<W, Integer> map) {
        int n = g.length;
        for (int i = 0; i < n; i++) {
            if (g[i].size() > 2) {
                System.out.println(-1);
                return;
            }
        }
        int[] ans = new int[n - 1];
        //dfs(new C(-1, 0), g, ans, 3, new HashSet<>());
        Queue<int[]> queue = new LinkedList<>();
        Set<Integer> seen = new HashSet<>();
        int val = 3;
        for (Integer integer : g[0]) {
            Integer idx = map.get(new W(0, integer));
            ans[idx] = val;
            queue.add(new int[]{val, integer});
            seen.add(integer);
            val = val == 2 ? 3 : 2;
        }
        seen.add(0);
        while (!queue.isEmpty()) {
            int[] poll = queue.poll();
            for (Integer u : g[poll[1]]) {
                if (!seen.contains(u)) {
                    seen.add(u);
                    int curr = poll[0] == 2 ? 3 : 2;
                    Integer integer = map.get(new W(poll[1], u));
                    ans[integer] = curr;
                    queue.add(new int[]{curr, u});
                }
            }
        }
        for (int an : ans) {
            System.out.print(an + "" "");
        }
        System.out.println();
    }

    static class W {
        int u;
        int v;

        public W(int u, int v) {
            this.u = u;
            this.v = v;
        }

        

        
    }

    

    

    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
a368f345,e5d02e93,"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.util.*;
import java.io.*;

public class C_1551 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int t = sc.nextInt();
		while(t-->0) {
			int n = sc.nextInt();
			int[] a = new int[n];
			int[] b = new int[n];
			int[] c = new int[n];
			int[] d = new int[n];
			int[] e = new int[n];
			for(int i = 0; i < n; i++) {
				String s = sc.next();
				int[] cnt = new int[5];
				for(int j = 0; j < s.length(); j++)
					cnt[s.charAt(j) - 'a']++;
				a[i] = 2 * cnt[0] - s.length();
				b[i] = 2 * cnt[1] - s.length();
				c[i] = 2 * cnt[2] - s.length();
				d[i] = 2 * cnt[3] - s.length();
				e[i] = 2 * cnt[4] - s.length();
			}
			
			Arrays.sort(a);
			Arrays.sort(b);
			Arrays.sort(c);
			Arrays.sort(d);
			Arrays.sort(e);
			
			int max = 0;
			int sum = 0;
			for(int i = n - 1; i >= 0; i--) {
				sum += a[i];
				if(sum <= 0)
					break;
				max = n - i;
			}
			
			sum = 0;
			for(int i = n - 1; i >= 0; i--) {
				sum += b[i];
				if(sum <= 0)
					break;
				max = Math.max(max, n - i);	
			}
			
			sum = 0;
			for(int i = n - 1; i >= 0; i--) {
				sum += c[i];
				if(sum <= 0)
					break;
				max = Math.max(max, n - i);	
			}
			
			sum = 0;
			for(int i = n - 1; i >= 0; i--) {
				sum += d[i];
				if(sum <= 0)
					break;
				max = Math.max(max, n - i);	
			}
			
			sum = 0;
			for(int i = n - 1; i >= 0; i--) {
				sum += e[i];
				if(sum <= 0)
					break;
				max = Math.max(max, n - i);	
			}
			
			pw.println(max);
			
		}
		
		pw.flush();
	}

	
}
",0,Non-plagiarised
5766f176,e7a997b5,"import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;

public class Main {

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

class Solve {

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








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

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

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

public class c {

    public static void main(String[] args){

        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-- > 0){

            int n = sc.nextInt();


            ArrayList<ArrayList<Edge>> graph = new ArrayList<>();
            for(int i=0; i<n; i++){
                graph.add(new ArrayList<Edge>());
            }

            for(int i=0; i<n-1; i++){
                int u = sc.nextInt();
                int v = sc.nextInt();

                Edge e = new Edge(u-1, v-1, i+1);
                Edge e2 = new Edge(v-1, u-1, i+1);

                graph.get(u-1). add(e);
                graph.get(v-1).add(e2);

            }

            int edges[] = new int[n];

            int indegree1count = 0;
            int indegree2count = 0;
            for(ArrayList<Edge> list : graph){
                if(list.size() == 1){
                    indegree1count++;
                }
                else if(list.size() == 2){
                    indegree2count++;
                }
            }

            if(indegree1count == 2 && indegree1count+indegree2count==n){

                for(int i=0; i<graph.size(); i++){
                    ArrayList<Edge> list = graph.get(i);
                    if(list.size() == 1){
                        dfs(graph, edges, false, -1, i) ;
                    }
                }

                for(int i=1; i<edges.length; i++){
                    System.out.print(edges[i] + "" "");
                }
                System.out.println();

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


        }

    }

    public static void dfs(ArrayList<ArrayList<Edge>> graph, int[] edges, boolean isprev2, int parent, int current){

        for(Edge e : graph.get(current)){

            if(e.v == parent){
                continue;
            }

            edges[e.id] = isprev2 ? 5 : 2;

            dfs(graph, edges, !isprev2, current, e.v);

        }

    }

}

class Edge {

    int u;
    int v;
    int id;

    public Edge(int u, int v, int id) {
        this.u = u;
        this.v = v;
        this.id = id;
    }

}


",0,Non-plagiarised
3f6f1267,cdb7a891,"import java.io.*;
import java.util.*;

public class T4  {

    public static void main(String[] args) {
        FastScanner s = new FastScanner();
        T4 main = new T4();
        int n = 1;
        while (n-- > 0) {
            main.MainPrint(s);
        }
    }

    long mod =  998244353L;

    private void MainPrint(FastScanner s) {
        int n = s.nextInt();
        k = s.nextInt();
        TreeMap<Integer, int[]> map = new TreeMap<>();
        int l, r;
        int[] get;
        for (int i = 0; i < n; i++) {
            l = s.nextInt();
            r = s.nextInt();
            if (!map.containsKey(l)) {
                get = new int[2];
                get[0]++;
                map.put(l, get);
            } else {
                get = map.get(l);
                get[0]++;
            }
            if (!map.containsKey(r + 1)) {
                get = new int[2];
                get[1]++;
                map.put(r + 1, get);
            } else {
                get = map.get(r + 1);
                get[1]++;
            }
        }
        int count = 0;
        long ans = 0;
        precomp();
        for (int i : map.keySet()) {
            get = map.get(i);
            count += get[0] - get[1];
            ans += rem[count] - rem[count-get[0]];
            ans %= mod;
        }
        if (ans<0) ans+=mod;
        System.out.println(ans%mod);
    }


    long mul(long a, long b) {
        return a*b%mod;
    }

    long exp(long base, long e) {
        if (e==0) return 1;
        long half=exp(base, e/2);
        if (e%2==0) return mul(half, half);
        return mul(half, mul(half, base));
    }

    long modInv(long x) {
        return exp(x, mod-2);
    }

    long[] facts;
    long[] factInvs;
    long[] rem;
    int k;

    void precomp() {
        facts=new long[300_001];
        factInvs=new long[300_001];
        rem = new long[300_001];
        factInvs[0]=facts[0]=1;

        for (int i=1; i<facts.length; i++)
            facts[i]=mul(facts[i-1], i);

        factInvs[facts.length-1]=modInv(facts[facts.length-1]);

        for (int i=facts.length-2; i>=0; i--)
            factInvs[i]=mul(factInvs[i+1], i+1);
        for (int i = k;i<rem.length;i++){
            rem[i] =mul(facts[i], mul(factInvs[k], factInvs[i-k]));
        }
    }

    

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

import java.lang.*;

public class Practice {
	public static long mod = 998244353;
	public static long mod2 = 998244353;
	public static long tt = 0;
	public static int[] ttt = new int[2];
	public static long[] fac = new long[500000];
	public static ArrayList<Integer> prime;

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

		// int t = Integer.parseInt(br.readLine());
		// while (t-- > 0) {
		fac();
		String[] s1 = br.readLine().split("" "");
		int n = Integer.parseInt(s1[0]);
		int k = Integer.parseInt(s1[1]);
		Long[][] arr = new Long[n][2];
		Long[] st = new Long[n];
		Long[] end = new Long[n];
		for (int i = 0; i < n; i++) {
			String str = (br.readLine());
			String[] s2 = str.split("" "");
			arr[i][0] = Long.parseLong(s2[0]);
			st[i] = arr[i][0];
			arr[i][1] = Long.parseLong(s2[1]);
			end[i] = arr[i][1];
		}
		Arrays.sort(st);
		Arrays.sort(end);
		long pp = (power(fac[k], mod - 2));
		long[] comb = new long[n + 1];
		for (int i = 1; i <= n; i++) {
			if (i < k) {
				continue;
			}
			// System.out.println(i + "" "" + fac[i] + "" "" + power(fac[k], mod - 2) + "" "" +
			// fac[k]);
			comb[i] = (fac[i] * pp) % mod;
			comb[i] = (comb[i] * (power(fac[i - k], mod - 2))) % mod;
		}
//		for (int i = 0; i <= n; i++) {
//			System.out.print(comb[i] + "" "");
//		}
		HashMap<Long, Integer> map1 = new HashMap<Long, Integer>();
		HashMap<Long, Integer> map = new HashMap<>();
		for (int i = 0; i < n; i++) {
			if (map.containsKey(arr[i][0])) {
				map.put(arr[i][0], map.getOrDefault(arr[i][0], 0) + 1);
				continue;
			}
			int a = getLower(arr[i][0] - 1, st);
			int b = getLower(arr[i][0] - 1, end);
			map.put(arr[i][0], map.getOrDefault(arr[i][0], 0) + 1);
			map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0));
			if (a != -1 || b != -1) {
				if (b == -1) {
					int curr = a + 1;
					map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0) + curr);
					continue;
				}
				// System.out.println(arr[i][0] + "" "" + b + "" "" + a);
				int curr = a - b;
				map1.put(arr[i][0], map1.getOrDefault(arr[i][0], 0) + curr);
			}
		}
		long ans = 0;
		for (long a : map.keySet()) {
			ans = (ans + comb[map.get(a) + map1.get(a)] + mod - comb[map1.get(a)]) % mod;
		}
		// System.out.println(map + "" "" + map1);
		pw.println(ans);
		// }
		pw.close();

	}

	private static long power(long a, long p) {
		// TODO Auto-generated method stub
		long res = 1;
		while (p > 0) {
			if (p % 2 == 1) {
				res = (res * a) % mod;
			}
			p = p / 2;
			a = (a * a) % mod;
		}
		return res;
	}

	private static void fac() {
		fac[0] = 1;
		// TODO Auto-generated method stub
		for (int i = 1; i < fac.length; i++) {
			if (i == 1) {
				fac[i] = 1;
			} else {
				fac[i] = i * fac[i - 1];
			}
			if (fac[i] > mod) {
				fac[i] = fac[i] % mod;
			}
		}
	}

	private static int getLower(Long long1, Long[] st) {
		// TODO Auto-generated method stub
		int left = 0, right = st.length - 1;
		int ans = -1;
		while (left <= right) {
			int mid = (left + right) / 2;
			if (st[mid] <= long1) {
				ans = mid;
				left = mid + 1;
			} else {
				right = mid - 1;
			}
		}
		return ans;
	}

}
",0,Non-plagiarised
bdfe8110,fadc1365,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class E {

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

	
	
	

	
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class a{ 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(),k=s.nextInt();
			int pos[]=s.readArray(k);
			int temp[]=s.readArray(k);
			long ans[]=new long[n];
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++){
				ans[pos[i]-1]=temp[i];
			}
			for(int i=1;i<n;i++){
				ans[i]=Math.min(ans[i-1]+1,ans[i]);
			}
			for(int i=n-2;i>=0;i--){
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for(int i=0;i<n;i++){
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
	
    
	
    
    
    
    
    
    
}
",1,Plagiarised
8d6f1bf5,dc281165,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Menorah {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t > 0) {
            int n = Integer.parseInt(br.readLine());
            String source = br.readLine();
            String destination = br.readLine();
            int sameStatusOnes = 0;
            int sameStatusZeros = 0;
            int diffStatusOnes = 0;
            int diffStatusZeros = 0;
            for (int i = 0; i < n; i++) {
                char c1 = source.charAt(i);
                char c2 = destination.charAt(i);
                if (c1 == c2) {
                    if (c1 == '0') {
                        sameStatusZeros += 1;
                    } else {
                        sameStatusOnes += 1;
                    }
                } else {
                    if (c1 == '0') {
                        diffStatusZeros += 1;
                    } else {
                        diffStatusOnes += 1;
                    }
                }
            }
            int sameStatus = sameStatusOnes + sameStatusZeros;
            int diffStatus = diffStatusOnes + diffStatusZeros;
            //first case
            if (sameStatus == n) {
                System.out.println(0);
            } else if (diffStatus == n) {
                //second case
                if (diffStatus % 2 == 0 && diffStatusOnes == (n + 1) / 2)
                    System.out.println(n);
                else
                    System.out.println(-1);
            } else {
                int op1 = -1;
                int op2 = -1;
                if (sameStatus % 2 != 0 && sameStatusOnes == (sameStatus + 1) / 2)
                    op1 = sameStatus;
                if (diffStatus % 2 == 0 && diffStatusOnes == (diffStatus + 1) / 2)
                    op2 = diffStatus;

                if (op1 != -1 && op2 != -1)
                    System.out.println(Integer.min(op1, op2));
                else if (op1 != -1)
                    System.out.println(op1);
                else if (op2 != -1)
                    System.out.println(op2);
                else
                    System.out.println(-1);
            }
            t--;
        }
    }
}
","import java.util.*;
import java.io.*;

public class C {
    static PrintWriter pw;

    void solve(int n, char[] a, char[] b) {
        int same = 0, diff = 0;
        int[] sameCnt = {0, 0}, diffCnt = {0, 0};
        for (int i = 0; i < n; i++) {
            if (a[i] == b[i]) {
                same++;
                sameCnt[a[i] - '0']++;
            } else {
                diff++;
                diffCnt[a[i] - '0']++;
            }
        }
        // tr(same, sameCnt, diff, diffCnt);
        int res = Integer.MAX_VALUE;
        if (same % 2 != 0 && sameCnt[1] - sameCnt[0] == 1) res = Math.min(res, same);
        if (diff % 2 == 0 && diffCnt[1] == diffCnt[0]) res = Math.min(res, diff);
        pr(res == Integer.MAX_VALUE ? -1 : res);
    }

    private void run() {
        // read_write_file(); // comment this before submission
        FastScanner fs = new FastScanner();
        int t = fs.nextInt();
        while (t-- > 0) {
            int n = fs.nextInt();
            char[] a = fs.next().toCharArray(), b = fs.next().toCharArray();
            solve(n, a, b);
        }
    }

    private final String INPUT = ""input.txt"";
    private final String OUTPUT = ""output.txt"";

    

    public static void main(String[] args) {
        pw = new PrintWriter(System.out);
        new C().run();
        pw.close();
    }

    void pr(int num) {
        pw.println(num);
    }

    void pr(long num) {
        pw.println(num);
    }

    void pr(double num) {
        pw.println(num);
    }

    void pr(String s) {
        pw.println(s);
    }

    void pr(char c) {
        pw.println(c);
    }

    

    
}
",0,Non-plagiarised
ccc8ef27,d6fb3b9e,"import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
","import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
",1,Plagiarised
90dc2b20,d8a171a3,"import java.util.*;
import java.io.*;
public class C1615{
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-->0) {
			int n = fs.nextInt();
			String a = fs.next();
			String b = fs.next();
			char ch1[] = a.toCharArray();
			char ch2[] = b.toCharArray();
			int c00 = 0;
			int c01 = 0;
			int c10 = 0;
			int c11 = 0;
			for(int i=0;i<n;i++){
				if(ch1[i]=='0'){
					if(ch2[i]=='0'){
						c00+=1;
					}
					else{
						c01+=1;
					}
				}
				else{
					if(ch2[i]=='0'){
						c10+=1;
					}
					else{
						c11+=1;
					}
				}
			}
			int ans = -1;
			if((c11-c00)==1 || c10==c01){
				int s1 = (int)1e7; 
				int s2 = (int)1e7;
				if((c11-c00)==1){
					s1 = c11+c00;
				}
				if(c10==c01)
				s2 = c10+c01;
				ans = Math.min(s1,s2); 
			}
			out.println(ans);
		}
		out.close();
	}
	
	
}
","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
6f02c6d9,ff34fab2,"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.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.*;
 
public class Div2 {
	
	

	 public static String solution(int [] arr, int n, String st) 
	 {
        ArrayList<Integer> red = new ArrayList<>();
        ArrayList<Integer> blue = new ArrayList<>();
        
        for(int i = 0; i<n; i++)
        {
        	if(st.charAt(i)=='R')
        		red.add(arr[i]);
        	else
        		blue.add(arr[i]);
        }
	    	
        Collections.sort(red);
        Collections.sort(blue);
        int cb = 1;
        
        for(int j = 0; j<blue.size(); j++)
        {
            if(blue.get(j)<cb)
            	return ""NO"";
            cb++;
        }
        
        int cr = n;
        for(int j = red.size()-1; j>=0; j--)
        {
            if(red.get(j)>cr)
            	return ""NO"";
            cr--;
        }
        
        return ""YES"";

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

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
	  
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	String st = s.next();
   
    	out.println(solution(arr,n, st));
    }
    
		     
    out.flush();
    out.close();
    
}
}
",1,Plagiarised
a5d5a95f,c4ca2ff3,"import java.util.*;
import java.io.*;
public class Main {
// For fast input output

// end of fast i/o code
public static void main(String[] args) {
  FastReader reader = new FastReader();
  int Q = reader.nextInt();
  outer: for (int q = 0; q < Q; q++) {
    int N = reader.nextInt();
    int[][] scores = new int[5][N];
    for (int i = 0; i < N; i++) {
      int[] occurs = new int[5];
      String word = reader.next();
      for (int j = 0; j < word.length(); j++) {
        occurs[word.charAt(j) - 'a']++;
      }
      for (int j = 0; j < 5; j++) {
        scores[j][i] = occurs[j] - (word.length() - occurs[j]) ;
      }
    }
    int bestCount = 0;
    for (int i = 0; i < 5; i++) {
      int[] curr = scores[i];
      Arrays.sort(curr);
      int currentCount = 1;
      int currentScore = curr[curr.length - 1];
      for (int j = curr.length - 2; j >= 0 && currentScore > 0; j--) {
        currentScore += curr[j];
        currentCount++;
      }
      if (currentScore <= 0) currentCount--;
      bestCount = Math.max(currentCount, bestCount);
    }
    System.out.println(bestCount);
  }
}

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

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

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


    }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;


public class Armchair {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int arr[]=new int[n];
        ArrayList<Integer> list1=new ArrayList<Integer>();
         ArrayList<Integer> list2=new ArrayList<Integer>();
        for(int i=0;i<n;i++)
        {
            int a=in.nextInt();
            if(a==0)
                list2.add(i);
            else
                list1.add(i);
        }
        long dp[][]=new long[list1.size()+1][list2.size()+1];
        
        solve(list1,list2,dp);
        System.out.println(dp[list1.size()][list2.size()]);
    }

public static void solve( ArrayList<Integer> list1,ArrayList<Integer> list2,long dp[][]){
       for(int i=1;i<=list1.size();i++)
		dp[i][0]=Integer.MAX_VALUE;

	for(int i=1;i<=list1.size();i++){
		for(int j=1;j<=list2.size();j++){
			dp[i][j]=Math.min(Math.abs(list1.get(i-1)-list2.get(j-1))+dp[i-1][j-1],dp[i][j-1]);
		}
	}
}
}
",0,Non-plagiarised
31cdf5fe,80cc284c,"import java.util.Scanner;

public class Main {

    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while(t-- > 0)
        {
            int n = scanner.nextInt();
            int[] time = new int[n];
            int[] h = new int[n];
            for(int i  = 0; i < n; i++)
            {
                time[i] = scanner.nextInt();
            }
            for(int j = 0; j < n; j++)
            {
                h[j] = scanner.nextInt();
            }
            long prevMTime = time[n-1];
            long prevMHealth = h[n-1];
            long manaRequired = 0;
            long currMTime = time[n-1];
            long currMHealth = h[n-1];
            long spellCastingTime = prevMTime - prevMHealth + 1;

            for(int i = n-2; i >= 0; i--)
            {
                currMHealth = h[i];
                currMTime = time[i];
                //spellCastingTime = prevMTime - prevMHealth + 1;
                if(spellCastingTime <= currMTime && currMTime - spellCastingTime + 1 < currMHealth)
                {
                    spellCastingTime = currMTime - currMHealth + 1;
                }
                else if(spellCastingTime > currMTime)
                {
                    long hm = (prevMTime - spellCastingTime) + 1;
                    manaRequired += (hm * (hm+1)) / 2;
                    prevMTime =currMTime;
                    prevMHealth = currMHealth;
                    spellCastingTime = prevMTime - prevMHealth + 1;
                }
            }
            long hm = (prevMTime - spellCastingTime) + 1;
            manaRequired += (hm * (hm+1)) / 2;
            System.out.println(manaRequired);

        }
    }

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

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-- > 0){
			int n = sc.nextInt();
			long[] k = new long[n];
			long[] h = new long[n];
			for(int i = 0;i < n;i++){
				k[i] = sc.nextLong();
			}
			for(int i = 0;i < n;i++){
				h[i] = sc.nextLong(); 
			}
			long length = h[n-1];
			long curr = 0;
			long ans = 0;
			for(int i = n-1;i >= 1;i--){
				if(k[i] - k[i-1] >= length){
					curr += length;
					ans = ans += (curr * (curr + 1))/2;
					length = h[i-1];
					curr = 0;
				}else{
					length = Math.max(length - (k[i] - k[i-1]), h[i-1]);
					curr += k[i] - k[i-1];
				}
			}
			curr += length;
			ans += (curr * (curr + 1))/2;
			System.out.println(ans);
		}
	}
}
",0,Non-plagiarised
4a1573d6,db8d728d,"import java.util.*;
import java.math.*;
import java.io.*; 
 public class A{

static FastReader scan=new FastReader();
 public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
  static LinkedList<Integer>edges[];
  static boolean stdin = true;
    static String filein = ""input"";
    static String fileout = ""output"";
static int dx[] = { -1, 0, 1, 0 };
static int dy[] = { 0, 1, 0, -1 };
int dx_8[]={1,1,1,0,0,-1,-1,-1};
int dy_8[]={-1,0,1,-1,1,-1,0,1};
static char sts[]={'U','R','D','L'};
static boolean prime[];

    
   
 
   
  
 
 
           
           static int perm=0,FOR=0;
           
     

static boolean flag=false;
static int len=100000000;

static ArrayList<Pair>inters=new ArrayList<Pair>();





static StringBuilder sb;



 private static int next(int[] arr, int target)  
    {  
        int start = 0, end = arr.length - 1;  
    
        int ans = -1;  
        while (start <= end) {  
            int mid = (start + end) / 2;  
    
            // Move to right side if target is  
            // greater.  
            if(arr[mid]==target)
                return mid;
            if (arr[mid] <target) {  
                start = mid + 1;  
            }  
    
            // Move left side.  
            else {  
                ans = mid;  
                end = mid - 1;  
            }  
        }  
        return ans;  
    }  
//static boolean vis[][];
    

  

  
  static StringBuilder a,b;

    
static ArrayList<Integer>v;
static ArrayList<Integer>pows;
 


   static long mod=(long)(1e9)+7;
    
        
    static int dp[][];
    static int n;
    static int arr[];
        
        
public static void main(String[] args)  throws Exception 
{
//SUCK IT UP AND DO IT ALRIGHT
//scan=new FastReader(""div7.in"");
//out = new PrintWriter(""div7.out"");
   //System.out.println(countSetBits(2015));
    //int elem[]={1,2,3,4,5};
//System.out.println(""avjsmlfpb"".compareTo(""avjsmbpfl""));
int tt=1;

/*for(int i=0;i<=100;i++)
    if(prime[i])
        arr.add(i);
    System.out.println(arr.size());*/
   // check(new StringBuilder(""05:11""));
   // System.out.println(26010000000000L%150);
   tt=scan.nextInt();

outer:while(tt-->0)
{
 int n=scan.nextInt(),m=scan.nextInt();
 char board[][]=new char[n][m];
 for(int i=0;i<n;i++)
    board[i]=scan.next().toCharArray();
ArrayList<Pair>res[]=new ArrayList[3*n*m];
for(int i=0;i<3*n*m;i++)
res[i]=new ArrayList();
int k=0;
for(int i=0;i<n;i++)
{
    for(int j=0;j<m;j++)
    {
        ArrayList<Pair>arr=new ArrayList<Pair>();
        ArrayList<Pair>arr2=new ArrayList<Pair>();
        if(i+1<n&&j+1<m)
        {
            if(board[i][j]=='1')
                arr.add(new Pair(i,j));
            else arr2.add(new Pair(i,j));
            if(board[i][j+1]=='1')
                arr.add(new Pair(i,j+1));
            else  arr2.add(new Pair(i,j+1));
            
            if(board[i+1][j]=='1')
                arr.add(new Pair(i+1,j));
            else arr2.add(new Pair(i+1,j));
            if(board[i+1][j+1]=='1')
                arr.add(new Pair(i+1,j+1));
            else arr2.add(new Pair(i+1,j+1));
            if(arr.size()==3)
            {
                for(Pair p:arr){
                    board[p.x][p.y]='0';
                    res[k].add(new Pair(p.x,p.y));
                }
                k++;
            }
            else if(arr.size()==2)
            {
                for(Pair p:arr2)
                {
                    board[p.x][p.y]='1';
                     res[k].add(new Pair(p.x,p.y));
                }
                //k++;
                Pair p=arr.get(0);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
                for(Pair pp:arr2)
                {
                    board[pp.x][pp.y]='0';
                    res[k].add(new Pair(pp.x,pp.y));
                }
                p=arr.get(1);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
            }
            else if(arr.size()==1)
            {
                Pair p=arr.get(0);
                Pair tmp=new Pair(p.x,p.y);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                p=arr2.get(1);
                 board[p.x][p.y]='1';
                res[k].add(new Pair(p.x,p.y));
                  p=arr2.get(2);
                 board[p.x][p.y]='1';
                res[k].add(new Pair(p.x,p.y));
                k++;
                arr=new ArrayList();
                arr.add(new Pair(arr2.get(1).x,arr2.get(1).y));
                arr.add(new Pair(arr2.get(2).x,arr2.get(2).y));
                arr2.remove(1);
                arr2.remove(1);
                arr2.add(new Pair(tmp.x,tmp.y));

                for(Pair pp:arr2)
                {
                    board[pp.x][pp.y]='1';
                     res[k].add(new Pair(pp.x,pp.y));
                }
                //k++;
                 p=arr.get(0);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
                for(Pair pp:arr2)
                {
                    board[pp.x][pp.y]='0';
                    res[k].add(new Pair(pp.x,pp.y));
                }
                p=arr.get(1);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
            }
            else if(arr.size()==4)
            {
                Pair p=arr.get(0);
                board[p.x][p.y]='0';
                arr2.add(new Pair(p.x,p.y));
                res[k].add(new Pair(p.x,p.y));
                 p=arr.get(1);
                board[p.x][p.y]='0';
                arr2.add(new Pair(p.x,p.y));
                  res[k].add(new Pair(p.x,p.y));

                 p=arr.get(2);
                board[p.x][p.y]='0';
                arr2.add(new Pair(p.x,p.y));
                  res[k].add(new Pair(p.x,p.y));
                  k++;
                arr.remove(0);
                arr.remove(0);
                arr.remove(0);
                p=arr.get(0);

                Pair tmp=new Pair(p.x,p.y);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                p=arr2.get(1);
                 board[p.x][p.y]='1';
                res[k].add(new Pair(p.x,p.y));
                  p=arr2.get(2);
                 board[p.x][p.y]='1';
                res[k].add(new Pair(p.x,p.y));
                k++;
                arr=new ArrayList();
                arr.add(new Pair(arr2.get(1).x,arr2.get(1).y));
                arr.add(new Pair(arr2.get(2).x,arr2.get(2).y));
                arr2.remove(1);
                arr2.remove(1);
                arr2.add(new Pair(tmp.x,tmp.y));

                for(Pair pp:arr2)
                {
                    board[pp.x][pp.y]='1';
                     res[k].add(new Pair(pp.x,pp.y));
                }
                //k++;
                 p=arr.get(0);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
                for(Pair pp:arr2)
                {
                    board[pp.x][pp.y]='0';
                    res[k].add(new Pair(pp.x,pp.y));
                }
                p=arr.get(1);
                board[p.x][p.y]='0';
                res[k].add(new Pair(p.x,p.y));
                k++;
            }


        }
    }
}
/*for(int i=0;i<n;i++){
for(int j=0;j<m;j++)
{
    out.print(board[i][j]+"" "");
}
out.println();
}*/
out.println(k);
for(int i=0;i<k;i++)
{
    for(Pair p:res[i])
        out.print((p.x+1)+"" ""+(p.y+1)+"" "");
    out.println();
}


}




 
out.close();

//SEE UP 

}






 


 
 static class Pair implements Comparable<Pair>{
        public int x, y;
        public Pair(int x1, int y1) {
            x=x1;
            y=y1;
        }
        
        
        


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

public class BinaryTable {
    
    // static int mod = 998244353;
    static int mod = 1000000007;

    

    public static void main(String[] args) throws Exception {
        FastReader scn = new FastReader();
        PrintWriter pw = new PrintWriter(System.out);
        int t = scn.nextInt();
        outer : while(t-->0){
            int n = scn.nextInt();
            int m = scn.nextInt();
            int[][] arr = new int[n][m];
            for(int i=0; i<n; i++){
            	String s = scn.nextLine();
            	for(int j=0; j<m; j++){
            		char ch = s.charAt(j);
            		arr[i][j] = ch - '0';
            	}
            }
            ArrayList<Pair> list = new ArrayList<>();
            if(n % 2 == 0 && m % 2 == 0){
            	for(int i=0; i<n; i+=2){
            		for(int j=0; j<m; j+=2){
            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}
            		}
            	}
            }else if(n % 2 == 0 && m % 2 == 1){
            	int M = m-1;
            	for(int i=0; i<n; i+=2){
            		for(int j=0; j<M; j+=2){
            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}
            		}
            	}
            	for(int i=0; i<n; i+=2){
            		if(arr[i][m-1] == 1 && arr[i+1][m-1] == 1){
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-1));
            		}else if(arr[i][m-1] == 1){
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i, m-1));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-1));
						list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-1));
            		}else if(arr[i+1][m-1] == 1){
            			list.add(new Pair(i, m-1));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-1));
           				list.add(new Pair(i, m-2));
            		}
            	}
            }else if(n % 2 == 1 && m % 2 == 0){
            	int N = n-1;
            	for(int i=0; i<N; i+=2){
            		for(int j=0; j<m; j+=2){
            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}
            		}
            	}
            	for(int j=0; j<m; j+=2){
            		if(arr[n-1][j] == 1 && arr[n-1][j+1] == 1){
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-2, j+1));
            		}else if(arr[n-1][j] == 1){
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-1, j));
						list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-2, j));
            		}else if(arr[n-1][j+1] == 1){
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j));
           				list.add(new Pair(n-1, j+1));
            		}
            	}
            }else if(n % 2 == 1 && m % 2 == 1){
            	int N = n-1;
            	int M = m-1;
            	for(int i=0; i<N; i+=2){
            		for(int j=0; j<M; j+=2){
            			if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j] == 1 && arr[i][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1 && arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            			}else if(arr[i][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}else if(arr[i][j+1] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j] == 1){
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i, j));
            			}else if(arr[i+1][j+1] == 1){
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j+1));
            				list.add(new Pair(i+1, j+1));
            				list.add(new Pair(i, j));
            				list.add(new Pair(i+1, j));
            			}
            		}
            	}
            	for(int j=0; j<M; j+=2){
            		if(arr[n-1][j] == 1 && arr[n-1][j+1] == 1){
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-2, j+1));
            		}else if(arr[n-1][j] == 1){
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-1, j));
						list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-2, j));
            		}else if(arr[n-1][j+1] == 1){
            			list.add(new Pair(n-1, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j+1));
            			list.add(new Pair(n-2, j+1));
            			list.add(new Pair(n-2, j));
            			list.add(new Pair(n-1, j));
           				list.add(new Pair(n-1, j+1));
            		}
            	}
            	for(int i=0; i<N; i+=2){
            		if(arr[i][m-1] == 1 && arr[i+1][m-1] == 1){
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-1));
            		}else if(arr[i][m-1] == 1){
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i, m-1));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-1));
						list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i, m-1));
            		}else if(arr[i+1][m-1] == 1){
            			list.add(new Pair(i, m-1));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-2));
            			list.add(new Pair(i+1, m-2));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i+1, m-1));
            			list.add(new Pair(i, m-1));
           				list.add(new Pair(i, m-2));
            		}
            	}
            	if(arr[n-1][m-1] == 1){
            		list.add(new Pair(n-1, m-1));
            		list.add(new Pair(n-2, m-1));
            		list.add(new Pair(n-1, m-2));
            		list.add(new Pair(n-2, m-2));
            		list.add(new Pair(n-1, m-2));
            		list.add(new Pair(n-1, m-1));
            		list.add(new Pair(n-1, m-1));
            		list.add(new Pair(n-2, m-2));
            		list.add(new Pair(n-2, m-1));
            	}
            }
            int k = list.size()/3;
            pw.println(k);
            for(int i=0; i<k; i++){
            	for(int j=0; j<3; j++){
            		Pair p = list.get(i*3+j);
            		pw.print((p.x+1) + "" "" + (p.y+1) + "" "");
            	}
            	pw.println();
            }
        }
        pw.close();
    }

    public static class Pair{
        int x;
        int y;

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

    

    

    // private static void sort(Pair[] arr) {
    //     List<Pair> list = new ArrayList<>();
    //     for(int i=0; i<arr.length; i++){
    //         list.add(arr[i]);
    //     }
    //     Collections.sort(list); // collections.sort uses nlogn in backend
    //     for (int i = 0; i < arr.length; i++){
    //         arr[i] = list.get(i);
    //     }
    // }

    

    

    

    

    

    

    // (x^y)%p in O(logy)
    

    
    
    
    
    

    

    // TC- O(logmax(a,b))
    

    

    

    // TC- O(logmax(a,b))
    

    

     
}
",0,Non-plagiarised
35f0c004,8d6f1bf5,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            String a=input.next();
            String b=input.next();
            int same1=0,same0=0,opp1=0,opp0=0;
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)==b.charAt(i))
                {
                    if(a.charAt(i)=='1') same1++;
                    else same0++;
                }
                else
                {
                    if(a.charAt(i)=='1') opp1++;
                    else opp0++;
                }
            }
            if(same0+same1==n)
            {
                out.println(0);
            }
            else
            {
                int x=same1+opp1;
                int y=same1+opp0;
                int z=same0+opp0;
                if(x==y || (z+1)==y)
                {
                    int min=Integer.MAX_VALUE;
                    if((same0+same1)%2!=0 && same0==(same0+same1)/2)
                    {
                        min=Math.min(min,same0+same1);
                    }
                    if((opp0+opp1)%2==0 && opp0==(opp0+opp1)/2)
                    {
                        min=Math.min(min,opp0+opp1);
                    }
                    out.println(min);
                }
                else
                {
                    out.println(-1);
                }
            }
        }
        out.close();
    }
    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Menorah {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t > 0) {
            int n = Integer.parseInt(br.readLine());
            String source = br.readLine();
            String destination = br.readLine();
            int sameStatusOnes = 0;
            int sameStatusZeros = 0;
            int diffStatusOnes = 0;
            int diffStatusZeros = 0;
            for (int i = 0; i < n; i++) {
                char c1 = source.charAt(i);
                char c2 = destination.charAt(i);
                if (c1 == c2) {
                    if (c1 == '0') {
                        sameStatusZeros += 1;
                    } else {
                        sameStatusOnes += 1;
                    }
                } else {
                    if (c1 == '0') {
                        diffStatusZeros += 1;
                    } else {
                        diffStatusOnes += 1;
                    }
                }
            }
            int sameStatus = sameStatusOnes + sameStatusZeros;
            int diffStatus = diffStatusOnes + diffStatusZeros;
            //first case
            if (sameStatus == n) {
                System.out.println(0);
            } else if (diffStatus == n) {
                //second case
                if (diffStatus % 2 == 0 && diffStatusOnes == (n + 1) / 2)
                    System.out.println(n);
                else
                    System.out.println(-1);
            } else {
                int op1 = -1;
                int op2 = -1;
                if (sameStatus % 2 != 0 && sameStatusOnes == (sameStatus + 1) / 2)
                    op1 = sameStatus;
                if (diffStatus % 2 == 0 && diffStatusOnes == (diffStatus + 1) / 2)
                    op2 = diffStatus;

                if (op1 != -1 && op2 != -1)
                    System.out.println(Integer.min(op1, op2));
                else if (op1 != -1)
                    System.out.println(op1);
                else if (op2 != -1)
                    System.out.println(op2);
                else
                    System.out.println(-1);
            }
            t--;
        }
    }
}
",0,Non-plagiarised
4fd752f7,c7239c97,"import java.io.*;
import java.util.*;

public class C {
	
	public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt(), tt = 0;
        while(t-->0) { 
        	int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
        	int aa[] = in.readArray(n);
        	Pair a[] = new Pair[n];
        	for(int i=0;i<n;i++) a[i] = new Pair(i,aa[i]);
        	PriorityQueue<Pair> pq = new PriorityQueue<>();
        	Arrays.sort(a);
        	int goneTo[] = new int[n];
        	for(int i=0;i<m;i++){
        		pq.add(new Pair(i+1,a[n-1-i].y));
        		goneTo[a[n-1-i].x] = i+1;
        	}
        	for(int i=n-m-1;i>=0;i--){
        		Pair xx = pq.poll();
        		xx.y += a[i].y;
        		goneTo[a[i].x] = xx.x;
        		pq.add(new Pair(xx.x,xx.y));
        	}
        	Iterator<Pair> it = pq.iterator();
        	ArrayList<Pair> arr = new ArrayList<>();
        	while(it.hasNext()) arr.add(it.next());
        	Collections.sort(arr);
        	//for(Pair i : arr) out.print(i.y+"" "");
        	//out.println();
        	if(arr.get(m-1).y-arr.get(0).y>x) out.println(""NO"");
        	else{
        		out.println(""YES"");
        		int pos[] = new int[n];
        		for(Pair i : a) pos[i.x] = goneTo[i.x];
        		for(int i : pos) out.print(i+"" "");
        		out.println();
        	}
    		//tt++; out.println(""Case #""+tt+"": ""+ans);
        }
        out.flush();
}

static class Pair implements Comparable<Pair> {
		int x, y;
		Pair(int a, int b){ x = a; y = b; }		
		
		}	

	
	

	static final Random random = new Random();

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

public class C {
	
	public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt(), tt = 0;
        while(t-->0) { 
        	int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
        	int aa[] = in.readArray(n);
        	Pair a[] = new Pair[n];
        	for(int i=0;i<n;i++) a[i] = new Pair(i,aa[i]);
        	PriorityQueue<Pair> pq = new PriorityQueue<>();
        	Arrays.sort(a);
        	int goneTo[] = new int[n];
        	for(int i=0;i<m;i++){
        		pq.add(new Pair(i+1,a[n-1-i].y));
        		goneTo[a[n-1-i].x] = i+1;
        	}
        	for(int i=n-m-1;i>=0;i--){
        		Pair xx = pq.poll();
        		xx.y += a[i].y;
        		goneTo[a[i].x] = xx.x;
        		pq.add(new Pair(xx.x,xx.y));
        	}
        	Iterator<Pair> it = pq.iterator();
        	ArrayList<Pair> arr = new ArrayList<>();
        	while(it.hasNext()) arr.add(it.next());
        	Collections.sort(arr);
        	//for(Pair i : arr) out.print(i.y+"" "");
        	//out.println();
        	if(arr.get(m-1).y-arr.get(0).y>x) out.println(""NO"");
        	else{
        		out.println(""YES"");
        		int pos[] = new int[n];
        		for(Pair i : a) pos[i.x] = goneTo[i.x];
        		for(int i : pos) out.print(i+"" "");
        		out.println();
        	}
    		//tt++; out.println(""Case #""+tt+"": ""+ans);
        }
        out.flush();
}

static class Pair implements Comparable<Pair> {
		int x, y;
		Pair(int a, int b){ x = a; y = b; }		
		
		}	

	
	

	static final Random random = new Random();

	
}
",1,Plagiarised
26e699de,76ad805a,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

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



        }

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

public class First {
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            String a = sc.next();
            String b = sc.next();
            char ch1[] = a.toCharArray();
            char ch2[] = b.toCharArray();
            int zz = 0;
            int oz = 0;
            int zo = 0;
            int oo = 0;
            for (int i = 0; i < n; i++) {
                if (ch1[i] == '0') {
                    if (ch2[i] == '0') {
                        zz += 1;
                    } else {
                        oz += 1;
                    }
                } else {
                    if (ch2[i] == '0') {
                        zo += 1;
                    } else {
                        oo += 1;
                    }
                }
            }
            int ans = -1;
            if ((oo - zz) == 1 || zo == oz) {
                int s1 = (int) 1e7;
                int s2 = (int) 1e7;
                if ((oo - zz) == 1) {
                    s1 = oo + zz;
                }
                if (zo == oz)
                    s2 = zo + oz;
                ans = Math.min(s1, s2);
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
1984bef1,2063ba3e,"import java.util.*;
import java.io.*;
public class stoneheaps {
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int t = Integer.parseInt(br.readLine());
		for(int i = 0; i < t; i ++) {
			int n = Integer.parseInt(br.readLine());
			String[] tokens = br.readLine().split("" "");
			int[] arr = new int[n];
			for(int j = 0; j < n; j++) {
				arr[j] = Integer.parseInt(tokens[j]);
			}
			
			int l = 1;
			int r = 1000000000;
			while(l < r) {
				int mid  = l + (r-l+1)/2;
				if(check(arr, mid)) {
					l = mid;
				}
				else {
					r = mid-1;
				}
			}
			System.out.println(l);
		}
	}
	
	static boolean check(int[] arr, int x) {
		int[] changed = new int[arr.length];
		
		for(int i = 0; i < arr.length; i ++) {
			changed[i] = arr[i];
		}
		
		int n = arr.length;
		for(int i = n-1; i >= 0; i--) {
			if(changed[i] < x) {
				return false;
			}
			else if(i > 1){
				int change = Math.min(changed[i]-x, arr[i])/3;
				changed[i-1] = changed[i-1]+change;
				changed[i-2] = changed[i-2] +change*2;
			}
		}
		return true;
	}
}
","import java.io.*;
import java.util.*;

public class c {
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int numCases = Integer.parseInt(in.readLine());
        for (int casenum = 0; casenum < numCases; casenum++) {
            int n = Integer.parseInt(in.readLine());
            long[] arr = new long[n];
            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
            for (int i = 0; i < n; i++) {
                arr[i] = Long.parseLong(tokenizer.nextToken());
            }
            long low = 0;
            long high = 1000000000;
            low--;
            while (low < high) {
                long mid = low + (high - low + 1) / 2;
                boolean works = test(arr, mid);
                if (works) {
                    low = mid;
                } else {
                    high = mid - 1;
                }
                //System.out.println(mid + "" "" + works);
            }
            System.out.println(low);
        }
        in.close();
        out.close();
    }

    public static boolean test(long[] arr, long k) {
        long[] h = new long[arr.length];
        for (int i = 0; i < arr.length; i++) {
            h[i] = arr[i];
        }
        for (int i = h.length - 1; i - 2 >= 0; i--) {
            if (h[i] < k)
                break;
            long d = Math.min((h[i]-k) / 3, arr[i]/3);
            h[i] -= 3 * d;
            h[i - 1] += d;
            h[i-+ 2] += 2 * d;
        }
        for (int i = 0; i < h.length; i++) {
            if (h[i] < k)
                return false;
        }
        //System.out.println(Arrays.toString(h));
        return true;
    }
}
",0,Non-plagiarised
1410e423,da5cf40b,"import java.io.*;
import java.util.*;

public class C {

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

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		
		int t = Integer.parseInt(br.readLine());
		
		while(t --> 0) {
			
			int n = Integer.parseInt(br.readLine());
			
			char[] lineA = br.readLine().toCharArray();
			char[] lineB = br.readLine().toCharArray();
			
			boolean[] a = new boolean[n];
			boolean[] b = new boolean[n];
			
			int ac = 0;
			int aic = 0;
			int bc = 0;
			int stay = 0;
			int flip = 0;
			
			for(int i = 0; i < n; i++) {
				
				if(lineA[i] == '1') {
					
					ac++;
					a[i] = true;
					
				}else
					aic++;
				
				if(lineB[i] == '1') {
					
					bc++;
					b[i] = true;
					
				}
				
				if(a[i] == b[i])
					stay++;
				else
					flip++;
				
			}
			
			if(ac != bc && aic + 1 != bc) {
				
				pw.println(-1);
				
			}else {
				
				if(ac == aic+1)
					pw.println(Math.min(stay, flip));
				else if(ac == bc)
					pw.println(flip);
				else
					pw.println(stay);
				
			}
			
		}
		
		pw.close();

	}

}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    /* start */
   
       public static void main(String [] args)
    {
        // int testcases = 1;
        int testcases = i();
        while(testcases-->0)
        {
            
            solve();
        }
        out.flush();
        out.close();
    }
    static void solve()
    { 
        int n = i();
        char c[] = inputC();
        char d[] = inputC();
        int x01=0,x10=0,x00=0,x11=0;
        for(int i=0;i<n;i++)
        {
            if(c[i]=='0'&&d[i]=='0')x00++;
            if(c[i]=='0'&&d[i]=='1')x01++;
            if(c[i]=='1'&&d[i]=='0')x10++;
            if(c[i]=='1'&&d[i]=='1')x11++;
        }

        int ans = Integer.MAX_VALUE;
        if(x01==0 && x10==0)
        {
            System.out.println(0);
            return ;
        }
        if(x11==x00+1)
        {
            ans = Math.min(x11+x00,ans);
        }
      if(x01==x10)
        {
            ans = Math.min(x01+x10,ans);
        }
        if(ans == Integer.MAX_VALUE){
            ans = -1;
        }
        System.out.println(ans);
    }
    
    /* end */
     

    static int i() {
        return sc.nextInt();
    }


    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    

    

    

    
      
     

      

     
    
     

    
    

    

    

    

    

    

    

     

      

        
    
        
        //pair class
        
}
",0,Non-plagiarised
3b498a39,ae775964,"import java.util.*;


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

public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];
	 static int max;
	  public static void main(String[] args)
{
		   PrintWriter out=new PrintWriter(System.out);
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		   //ttt =i();
		 
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int A[]=input(n);
	        	dp=new long[n+1][n+1];
	        	for(int i=0;i<=n;i++) {
	        		Arrays.fill(dp[i],-1);
	        	}
		        	
	        	
	        	ArrayList<Integer> l=new ArrayList<Integer>();
	        	ArrayList<Integer> m=new ArrayList<Integer>();
	        	for(int i=0;i<n;i++) {
	        		if(A[i]==0) {
	        			l.add(i+1);
	        		}
	        		else {
	        			m.add(i+1);
	        		}
	        	}
	        	A=new int[m.size()];
	        	int B[]=new int[l.size()];
	        	for(int i=0;i<l.size();i++) {
	        		B[i]=l.get(i);
	        	}
	        	for(int i=0;i<m.size();i++) {
	        		A[i]=m.get(i);
	        	}
	        	n=m.size();
	        	int o=l.size();
		        	System.out.println(go(A,B,0,0,n,o));
	        	
			}

	     //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	//CHECK FOR N=1
       	//CHECK FOR N=1
		        
		     
    }
	  
	 
	  
	  
	
	 
	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
		if(i==n)
			return 0;
		if(j==m)
			return Integer.MAX_VALUE;
		if(dp[i][j]!=-1)
			return dp[i][j];
		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
		long op2=go(A, B, i, j+1, n, m);
		return dp[i][j]=Math.min(op1, op2);
	
		
		
		
		
		}








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

















     static int i() {
    	 return sc.nextInt();
     }
     
     static long l() {
    	 return sc.nextLong();
     }  
     
     
  
  
  
      
      
      
      
     
        
     
}
","import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.sound.sampled.ReverbType;


public class Edu109 {
	static PrintWriter out;
	static Scanner sc;
	static int[]a;
	static int A,B,n,m,h,ans,sum;
	public static void main(String[]args) throws IOException {
		sc=new Scanner(System.in);
		out=new PrintWriter(System.out);
		D();
		out.close();
	}
	  
		
		
		
		
		
		
		static long[][]mem;
		static int ones;
		static ArrayList<Integer>pos;
		static void D() throws IOException {
			int t=1;
			while(t-->0) {
				n=ni();
				a=nai(n);
				mem=new long[n][n];
				ones=0;
				pos=new ArrayList<Integer>();
				for(int i=0;i<n;i++) {
					Arrays.fill(mem[i], -1);
					if(a[i]==1)pos.add(i);
				}
				ones=pos.size();
				long ans=solve(0,0);
				out.println(ans);
			}
		}
		private static long solve(int i, int j) {
			if(i==n||j>=ones)return j==ones?0:(long)1e14;
			if(mem[i][j]!=-1)return mem[i][j];
			long lv=solve(i+1,j);
			if(a[i]==0) {
				int pr=Math.abs(i-pos.get(j));
				lv=Math.min(lv, pr+solve(i+1,j+1));
			}
			return mem[i][j]=lv;
		}
		
		
		
		
	

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

	
	
	
	
	

	
}
",0,Non-plagiarised
5288afb7,df594a00,"import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int t=Integer.parseInt(bu.readLine());
        while(t-->0)
        {
            bu.readLine();
            String s[]=bu.readLine().split("" "");
            int n=Integer.parseInt(s[0]),k=Integer.parseInt(s[1]);
            int a[]=new int[n],i,x,ac[]=new int[n],b[]=new int[k];
            Arrays.fill(a,Integer.MAX_VALUE);

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

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

            for(i=0;i<n;i++) sb.append(a[i]+"" "");
            sb.append(""\n"");
        }
        System.out.print(sb);
    }
}
","import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int cases = Integer.parseInt(br.readLine());
		while(cases-- > 0) {
			br.readLine();
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int k = Integer.parseInt(str[1]);
			int[] a = new int[k];
			int[] t = new int[k];
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				a[i] = Integer.parseInt(str[i]) - 1;
			}
			str = br.readLine().split("" "");
			for(int i=0; i<k; i++) {
				t[i] = Integer.parseInt(str[i]);
			}
			int[] temp = new int[n];
			Arrays.fill(temp, Integer.MAX_VALUE);
			int[] left = new int[n];
			int[] right = new int[n];
			Arrays.fill(left, Integer.MAX_VALUE);
			Arrays.fill(right, Integer.MAX_VALUE);
			int ind = 0;
			for(int i=0; i<k; i++) {
				left[a[i]] = t[i];
				right[a[i]] = t[i];
			}
			int minleft = Integer.MAX_VALUE;
			for(int i=0; i<n; i++) {
				left[i] = Math.min(left[i], minleft);
				minleft = left[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : left[i]+1;
			}
			int minright = Integer.MAX_VALUE;
			for(int i=n-1; i>=0; i--) {
				right[i] = Math.min(right[i], minright);
				minright = right[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : right[i]+1;
			}
			for(int i=0; i<n; i++) {
				temp[i] = Math.min(right[i], left[i]);
				System.out.print(temp[i]+"" "");
			}
			System.out.println();
		}
	}
}
",0,Non-plagiarised
ad2a1ae2,bc46480a,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.StringTokenizer;
 
public class Solution {
	 
	 
	public static void main(String[] args) {
		FastReader sc = new FastReader();
       
        int t=sc.nextInt();
       while(t-->0) {
    	   int n=sc.nextInt();
    	   int r[]=new int[n];
    	   int l[]=new int[n];
    	   for(int i=0;i<n;i++) {
    		   r[i]=sc.nextInt();
    	   }
    	   for(int i=0;i<n;i++) l[i]=r[i]-sc.nextInt()+1;
    	   long ans=0,min=l[n-1],max=r[n-1];
    	   
    	   for(int i=n-2;i>=0;i--) {
    		   if(r[i]>=min) min=Math.min(min,l[i]);
    		   else {
    			   ans+=(max-min+1)*(max-min+2)/2;
    			   max=r[i];
    			   min=l[i];
    		   }
    		   
    	   }
    	   ans+=(max-min+1)*(max-min+2)/2;
    	   System.out.println(ans);
    	   
    	   
       }
}	
}
","import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

/**
 * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
 */

public class Main {
   static InputReader sc=new InputReader(System.in);
   public static void main(String[] args) {
      // Write your solution here
      int t=sc.nextInt();
      while(t-->0){
         solve();
      }
   }

   private static void solve() {
      int n=sc.nextInt();
      Node left[]=new Node[n];
      int index=0;
      Node ini[]=new Node[n];
      int tmp[]=new int[n];
      for(int i=0;i<n;i++){
         tmp[i]=sc.nextInt();
      }
      for(int i=0;i<n;i++){
         ini[i]=new Node(tmp[i],tmp[i]-sc.nextInt()+1);
      }
      Arrays.sort(ini);
      left[0]=ini[0];
      for(int i=1;i<n;i++){
         //System.out.println(ini[i].k+"" ""+ini[i].s);
         if(ini[i].s<=left[index].k&&ini[i].k>left[index].k){
            left[index].k=ini[i].k;
         }else if(ini[i].s>left[index].k){
            index++;
            left[index]=ini[i];
         }
      }
      long ans=0;
      for(int i=0;i<=index;i++){
         //System.out.println(left[i].k+"" ""+left[i].s);
         ans+=(long)(left[i].k-left[i].s+2)*(left[i].k-left[i].s+1)/2;
      }
      System.out.println(ans);


   }
}
class Node implements Comparable<Node>{
   int k,s;
   Node(int k,int s){
      this.s=s;
      this.k=k;
   }
   
}

",0,Non-plagiarised
3b5cec19,8f31b279,"import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;



public class Test{

    static class Pair implements Comparable<Pair>{
    int wt;
    int idx;
    Pair(int x,int y){
        this.wt=x;
        this.idx=y;
    }
    

    
}   



    public static void main (String[] args) throws java.lang.Exception{
        FastReader scan=new FastReader();
        int t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int m=scan.nextInt();
            int x=scan.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            Queue<Pair>q=new PriorityQueue<>();
            for(int i=1;i<=m;i++){
                q.add(new Pair(0,i));
            }
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                Pair temp=q.poll();
                int wt=temp.wt;
                int idx=temp.idx;
                System.out.print(idx+"" "");
                //System.out.println(temp);
                q.add(new Pair(wt+arr[i],idx));
            }
            System.out.println();


        }
    }

        
}
","import java.util.*;
import java.io.*;
public class JavaTract
{
	static class Pair implements Comparable<Pair>{
    	int first;
    	int second;
    	Pair(int x,int y){
        	this.first=x;
        	this.second=y;
    	}
    	
   	}	
    public static void main (String[] args) 
    {
        Scanner scan=new Scanner(System.in);
        int t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int m=scan.nextInt();
            int x=scan.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            // TreeSet<Pair> set = new TreeSet<>(); 
            Queue<Pair> set = new PriorityQueue<>();
            for(int i=1;i<=m;i++){
               
               set.add(new Pair(0,i));
            }
            
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                Pair temp=set.poll();
                
                int first = temp.first;
                int second = temp.second;

                System.out.print(second+"" "");
                
                set.add(new Pair(first+arr[i],second));
                
            }
            System.out.println();


        }
    }

       
}
",1,Plagiarised
22b41936,9cea10af,"import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {

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

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

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

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

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

     }



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

//        try {


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


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

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


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

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








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

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

    }

    

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


    

    

    

    


    

    

    

    

    


    


    


    


}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class P4 {
	static int dp[][]=new int[5000+1][5000+1];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader sc=new FastReader();
		int t=1;
		//t=sc.nextInt();
		StringBuilder s=new StringBuilder();
		while(t--!=0) {
			int n=sc.nextInt();
			int a[]=new int[n];
			
			for(int i=0;i<=n;i++) {
				for(int j=0;j<=n;j++) {
					P4.dp[i][j]=-1;
				}
			}
			ArrayList<Integer> one=new ArrayList<>();
			ArrayList<Integer> zero=new ArrayList<>();
			for(int i=0;i<n;i++) {
				a[i]=sc.nextInt();
				if(a[i]==0) {
					zero.add(i);
				}else {
					one.add(i);
				}
			}
			Collections.sort(zero);
			Collections.sort(one);
			long ans=sol(0,0,zero.size(),one.size(),a,zero,one);
			System.out.println(ans);
		}
		//System.out.println(s);
	}
	private static long sol(int i, int j, int n, int m,int a[], ArrayList<Integer> zero, ArrayList<Integer> one) {
		//System.out.println(i+"" ""+j);
		// TODO Auto-generated method stub
		if(j==m) {
			return 0;
		}
		int av=n-i;
		int rem=m-j;
		if(av<rem) {
			return Integer.MAX_VALUE-1;
		}
		if(dp[i][j]!=-1) {
			return dp[i][j];
		}
		long ans1=sol(i+1,j,n,m,a, zero, one);
		long ans2=Math.abs(zero.get(i)-one.get(j))+sol(i+1,j+1,n,m,a, zero, one);
		dp[i][j]=(int) Math.min(ans1, ans2);
		return dp[i][j];
	}
	 
}
",1,Plagiarised
307ef2cb,565f77b7,"import java.util.PriorityQueue;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 18:16:56 02/05/2021
    Custom Competitive programming helper.
*/

public class Main {
	public static void solve() {
		int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
		Pair[] a = new Pair[n];
		for(int i = 0; i<n; i++) a[i] = new Pair(i, in.nextInt());
		Util.sortArray(a);
		Util.reverse(a);
		PriorityQueue<Pair> heights = new PriorityQueue<>();
		for(int i = 0; i<m; i++) heights.add(new Pair(i, 0));
		int[] ans = new int[n];
		for(int i = 0; i<n; i++) {
			Pair p = heights.poll();
			p.val += a[i].val;
			ans[a[i].idx] = p.idx+1;
			heights.add(p);
		}
		long mn = Long.MAX_VALUE, mx = Long.MIN_VALUE;
		while(!heights.isEmpty()) {
			Pair p = heights.poll();
			mn = Math.min(mn, p.val);
			mx = Math.max(mx, p.val);
		}
		if(mx-mn>x) {
			out.println(""NO"");
			return;
		}
		out.println(""YES"");
		out.printlnArray(ans);
	}
	static class Pair implements Comparable<Pair>{
		int idx;
		long val;
		public Pair(int idx, long val) {
			this.idx = idx;
			this.val = val;
		}
		public String toString() {
			return this.idx+"" ""+this.val;
		}
		
	}
	public static void main(String[] args) {
		in = new Reader();
		out = new Writer();
		int t = in.nextInt();
		while(t-->0) solve();
		out.exit();
	}
	static Reader in; static Writer out;



static class Util{
		private static Random random = new Random();
		static long[] fact;
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	    
	    
	    
	    
	    
	    
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
	    
		
		
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}


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

public class Solution {

	static Scanner scn = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static StringBuilder sb = new StringBuilder();

	public static void main(String[] HastaLaVistaLa) {
		int t = scn.nextInt();
		while(t-- > 0) solve();
		out.println(sb);
		out.close();
	}

	public static void solve() {
		// Road To Specialist Day 3
		int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
		int[] a = new int[n], ans = new int[n];
		for(int i = 0; i < n; i++) a[i] = scn.nextInt();
		PriorityQueue<Pair> pq = new PriorityQueue<>();
		for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
		for(int i = 0; i < n; i++) {
			int e = a[i];
			Pair p = pq.poll();
			p.value += e;
			pq.add(p);
			ans[i] = p.id + 1;
		}
		boolean check = false;
		long prev = pq.poll().value;
		while(!pq.isEmpty()) {
			long cur = pq.poll().value;
			if(Math.abs(cur - prev) > x) check = true;
			prev = cur;
		}
		if(check) sb.append(""NO"");
		else {
			sb.append(""YES\n"");
			for(int i : ans) sb.append(i + "" "");
		}
		sb.append(""\n"");
	}
	static class Pair implements Comparable<Pair> {
		int id;
		long value;
		public Pair(long value, int id) {
			this.id = id;
			this.value = value;
		}
		
	}
}
",0,Non-plagiarised
07a0e4dc,bac616ee,"import java.io.*;
import java.util.*;

public class C_NotAssigning_1400 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while(t-->0) {
            int n = sc.nextInt();
            boolean[] visited = new boolean[n];
            ArrayList<Edge>[] adj = new ArrayList[n];
            for(int i = 0; i < n; i++) {
                adj[i] = new ArrayList<>();
            }
            for(int i = 0; i < n-1; i++) {
                int a = sc.nextInt()-1;
                int b = sc.nextInt()-1;
                adj[a].add(new Edge(b, i));
                adj[b].add(new Edge(a, i));
            }
            int start = -1;
            boolean flag = false;
            for(int i = 0; i < n; i++) { //start from leaf node
                if(adj[i].size() == 1) {
                    start = i;
                } else if(adj[i].size() > 2) {
                    flag = true;
                }
            }
            int[] weights = new int[n-1];
            Queue<Integer> que = new LinkedList<>();
            que.offer(start);
            visited[start] = true;
            int curDist = 0;
            while(!que.isEmpty()) {
                int cur = que.poll();
                for(Edge e : adj[cur]) {
                    if(!visited[e.to]) {
                        visited[e.to] = true;
                        que.offer(e.to);
                        if(curDist%2 == 0) {
                            weights[e.index] = 2;
                        } else {
                            weights[e.index] = 3;
                        }
                    }
                }
                curDist++;
            }
            if(flag) {
                System.out.println(-1);
            } else {
                StringBuilder sb = new StringBuilder();
                for(int i = 0; i < n-1; i++){
                    sb.append(weights[i] + "" "");
                }
                System.out.println(sb.toString().trim());
            }

        }

        out.close();
    }
    static class Edge{
        public int to;
        public int index;
        Edge(int to, int index){
            this.to = to;
            this.index = index;
        }
    }

    public static PrintWriter out;

    

}
","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
13860c31,870e16d9,"import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.InputMismatchException;

/**
 * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
 */

public class Main {
   static InputReader sc=new InputReader(System.in);
   public static void main(String[] args) {
      // Write your solution here
      int t=sc.nextInt();
      while(t-->0){
         solve();
      }

   }

   private static void solve() {
      int n=sc.nextInt();
      char[] a=sc.nextLine().toCharArray();
      char[] b = sc.nextLine().toCharArray();
      int sml=0,nsml=0;
      boolean flag=false;
      int sm1=0;
      int nsm1=0;
      for(int i=0;i<n;i++){
         if(a[i]==b[i]){
            sml++;
            if(a[i]=='1')sm1++;
         }else {
            if (a[i] == '1') nsm1++;
            nsml++;
         }
      }
      int d1=sml-2*sm1;
      int d2=nsml-2*nsm1;
      int ans=-1;
      if(sml%2==1&&nsml%2==1&&d1==-1){
         ans=sml;
      }else if(sml%2==0&&nsml%2==0&&d2==0){
         ans=nsml;
      }else if(sml%2==1&&nsml%2==0&&(d1==-1||d2==0)){
         if(d1==-1&&d2!=0){
            ans=sml;
         }else if(d1!=-1&&d2==0){
            ans=nsml;
         }else if(d1==-1&&d2==0){
            ans=Math.min(sml,nsml);
         }
      }
      if(sml==n)ans=0;
      System.out.println(ans);
   }
}

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

public class CF1 {
    public static void main(String[] args) {
        FastScanner sc=new FastScanner();
        int T=sc.nextInt();
//        int T=1;
        for (int tt=0; tt<T; tt++){
           int n =sc.nextInt();
           String a = sc.next();
           String b= sc.next();
           int candles1=0;
           int candles2=0;
           int inPlace=0;
           for (int i=0; i<n; i++){
               if (a.charAt(i)=='1'){
                   candles1++;
               }
               if (b.charAt(i)=='1') candles2++;
               if (b.charAt(i)=='1' && a.charAt(i)=='1') inPlace++;
           }
           if (candles1==candles2 || n+1-candles2==candles1){
             int ans=Math.min(help(candles1-inPlace, inPlace,n+1,candles2,0,0), help(candles1-inPlace, inPlace,n+1,candles2,0,1));
             if (ans==Integer.MAX_VALUE) System.out.println(-1);
             else System.out.println(ans);
           }
           else System.out.println(-1);
        }
    }
    static int help(int i, int j, int max, int cands, int moves, int flip){
        if (j==cands && i==0) return moves;
        else if (j==0 && flip==0 || flip==1 && i==0 ) return Integer.MAX_VALUE;

            if (flip==0){
                int x=0;
                int y=cands-j+1;
                if (i+j==max-cands){
                    x=cands-y;
                }
                else x=max-cands-y;
                return help(x,y,max,cands,moves+1,1);
            }
            else {
                int x=0;
                int y=cands-j;
                if (i+j==max-cands){
                    x=cands-y;
                }
                else x=max-cands-y;
                return help(x,y,max,cands,moves+1,0);
            }
        
    }
    static long mod =998244353L;
    

    
    
    
    

    
    
}
",0,Non-plagiarised
213340b3,870e16d9,"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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class CF1 {
    public static void main(String[] args) {
        FastScanner sc=new FastScanner();
        int T=sc.nextInt();
//        int T=1;
        for (int tt=0; tt<T; tt++){
           int n =sc.nextInt();
           String a = sc.next();
           String b= sc.next();
           int candles1=0;
           int candles2=0;
           int inPlace=0;
           for (int i=0; i<n; i++){
               if (a.charAt(i)=='1'){
                   candles1++;
               }
               if (b.charAt(i)=='1') candles2++;
               if (b.charAt(i)=='1' && a.charAt(i)=='1') inPlace++;
           }
           if (candles1==candles2 || n+1-candles2==candles1){
             int ans=Math.min(help(candles1-inPlace, inPlace,n+1,candles2,0,0), help(candles1-inPlace, inPlace,n+1,candles2,0,1));
             if (ans==Integer.MAX_VALUE) System.out.println(-1);
             else System.out.println(ans);
           }
           else System.out.println(-1);
        }
    }
    static int help(int i, int j, int max, int cands, int moves, int flip){
        if (j==cands && i==0) return moves;
        else if (j==0 && flip==0 || flip==1 && i==0 ) return Integer.MAX_VALUE;

            if (flip==0){
                int x=0;
                int y=cands-j+1;
                if (i+j==max-cands){
                    x=cands-y;
                }
                else x=max-cands-y;
                return help(x,y,max,cands,moves+1,1);
            }
            else {
                int x=0;
                int y=cands-j;
                if (i+j==max-cands){
                    x=cands-y;
                }
                else x=max-cands-y;
                return help(x,y,max,cands,moves+1,0);
            }
        
    }
    static long mod =998244353L;
    

    
    
    
    

    
    
}
",0,Non-plagiarised
0e68e463,29cf2e70,"import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = in.nextInt();
        for(int tt = 0; tt < t; tt++) {
            int n = in.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) arr[i] = in.nextLong();
            char[] s = in.next().toCharArray();
            if (solve(arr, n, s))pw.println(""YES"");
            else pw.println(""NO"");
        }
        pw.close();
    }
    static boolean solve(long[] arr, int n, char[] s) {
        ArrayList<Long> B = new ArrayList<>();
        ArrayList<Long> R = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            if (s[i] == 'B') B.add(arr[i]);
            else R.add(arr[i]);
        }
        Collections.sort(B);
        Collections.sort(R);
      //  debug(B);
        long last = n;
        for (int i = R.size() - 1; i >= 0; i--) {
            long v = R.get(i);
            if (v > last) {
               return false;
            }
            last--;
        }
        long first = 1;
        int size = B.size();
        for (int i = 0; i < size; i++) {
            long v = B.get(i);
         //   debug(v, first);
            if (v < first) return false;
            first++;
        }
        return true;
    }


    
}
","import java.util.*;
import java.io.*;
 
public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();
 
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }
 
            Collections.sort(blue);
            Collections.sort(red);
 
            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
",0,Non-plagiarised
28c2d81a,48c5f745,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

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

        }
    }





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

}
",1,Plagiarised
558df7d4,d8654140,"import java.io.*;
import java.util.*;
public class Pupsen {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i=0; i<n; i++) {
				a[i] = in.nextInt();
			}
			int[] b = new int[n];
			if (n%2==0) {
				for (int i=0; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			else {
				if (a[0]+a[1]!=0) {
					b[0] = -a[2];
					b[1] = -a[2];
					b[2] = a[0]+a[1];
				}
				else if (a[0]+a[2]!=0) {
					b[0] = -a[1];
					b[2] = -a[1];
					b[1] = a[0]+a[2];
				}
				else {
					b[1] = -a[0];
					b[2] = -a[0];
					b[0] = a[1]+a[2];
				}
				for (int i=3; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			System.out.println();
		}
	}
	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;


 
public class Codeforces {
	
	static int mod=1000000007 ;
	static List<Integer>[] adj;
	static boolean vst[];
	static int dp[];
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
		FastScanner fs=new FastScanner();
		int t=fs.nextInt();
		while(t-->0) {
			int n=fs.nextInt();
			int arr[]=fs.readArray(n);
			int ans[]=new int[n];
			if(n%2==0) {
				for(int i=0;i<n;i+=2) {
					ans[i]=-arr[i+1];
					ans[i+1]=arr[i];
				}
			}
			else {
				for(int i=3;i<n;i+=2) {
					ans[i]=-arr[i+1];
					ans[i+1]=arr[i];
				}
				int a=0, b=0, c=0;
				outer:for(int i=0;i<3;i++) {
					for(int j=i+1;j<3;j++) {
						if(arr[i]+arr[j]!=0) {
							b=i;
							c=j;
							a= 3-c-b;
							break outer;
						}
					}
				}
				ans[a]=arr[b]+arr[c];
				ans[b]=-arr[a];
				ans[c]=-arr[a];
			}
			for(int i=0;i<n;i++) {
				out.print(ans[i]+"" "");
			}
			out.println();
//			long sum=0;
//			for(int i=0;i<n;i++) {
//				sum+=arr[i]*ans[i];
//			}
//			if(sum!=0) System.out.println(false);
		}
		out.close();
		
	}
	
	
	
	
	
	
	
	
	
	
	// Use this to input code since it is faster than a Scanner
	
 
}
",0,Non-plagiarised
3a12e509,47310b0e,"import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
","import java.io.*;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) throws IOException{
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            int t = Integer.parseInt(br.readLine());
            while (t-- > 0) {
                int n = Integer.parseInt(br.readLine());
                String[] s = br.readLine().split("" "");
                String c = br.readLine();

                ArrayList<Integer> blue = new ArrayList<>();
                ArrayList<Integer> red = new ArrayList<>();
                
                for (int i = 0; i < n; i++) {
                    if (c.charAt(i) == 'B') blue.add(Integer.parseInt(s[i]));
                    else
                        red.add(Integer.parseInt(s[i]));
                }

                Collections.sort(blue);
                Collections.sort(red);
                int p1 = 0, p2 = 0, num = 1, flag = 1;
                while (num <= n) {
                    if (p1 < blue.size()) {
                        if (blue.get(p1) < num) {
                            flag = 0;
                            break;
                        }
                        p1++;
                    }
                    else if (p2 < red.size()) {
                        if (red.get(p2) > num) {
                            flag = 0;
                            break;
                        }
                        p2++;
                    }
                    num++;
                }
                if (flag == 1)  System.out.println(""YES"");
                else
                    System.out.println(""NO"");
            }
        }
    }
}
",0,Non-plagiarised
4241f473,77448a05,"import java.io.*;
import java.util.*;

public class C {
	
	public static void main(String[] args)throws IOException {
		
		FastScanner scan = new FastScanner();
		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		int t = scan.nextInt();
		for(int tt = 0;tt<t;tt++) {
			
			int n = scan.nextInt();
			ArrayList<String> arr = new ArrayList<>();
			for(int i = 0;i<n;i++) arr.add(scan.next());
			int max = -1;
			for(int cases = 0;cases<5;cases++) {
				ArrayList<Integer> list = new ArrayList<>();
				char ch = (char)('a'+cases);
				for(int i = 0;i<n;i++) {
					String s = arr.get(i);
					int countch = 0, countTotal = 0;
					for(int j = 0;j<s.length();j++) {
						if(s.charAt(j)==ch) countch++;
						else countTotal++;
					}
					list.add(countch-countTotal);
				}
				Collections.sort(list);
				int sum = 0, count = 0;
				for(int i = n-1;i>=0;i--) {
					sum+=list.get(i);
					if(sum>0) count++;
					else break;
				}
				max = Math.max(max, count);
			}
			output.write(max+""\n"");
		}
		output.flush();

	}

	public static int[] sort(int arr[]) {

		List<Integer> list = new ArrayList<>();
		for(int i:arr)
			list.add(i);
		Collections.sort(list);
		for(int i = 0;i<list.size();i++) {
			arr[i] = list.get(i);
		}
		return arr;

	}
	
	
	
	

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.StringTokenizer;

public class P4 {
	static int N = 1000001;

	// Array to store inverse of 1 to N
	static long[] factorialNumInverse = new long[N + 1];

	// Array to precompute inverse of 1! to N!
	static long[] naturalNumInverse = new long[N + 1];

	// Array to store factorial of first N numbers
	static long[] fact = new long[N + 1];

	// Function to precompute inverse of numbers
	

	// Function to precompute inverse of factorials
	

	// Function to calculate factorial of 1 to N
	

	// Function to return nCr % p in O(1) time
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader sc = new FastReader();
		int t;
		t = sc.nextInt();
		StringBuilder st = new StringBuilder();
//		int p = 998244353;
//	    InverseofNumber(p);
//	    InverseofFactorial(p);
//	    factorial(p);
		// System.out.println(3|1);
		while (t-- != 0) {
			int n=sc.nextInt();
			String s[]=new String[n];
			for(int i=0;i<n;i++) {
				s[i]=sc.nextLine();
			}
			int max=0;
			ArrayList<Integer> freq=new ArrayList<>();
			for(int i=0;i<5;i++) {
				int f1=0;
				freq=new ArrayList<>();
				for(int j=0;j<n;j++) {
					f1=0;
					for(int k=0;k<s[j].length();k++) {
						if(s[j].charAt(k)==i+'a') {
							f1++;
						}else {
							f1--;
						}
					}
					freq.add(f1);
				}
				Collections.sort(freq);
				int x=0;
				int total=0;
				for(int j=n-1;j>=0;j--) {
					total=total+freq.get(j);
					if(total>0) {
						x++;
					}else {
						break;
					}
				}
				max=Math.max(max, x);
			}
			st.append(max+""\n"");
		}
		System.out.println(st);
	}

	static FastReader sc = new FastReader();

	

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

	

	
}
",1,Plagiarised
46bde295,8a858867,"import java.io.*;
import java.util.Arrays;

public class C {
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    private static int nextInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) in.nval;
    }
    
    private static String next(){
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return in.sval;
    }

    public static void main(String[] args) {
        int t = nextInt();
        for (int c = 0; c < t; c++) {
            int n = nextInt();
            String[] info = new String[n];
            for (int i = 0; i < n; i++) {
                info[i] = next();
            }
            int ans = 0;
            for (int i = 0; i < 5; i++) {
                char cur = (char) (i+'a');
                int[] map = new int[n];
                for (int j = 0; j < n; j++) {
                    for (int k = 0; k < info[j].length(); k++) {
                        if(info[j].charAt(k)==cur)map[j]++;
                        else map[j]--;
                    }
                }
                Arrays.sort(map);
                int sum = 0;
                for(int j = n-1; j >= 0; j--) {
                    sum += map[j];
                    if(sum<=0){
                        break;
                    }
                    ans = Math.max(ans,n-j);
                }
            }
            System.out.println(ans);
        }
    }
}
","import java.io.*;
import java.util.*;
 
 
public class Mainnn{
    // static final File ip = new File(""input.txt"");
    // static final File op = new File(""output.txt"");
    // static {
    //     try {
    //         System.setOut(new PrintStream(op));
    //         System.setIn(new FileInputStream(ip));
    //     } catch (Exception e) {
    //     }

    //     // in = new InputReader(System.in);
    // }



   public static void main(String[] args) {
      MyScanner sc = new MyScanner();
      out = new PrintWriter(new BufferedOutputStream(System.out));
      
      //out.println(result);                    // print via PrintWriter
      /////////////////////////////////////////////

        int test = sc.nextInt();
        while(test-- != 0)
        {
            int n = sc.nextInt();
            String[] info = new String[n];
            for (int i = 0; i < n; i++) {
                info[i] = sc.next();
            }
            int ans = 0;
            for (int i = 0; i < 5; i++) {
                char cur = (char) (i+'a');
                int[] map = new int[n];
                for (int j = 0; j < n; j++) {
                    for (int k = 0; k < info[j].length(); k++) {
                        if(info[j].charAt(k)==cur)map[j]++;
                        else map[j]--;
                    }
                }
                Arrays.sort(map);
                int sum = 0;
                for(int j = n-1; j >= 0; j--) {
                    sum += map[j];
                    if(sum<=0){
                        break;
                    }
                    ans = Math.max(ans,n-j);
                }
            }
            System.out.println(ans);
        }





      /////////////////////////////////////////////
      // Stop writing your solution here. -------------------------------------
      out.close();
   }
   
   

   //-----------PrintWriter for faster output---------------------------------
   public static PrintWriter out;
      
   //-----------MyScanner class for faster input----------
   
   //--------------------------------------------------------
}
",1,Plagiarised
80881cae,9555b9d1,"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;			
//		}
	}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int T = in.nextInt();
            while (T-- > 0) {
                solveOne(in, out);
            }
        }

        private void solveOne(Scanner in, PrintWriter out) {
            int N = in.nextInt();
            int[] k = L.readIntArray(N, in), h = L.readIntArray(N, in);
            Set<Integer> toRemove = new HashSet<>();

            int prevCost = h[0], prevX = k[0];
            for (int i = 1; i < N; i++) {
                for (int j = i; j < N; j++) {
                    int currCost = h[j], currX = k[j];
                    if (currX - currCost + 1 <= prevX) {
                        if (prevCost + (currX - prevX) > h[j]) h[j] = prevCost + (currX - prevX);
                    }
                }
                prevX = k[i];
                prevCost = h[i];
            }

            int nextCost = h[N - 1], nextX = k[N - 1];
            for (int i = N - 2; i >= 0; i--) {
                int currCost = h[i], currX = k[i];
                if ((nextCost - currCost) >= (nextX - currX)) {
                    toRemove.add(i);
                    continue;
                }
                nextCost = currCost;
                nextX = currX;
            }
            long cost = 0;
            for (int i = N - 1; i >= 0; i--)
                if (!toRemove.contains(i)) cost += (h[i] * ((long) h[i] + 1)) / 2;
            out.println(cost);
        }

    }

    static class L {
        public static int[] readIntArray(int size, Scanner in) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = in.nextInt();
            }
            return array;
        }

    }
}
",0,Non-plagiarised
6f02c6d9,884f5678,"import java.io.*;
import java.util.*;

public class Main {


    static long mod = 1000000007;

    

    

    static 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.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;
	}
	
	
	
		
}
",1,Plagiarised
1a31f5cb,dc575a6c,"import java.util.*;
import java.io.*;

public class Solution
{
    
    
    static void dfs(int n , LinkedList<Integer> g[] , int arr[][] , int p , long dp[][])
    {
        for(Integer i : g[n])
        {
            if(i != p)
            {
                dfs(i,g,arr,n,dp);
            dp[n][0] += Math.max(dp[i][0]+Math.abs(arr[n][0]-arr[i][0]) , 
                       dp[i][1]+Math.abs(arr[n][0]-arr[i][1]));
                       
                 
            dp[n][1] += Math.max(dp[i][0]+Math.abs(arr[n][1]-arr[i][0]) , 
                       dp[i][1]+Math.abs(arr[n][1]-arr[i][1]));
            }                
        }
    }
    public static void main(String []args) throws IOException
    {
        Reader sc = new Reader();
        StringBuffer str = new StringBuffer("""");
        int t  = sc.nextInt();
        while(t-- > 0)
        {
            int n = sc.nextInt();
            int arr[][] = new int[n][2];
            for(int i = 0 ; i < n;  i++)
            {
                arr[i][0] = sc.nextInt();
                arr[i][1] = sc.nextInt();
            }
            LinkedList<Integer> g[] = new LinkedList[n];
            for(int i = 0 ; i < n ; i++)
            {
                g[i] = new LinkedList<Integer>();
            }
            for(int i = 0 ; i < n-1 ; i++)
            {
                int x = sc.nextInt()-1;
                int y = sc.nextInt()-1;
                g[x].add(y);
                g[y].add(x);
            }
            long dp[][] = new long[n][2];
            dfs(0,g,arr,-1 , dp);
            str.append(Math.max(dp[0][0] , dp[0][1]));
            str.append(System.lineSeparator());
        }
        System.out.println(str);
    }
}
","import java.util.*;
import java.io.*;
public class Main {
    static long[][]dp;
    static ArrayList<Integer>[]adj;
    static int[][]arr;
    
    public static void main(String[] args) {
        FastScanner sc=new FastScanner();
        int t=sc.nextInt();
        while(t-->0){
            int n=sc.nextInt();
            arr=new int[n][2];
            adj=new ArrayList[n];
            for(int i=0;i<n;i++){
                arr[i][0]=sc.nextInt();
                arr[i][1]=sc.nextInt();
                adj[i]=new ArrayList<>();
            }
            for(int i=0;i<n-1;i++){
                int a=sc.nextInt()-1;
                int b=sc.nextInt()-1;   
                adj[a].add(b);
                adj[b].add(a);
            }
            dp=new long[n][2];
            dfs(0,-1);
            System.out.println(Math.max(dp[0][0],dp[0][1]));
        }
    }
    public static void dfs(int v,int parent){
        for(int u:adj[v]){
            if(u!=parent){
                dfs(u,v);
            }
        }
        long ans1=0;
        long ans2=0;
        for(int u:adj[v]){
            if(u!=parent){
                long a=Math.abs(arr[v][0]-arr[u][0])+dp[u][0];
                long b=Math.abs(arr[v][0]-arr[u][1])+dp[u][1];
                long a1=Math.abs(arr[v][1]-arr[u][0])+dp[u][0];
                long b1=Math.abs(arr[v][1]-arr[u][1])+dp[u][1];
                ans1+=Math.max(a,b);
                ans2+=Math.max(a1,b1);
            }
        }
        dp[v][0]=ans1;
        dp[v][1]=ans2;
    }
}
",0,Non-plagiarised
ccc8ef27,f7a0ea6d,"import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
","import java.util.*;

public class Solution {
	
	private static Scanner in = new Scanner(System.in);
	
	public static void main(String args[]) {
		
		int t = in.nextInt();
		
		while(t-->0) {
			solution();
		}
	}
	
	private static void solution() {
		
		int ans=0;
		int n = in.nextInt();
		String s[] = new String[n];
		int occurance[][] = new int[n][5];
		for(int i=0;i<n;i++) {
			s[i] = in.next();
			for(int j=0;j<s[i].length();j++) {
				occurance[i][s[i].charAt(j)-'a']++;
			}
		}
		
//		for(int i=0;i<n;i++)
//		{
//			for(int j=0;j<5;j++)
//				System.out.println(occurance[i][j]);
//			System.out.println();
//		}
		
		for(int i=0;i<5;i++) {
			int arr[] = new int[n];
			for(int j=0;j<n;j++) {
				arr[j] = s[j].length() - (2 * occurance[j][i]);
			}
			Arrays.sort(arr);
			
//			for(int j=0;j<n;j++)
//				System.out.println(arr[j]);
			
			int temp=0;
			int count=0;
			for(int j=0;j<n;j++) {
				if(temp+arr[j] < 0)
				{
					count++;
					temp += arr[j];
				}
				else 
					break;
			}
			ans = Math.max(ans, count);
		}
		System.out.println(ans);
	}
}
",0,Non-plagiarised
9ab3c0e1,d5fa4746,"import java.util.*;

public class d {

    public static Scanner sc = new Scanner(System.in);
    public static final int MOD = 998244353;
    int []f; int [] lf;

    public static int mul(int a, int b) {
        return (int)((long)a * (long)b % MOD);
    }

    public static int ksm(int a, int n) {
        int ans = 1;
        while(n > 0) {
            if((n & 1) == 1)
                ans = mul(a, ans);
            a = mul(a, a);
            n >>= 1;
        }
        return ans;
    }

    public int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
    }

    public static int inv(int a) {
        return ksm(a, MOD - 2);
    }

    public void solve() {
        int n = sc.nextInt();
        int k = sc.nextInt();
        f = new int[n + 42];
        lf = new int[n + 42];
        f[0] = lf[0] = 1;
        for(int i = 1; i < f.length; i++) {
            f[i] = mul(f[i  - 1], i);
            lf[i] = mul(lf[i - 1], inv(i));
        }

        int[] events = new int[2 * n];
        for(int i = 0; i < n; i++) {
            int le = sc.nextInt();
            int ri = sc.nextInt();
            events[i] = le * 2;
            events[i + n] = ri * 2 + 1;
        }

        Arrays.sort(events);
        int ans = 0, balance = 0;
        for(int r = 0; r < 2 * n;) {
            int l = r;
            while(r < 2 * n && events[l] == events[r]) ++r;
            int added = r - l;
            if(events[l] % 2 == 0) {
                ans += C(balance + added, k);
                if(ans >= MOD) ans -= MOD;
                ans += MOD - C(balance, k);
                if(ans >= MOD) ans -= MOD;
                balance += added;
            }
            else balance -= added;
        }
        sc.close();
        System.out.println(ans);
    }

    public static void main(String[] args) {
        (new d()).solve();
    }
}
","import java.lang.*;
import java.util.*;
import java.io.*;

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

    static final int MOD = 998244353;
    static int n, k;
    static int[] fact, invFact;

    static int mul(int a, int b) {
        return (int)((long)a * (long)b % MOD);
    }

    static int pow(int a, int p) {
        int ans = 1;
        while (p != 0) {
            if ((p & 1) != 0)
                ans = mul(ans, a);
            a = mul(a, a);
            p >>= 1;
        }
        return ans;
    }

    static int inv(int a) {
        return pow(a, MOD - 2);
    }

    static void precalc() {
        fact = new int[n + 42]; invFact = new int[n + 42];
        fact[0] = invFact[0] = 1;
        for (int i = 1; i < fact.length; ++i) {
            fact[i] = mul(fact[i - 1], i);
            invFact[i] = mul(invFact[i - 1], inv(i));
        }
    }

    static int nCk(int a, int b) {
        if (b < 0 || a < b)
            return 0;
        return mul(fact[a], mul(invFact[a - b], invFact[b]));
    }

    static void solve() {
        n = in.nextInt(); k = in.nextInt();
        precalc();
        int[] events = new int[2 * n];
        for (int i = 0; i < n; ++i) {
            int l = in.nextInt(), r = in.nextInt();
            events[i] = 2 * l;
            events[i + n] = 2 * r + 1;
        }
        Arrays.sort(events);

        int ans = 0, balance = 0;
        for (int r = 0; r < 2 * n;) {
            int l = r;
            while (r < 2 * n && events[l] == events[r])
                ++r;
            int added = r - l;

            if (events[l] % 2 == 0) {
                ans += nCk(balance + added, k);
                if (ans >= MOD) ans -= MOD;
                ans += MOD - nCk(balance, k);
                if (ans >= MOD) ans -= MOD;
                balance += added;
            } else
                balance -= added;
        }
        System.out.println(ans);
    }

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

    
}


",1,Plagiarised
47d54299,63bfa731,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class a {

   static int depth[];
   static ArrayList<Integer> tree[];
   static int diameter=0;

    public static void main(String[] args) {
        FastReader input=new FastReader();
        int t=input.nextInt();
        while (t-->0){
            diameter=0;
            int n=input.nextInt();
            int a=input.nextInt();
            int b=input.nextInt();
            int da=input.nextInt();
            int db=input.nextInt();
            depth=new int[n+1];
            tree=new ArrayList[n+1];
            for (int i = 0; i <=n ; i++) {
                tree[i]=new ArrayList<>();
            }
            for (int i = 0; i <n-1 ; i++) {
                int x=input.nextInt();
                int y=input.nextInt();
                tree[x].add(y);
                tree[y].add(x);
            }
            dfs(a,0);
//            System.out.println(depth[b]);
            if (2 * da >= Math.min(diameter, db) ||depth[b]<=da){
                System.out.println(""Alice"");
            }else {
                System.out.println(""Bob"");
            }



       }

    }

    private static int dfs(int root, int p) {
        int len=0;

        for(int child:tree[root]){
            if (child!=p){
                depth[child]=depth[root]+1;

                int curr=1+dfs(child,root);
                diameter=Math.max(diameter,curr+len);
                len=Math.max(len,curr);

            }
        }
        return len;

    }
    

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

    
}
",1,Plagiarised
e185bce5,f3d7ce08,"import java.util.*;

import java.io.*;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
	
public class Main {
		private static FS sc = new FS();
		
		
		
		
		
		static int mod = (int) 1e9;
		
		static LinkedList<Integer>[] temp, idx;
		static long inf = (long) Long.MAX_VALUE;
//		static long inf = Long.MAX_VALUE;
//		static int max;
		
		public static void main(String[] args) { 
			int t = sc.nextInt();
//			int t = 1;
			StringBuilder ret = new StringBuilder();
			while(t-- > 0) {
				int n = sc.nextInt();
				String a = sc.next(), b = sc.next();
				int _00 = 0, _01 = 0, _10 = 0, _11 = 0;
				for(int i = 0; i < n; i++) {
					if(a.charAt(i) == '0' && b.charAt(i) == '0') _00++;
					if(a.charAt(i) == '0' && b.charAt(i) == '1') _01++;
					if(a.charAt(i) == '1' && b.charAt(i) == '0') _10++;
					if(a.charAt(i) == '1' && b.charAt(i) == '1') _11++;
				}
				int ans = Integer.MAX_VALUE;
				if(_10 == _01) ans = _01 + _10;
				if(_10 > 0) {
					int n00 = _10 - 1;
		            int n01 = _11;
		            int n10 = _00 + 1;
		            int n11 = _01;
		            if (n01 == n10) {
		                ans = Math.min(ans, 1 + n01 + n10);
		            }
				}
				if(_11 > 0) {
					int n00 = _10;
		            int n01 = _11 - 1;
		            int n10 = _00;
		            int n11 = _01 + 1;
		            if (n01 == n10) {
		                ans = Math.min(ans, 1 + n01 + n10);
		            }
				}
				ret.append(ans == Integer.MAX_VALUE ? -1 : ans);
				ret.append(""\n"");
			}
			System.out.println(ret);
		}

	}
","import javax.swing.plaf.IconUIResource;
import java.lang.reflect.Array;
import java.text.CollationElementIterator;
import java.util.*;
import java.io.*;
 
//Timus judge id- 323935JJ
 
 
public class Main {
 
 
 
 
    //----------------------------------------------------------------------------------------------
    
 
 
    public static int mod = (int) (1e9 + 7);
    static int ans = Integer.MAX_VALUE;
 
    public static void main(String hi[]) throws Exception {
        FastReader sc = new FastReader();
        int t =sc.nextInt();
        while(t-->0)
        {
            int n =sc.nextInt();
            String a = sc.nextLine(),b=sc.nextLine();
 
            int count1=0,count2=0,count3=0,count4=0;
 
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
                    count1++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
                    count2++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
                    count3++;
                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
                    count4++;
            }
            int ans=Integer.MAX_VALUE;
 
            if(count3==count4)
                ans=Math.min(count3*2,ans);
 
            if(count2==count1+1)
                ans=Math.min(ans,2*count1+1);
 
           
            if(ans==Integer.MAX_VALUE)
                System.out.println(-1);
            else System.out.println(ans);
 
        }
 
    }
 
    
 
 
 
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
}
",0,Non-plagiarised
2a35cd81,464ad4dd,"import java.util.*;
import java.io.*;
public class Transform_the_experssion  {
	static Scanner sc=new Scanner(System.in);
	static PrintWriter pw=new PrintWriter(System.out);
	static ArrayList<Integer> []arr;
	
	public static void main(String[] args) throws IOException, InterruptedException {
       int t=sc.nextInt();
       while(t-->0) {
           int n=sc.nextInt();
           String [] strings=new String [n];
           int [][]arr=new int [5][n];
           int [] total=new int [5];
           for(int i=0;i<n;i++)
        	   strings[i]=sc.next();
           for(int i=0;i<5;i++) {
        	   char x=(char)('a'+i);
        	   for(int j=0;j<n;j++) {
        		   int sum=0;
        		   int end=strings[j].length();
        		   for(int k=0;k<end;k++) {
        			   if(strings[j].charAt(k)==x) {
        				   sum++;
        			   }
        		   }
        		   arr[i][j]=sum-(end-sum);
        		   total[i]+=sum-(end-sum);
        	   }
           }
           boolean f=false;
           for(int i=0;i<5 && !f;i++) {
        	   if(total[i]>0) {
        		   pw.println(n);
        		   f=true;
        	   }
           }
           //pw.println(Arrays.toString(total));
           if(!f) {
        	   int [] MaxS=new int [5];
        	   for(int i=0;i<5;i++) {
        			Arrays.sort(arr[i]);
        			if(arr[i][n-1]<=0)   {
        				 MaxS[i]=0; 
        			}
        			else {
						int sum=arr[i][n-1],countWords=1;
						for(int j=n-2;j>-1 && sum+arr[i][j]>0;j--) {
							sum+=arr[i][j];
							countWords++;
						}
						 MaxS[i]=countWords;
					}
        	   }
        	   int ans=0;
        	   //pw.println(Arrays.toString(MaxS));
               for(int i=0;i<5;i++)
            	   ans=Math.max(ans, MaxS[i]);
               pw.println(ans);
           }
           
    }
    
    
    pw.flush();
	}
	/*public class UnionFind {                                              
		int[] p, rank, setSize;
		int numSets;

		public UnionFind(int N) 
		{
			p = new int[numSets = N];
			rank = new int[N];
			setSize = new int[N];
			for (int i = 0; i < N; i++) {  p[i] = i; setSize[i] = 1; }
		}

		public int findSet(int i) { return p[i] == i ? i : (p[i] = findSet(p[i])); }

		public boolean isSameSet(int i, int j) { return findSet(i) == findSet(j); }

		public void unionSet(int i, int j) 
		{ 
			if (isSameSet(i, j)) 
				return;
			numSets--; 
			int x = findSet(i), y = findSet(j);
			if(rank[x] > rank[y]) { p[y] = x; setSize[x] += setSize[y]; }
			else
			{	p[x] = y; setSize[y] += setSize[x];
				if(rank[x] == rank[y]) rank[y]++; 
			} 
		}

		public int numDisjointSets() { return numSets; }

		public int sizeOfSet(int i) { return setSize[findSet(i)]; }
	}
	static class pair implements Comparai)ble<pair> {
		long x;
		long y;
 
		public pair(long x, long y) {
			this.x = x;
			this.y = y;
		}
 
		public String toString() {
			return x + "" "" + y;
		}
 
		public boolean equals(Object o) {
			if (o instanceof pair) {
				pair p = (pair) o;
				return p.x == x && p.y == y;
			}
			return false;
		}
 
		public int hashCode() {
			return new Double(x).hashCode() * 31 + new Double(y).hashCode();
		}
 
		public int compareTo(pair other) {
			if (this.x == other.x) {
				return Long.compare(this.y, other.y);
			}
			return Long.compare(this.x, other.x);
		}
	}*/
	
 
}
","import java.io.*;
import java.util.*;
public class Solution{
    public static int in = 0, count=0;
    static class comparator implements Comparator<int[]>{
        
    }
    public static int solve(ArrayList<int[]> al, int[] total){
        ArrayList<int[]> c = (ArrayList<int[]>) al.clone();
        java.util.Collections.sort(c, new comparator());

        int i= al.size()-1;
        int sum=0; for(int ii:total) sum+=ii;
        int check = total[in];
        sum-=check;
        for(; i>=0; i--){
            if(check>sum) return i+1;
            else{
                int newSum=0; for(int ii:c.get(i)) newSum+=ii;
                newSum-=c.get(i)[in];
                sum-=newSum;
                check-=c.get(i)[in];
            }
        }
        return 0;
    }
    public static void main (String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        int testCase = sc.nextInt();
        while (testCase-->0){
            int n = sc.nextInt();
            String[] strArr = new String[n];
            for(int i=0; i<n; i++) {
                strArr[i]=sc.nextLine();
            }
            int[] total = new int[5];
            ArrayList<int[]> al = new ArrayList<>();
            for(int i=0; i<n; i++){
                int[] arr= new int[5];
                for(int j=0; j<strArr[i].length(); j++){
                    arr[strArr[i].charAt(j)-'a']++;
                }
                for(int j=0; j<5; j++){
                    total[j]+=arr[j];
                }
                al.add(arr);
            }
            int ans = Integer.MIN_VALUE;
            for(int i=0; i<5; i++) {
                in = i;
                ans = Math.max(solve(al, total), ans);
                count=0;
            }
            System.out.println(ans);
        }
    }
    // Fast Reader Class
    
}
",0,Non-plagiarised
fadc1365,fdd85afb,"import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class a{ 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(),k=s.nextInt();
			int pos[]=s.readArray(k);
			int temp[]=s.readArray(k);
			long ans[]=new long[n];
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++){
				ans[pos[i]-1]=temp[i];
			}
			for(int i=1;i<n;i++){
				ans[i]=Math.min(ans[i-1]+1,ans[i]);
			}
			for(int i=n-2;i>=0;i--){
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for(int i=0;i<n;i++){
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
	
    
	
    
    
    
    
    
    
}
","import java.util.*;

public class Solution{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        long max=(long)1e18;
        StringBuilder sb=new StringBuilder();
        while(t-->0){
            int n=sc.nextInt();
            int k=sc.nextInt();
            long[] ans=new long[n+1];
            long[] tem=new long[n+1];
            int[] item=new int[k];
            
            Arrays.fill(ans,max);
            
            for(int i=0;i<k;i++){
                item[i]=sc.nextInt();
               
            }
            for(int i=0;i<k;i++){
                tem[item[i]]=sc.nextLong();
            }
            for(int i=n;i>=1;i--){
                 if(tem[i]!=0){
                     if(i==n)ans[i]=Math.min(ans[i],tem[i]);
                     else{ ans[i]=Math.min(ans[i],ans[i+1]+1);
                           ans[i]=Math.min(tem[i],ans[i]);
                           
                     }
                 }
                 else{
                     if(i<n)ans[i]=Math.min(ans[i],ans[i+1]+1);
                   
                 }
            }
               for(int i=1;i<=n;i++){
                 if(tem[i]!=0){
                     if(i==1)ans[i]=Math.min(ans[i],tem[i]);
                     else{ ans[i]=Math.min(ans[i],ans[i-1]+1);
                     ans[i]=Math.min(tem[i],ans[i]);
                     }
                 }
                 else{
                     if(i>1)ans[i]=Math.min(ans[i],ans[i-1]+1);
                   
                 }
            }
            for(int i=1;i<=n;i++){
              
                sb.append(ans[i]+"" "");
            }
            sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
",0,Non-plagiarised
1f6b81b1,51151974,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;


public class InterestingStory {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
		int t = sc.nextInt();
//        int t = 1;
        while (t-- != 0) {
            solver.solve(sc, out);
        }
        out.close();

    }

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

    }

    

    

    

    

    


}
","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
034030f3,bf992c91,"import java.util.*;
import java.io.*;

public class D_1525 {
	
	static int INF = (int)1e9;
	static int n, m;
	static int[] full, free;
	static int[][] memo;
	
	public static int dp(int i, int j) {
		if(i == n)
			return 0;
		if(j == m)
			return INF;
		
		if(memo[i][j] != -1)
			return memo[i][j];
		
		return memo[i][j] = Math.min(dp(i, j + 1), Math.abs(free[j] - full[i]) + dp(i + 1, j + 1));
	}
	
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int l = sc.nextInt();
		int[] array = sc.nextIntArray(l);
		
		n = 0;
		for(int i = 0; i < l; i++)
			if(array[i] == 1)
				n++;
		m = l - n;
		
		full = new int[n];
		free = new int[m];
		int ind1 = 0, ind2 = 0;
		for(int i = 0; i < l; i++)
			if(array[i] == 0)
				free[ind2++] = i;
			else
				full[ind1++] = i;
		
		memo = new int[n][m];
		for(int[] i : memo)
			Arrays.fill(i, -1);
		
		pw.println(dp(0, 0));
		pw.flush();
	}

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

public class P1525D {

    public static int[] ones, zeros;

    public static int[][] memo;

    public static void main(String[] args) {

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

    }

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

        if (oi == ones.length) {

            return 0;

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

            return 100000000;

        } else {

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

        }

    }

}
",1,Plagiarised
5b9a0551,db1ef8b3,"import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class Main {

    public static void main(String[] args) {
        FastScanner in=new FastScanner();
        PrintWriter out=new PrintWriter(System.out);
        int t=in.nextInt();
        while(t-->0)
        solve(in,out);
        out.close();
    }
    static void solve(FastScanner in,PrintWriter out){
        int n=in.nextInt();
        long a[]=new long[n];
        for (int i = 0; i < n; i++) {
            a[i]=in.nextLong();
        }
        long odd=Integer.MAX_VALUE,even=Integer.MAX_VALUE;
        even=a[0];
        long sum=a[0];
        long ans=Long.MAX_VALUE;
        for (int i = 1; i < n; i++) {
            if(i%2==0) {
                ans=Math.min(ans,(n-i/2)*a[i] + odd*(n-i/2) +sum);
                even=Math.min(even,a[i]);
            } else {
                ans=Math.min(ans,(n-i/2)*a[i] + even*(n-i/2-1) +sum);
                odd=Math.min(odd,a[i]);
            }
            sum+=a[i];
        }
        out.println(ans);
    }

    

    

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

/**
 *
 * @Har_Har_Mahadev
 */

public class C {

	private static long INF = 2000000000000000000L;

	public static void process() throws IOException {

		int n = sc.nextInt();
		PriorityQueue<Integer> odd = new PriorityQueue<Integer>();
		PriorityQueue<Integer> even = new PriorityQueue<Integer>();
		int arr[] = sc.readArray(n);
		long min = INF;
		long sumOdd = 0;
		long sumEven = 0;
		for (int i = 0; i < n; i++) {
			int x = arr[i];
			if (i % 2 == 0) {
				even.add(x);
				sumEven += x;
			} else {
				odd.add(x);
				sumOdd += x;
			}
			if (i > 0) {
				long ans = 0;
				ans += 1l * even.peek() * (n - (even.size()));
				ans += 1l * odd.peek() * (n - (odd.size()));
				ans += sumOdd + sumEven;
				min = Math.min(ans, min);
			}
		}
		System.out.println(min);
	}

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

	static FastScanner sc;
	static PrintWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new PrintWriter(System.out);
		} else {
			sc = new FastScanner(100);
			out = new PrintWriter(""output.txt"");
		}
		int t = 1;
		t = sc.nextInt();
		while (t-- > 0) {
			process();
		}
		out.flush();
		out.close();
	}

	

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


	

	

	

	

	

	

	

	

	

	

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

	

	

	
}
",0,Non-plagiarised
3e28571b,77b5c134,"import java.io.*;
import java.util.*;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class Ans implements Runnable {

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

	

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

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

	}
		
	
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

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

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

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

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

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


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

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

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

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

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

    public static void main (String[] args) {
        // It happens - Syed Mizbahuddin
        Main sol = new Main();
        int t = 1;
        t = in.nextInt();
        while (t-- != 0) {
            sol.solve();
        }
        System.out.print(out);
    }

    

    

    

    

    

    

    

    

    

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

    static FastReader in;
    static StringBuilder out;
    static PrintStream err;
    final int MAX;
    final int MIN;
    int mod ;
    Main() {
        in = new FastReader();
        out = new StringBuilder();
        MAX = Integer.MAX_VALUE;
        MIN = Integer.MIN_VALUE;
        mod = (int)1e9 + 7;
    }
    

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


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

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

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

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

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

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

            return checkPairs(a, b, index);
        }

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

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

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

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

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

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

    }

    
}
",1,Plagiarised
b2001d68,ba468e1f,"import java.util.*;
import java.lang.*;
import java.io.*;

public class D753 {
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        try {
            // Scanner sc=new Scanner(System.in);
            FastReader sc = new FastReader();
            int t = sc.nextInt();
            while (t-- > 0) {
                int n=sc.nextInt();
                int[] arr=new int[n];
                for(int i=0;i<n;i++){
                    arr[i]=sc.nextInt();
                }
                
                char[] color=sc.next().toCharArray();
                ArrayList<Integer> b=new ArrayList<>();
                ArrayList<Integer> r=new ArrayList<>();
                for(int i=0;i<n;i++){
                    if(color[i]=='B')b.add(arr[i]);
                    else r.add(arr[i]);
                }
                Collections.sort(b);
                Collections.sort(r);
                boolean ok=true;
                int cur=1;
                for(int i:b){
                    if(i>=cur)cur++;
                    else{
                        ok=false;
                        break;
                    }
                    //cur++;
                }
                for(int i:r){
                    if(i<=cur)cur++;
                    else{
                        ok=false;
                        break;
                    }
                }
                if(ok)System.out.println(""YES"");
                else System.out.println(""NO"");
            }
        } catch (Exception e) {
            return;
        }

    }
    

    

    

    

    

    
    

    

    

    

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

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
",0,Non-plagiarised
ac180326,b1e9f1f6,"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;
		}

		

		

	}

	

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class test {

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

		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();
		while (t-- > 0) {
			String[] st = br.readLine().split("" "");
			int n = Integer.parseInt(st[0]);
			int m = Integer.parseInt(st[1]);
			int x = Integer.parseInt(st[2]);

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

			int bcount = n / m;
			int extra = n % m;

			int[] ans = new int[n];
			sort(temp);
			int id = 0;

			int minmax = 0;
			boolean flag = false;
			for (int i = 0; i < bcount; i++) {

				minmax -= temp[id].val;
				for (int j = 0; j < m; j++) {
					ans[temp[id].idx] = j + 1;

					if (j == m) {
						minmax += temp[id].val;
					}
					id++;
				}

				if (minmax > x) {
					sb.append(""NO\n"");
					flag = true;
					break;
				}

			}

			for (int i = 0; i < extra; i++) {
				ans[temp[id].idx] = i + 1;
				id++;
			}

			if (flag == false) {
				sb.append(""YES\n"");
				for (int i = 0; i < n; i++) {
					sb.append(ans[i] + "" "");
				}

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

		}

		System.out.println(sb);
	}

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

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

		
	}

	public static void sort(Pair[] arr) {
		ArrayList<Pair> list = new ArrayList<>();
		for (int i = 0; i < arr.length; i++) {
			list.add(new Pair(arr[i].val, arr[i].idx));
		}

		Collections.sort(list);

		for (int i = 0; i < arr.length; i++) {
			arr[i] = list.get(i);
		}

	}
}
",0,Non-plagiarised
3f939694,54488276,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class Main {
    public static void main(String args[])throws Exception{
        Input sc=new Input();
        StringBuilder sb=new StringBuilder();
        int t=sc.readInt();
        for(int f=0;f<t;f++){
            int n=sc.readInt();
            String str[]=new String[n];
            for(int i=0;i<n;i++){
                str[i]=sc.readString();
            }
            char ch[]={'a','b','c','d','e'};
            int ans=0;
            for(int i=0;i<5;i++){
                char c=ch[i];
                ArrayList<pair> lst=new ArrayList<>();
                int a[]=new int[n];
                for(int j=0;j<n;j++)
                {
                    int count=0;
                    for(int k=0;k<str[j].length();k++){
                        if(str[j].charAt(k)==c)
                            count++;
                    }
                    lst.add(new pair(count,(str[j].length()-count)));
                }
                Collections.sort(lst);
                int s1=0;int s2=0;
//                for(int j=0;j<lst.size();j++){
//                    System.out.println(lst.get(j).a+"" ""+lst.get(j).b);
//                }
//                System.out.println(""--------"");
                int co=0;
                for(int j=0;j<lst.size();j++){
                    int v1=lst.get(j).a;
                    int v2=lst.get(j).b;
                    if((s1+v1)>(s2+v2)){
                        s1+=v1;
                        s2+=v2;
                        co++;
                    }
                    //System.out.println(lst.get(j).a+"" ""+lst.get(j).b);
                }
                ans=Math.max(co,ans);

            }
            // count all 'a' in each string
            sb.append(ans+""\n"");
        }
        System.out.print(sb);
    }
}
class pair implements Comparable<pair>{
    int a;
    int b;
    pair(int a,int b){
        this.a=a;
        this.b=b;
    }

    
}

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

public class C {
	static int n;
	public static void main (String[] args) throws IOException {
		FastReader io = new FastReader();
		int t = io.nextInt();
		for (int ii=0; ii<t; ii++) {
			n = io.nextInt();

			String[] arr = new String[n];

			for (int i=0; i<n; i++) {
				String str = io.next();
				arr[i] = str;
			}

			char[] chars = new char[]{'a','b','c','d','e'};

			int ans = -1;

			for (int i=0; i<5; i++) {
				ans = Math.max(ans, solve(arr, chars[i]));
			}
			System.out.println(ans);
		}
	}

	static int solve(String[] arr, char c) {
		//System.out.println(""Comparing based on "" + c);
		Arrays.sort(arr, new Comp(c));

		int good = 0;
		int total = 0;
		int ret = 0;

		for (int i=0; i<n; i++) {
			//System.out.println(good + "" "" + total);
			for (int j=0; j<arr[i].length(); j++) {
				if (arr[i].charAt(j) == c) good++;
			}
			total += arr[i].length();
			if (2 * good > total) {
				ret++;
			} else {
				return ret;
			}
		}

		return ret;
	}

	static class Comp implements Comparator<String> {
		char c;

		public Comp (char c) {
			this.c = c;
		}

		
	}
}
",0,Non-plagiarised
9310ad0c,f36138e7,"import java.io.*;
import java.util.*;

public class Main{

    
    
    


    

    

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


    FastReader sc = new FastReader();
    
   int t=sc.nextInt();

   
  while(t-->0)
  {
      int n=sc.nextInt();

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

      long h[]=new long[n];
      for(int i=0;i<n;i++)
      {
          h[i]=sc.nextLong();
      }
      ArrayList<Long> al=new ArrayList<>();
      long csp=h[n-1],idx=k[n-1]-h[n-1];
      for(int i=n-2;i>=0;i--)
      {
          if(idx<k[i])
          {
              if(k[i]-idx<h[i])
              {
                  long diff=h[i]-(k[i]-idx);
                  csp+=diff;
                  idx-=diff;
              }
          }
          else
          {
              al.add(csp);
              csp=h[i];
              idx=k[i]-csp;
          }
         

      }

      long sum=0;
      al.add(csp);
      for(long i:al)
      {
         sum=sum+((i*(i+1))/2);
      }

      System.out.println(sum);
     
  }
}
}
","import java.io.*;
import java.util.*;

public class a {

    public static void main(String[] args){

        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-- > 0){

            int n = sc.nextInt();

            long time[] = new long[n];
            long health[] = new long[n];

            for(int i=0; i<n; i++){
                long temp = sc.nextLong();
                time[i] = temp;
            }
            for(int i=0; i<n; i++){
                long temp = sc.nextLong();
                health[i] = temp;
            }

            long ans = 0L;
            int peak = n-1;
            int end = n-1;
            for(int i=n-1; i>=0; i--){

                if(i == n-1){
                    ans += (health[i]*(health[i]+1))/2;
                    continue;
                }

                if(health[peak] - (time[peak]-time[i]) <= 0){
                    peak = i;
                    end = i;
                    ans += (health[i]*(health[i]+1))/2;
                }

                else if(health[peak] - (time[peak]-time[i]) < health[i]){

                    long val = health[peak] + (time[end]-time[peak]); 
                    ans -= (val*(val+1))/2;

                    //System.out.println(""Val1: "" + val);

                    val = health[i] + (time[end]-time[i]);
                    ans += (val*(val+1))/2;

                    //System.out.println(""Val2: "" + val);

                    peak = i;
                }

            }

            System.out.println(ans);

        }

    }

}


",0,Non-plagiarised
30e0cc81,b55888de,"import java.io.*;
import java.util.*;
import java.math.BigInteger; 
import java.lang.*;




public class Main {
    
    
    
    
   public static String[] F(BufferedReader bf) throws Exception
    {
        return (bf.readLine().split("" ""));
    }
    
   public static void pr(PrintWriter out,Object o)
   {
      
    out.println(o.toString());//out.flush();
    
   }
   
   
   
   
    
    public static void pr(Object o)
    {
        System.out.println(o.toString());
    }
    
    
   
    public static int inInt(String s)
    {
        return Integer.parseInt(s);
    }
    
 
 
    
    
    
   
     
     
        
    
   
    

   
   

   
    
    
   
    public static int F(String[] arr,char ch){


      int[] nums = new int[arr.length];

      for(int i=0;i<arr.length;i++){
        String str = arr[i];int a=0;
        for(int j=0;j<str.length();j++){
              if(str.charAt(j) == ch){
                a++;
              }
        }
        //int b = (str.length()/2);
       // if((str.length()%2) != 0) b++;
        nums[i] = (2*a - (str.length()));
      }

      Arrays.sort(nums);
      int sum = 0;
      
   
      for(int i=arr.length-1;i>=0;i--){
        if((sum+nums[i]) <= 0){
          return  arr.length-1-i;
        }
        sum += nums[i];
      }

      return arr.length;
    }
    public static void main (String[] args) throws Exception {
        
        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);;;//
        
        //int[] map=new int[1000001];
      
       int yy=inInt(bf.readLine());
       


        

        for(int w=0;w<yy;w++)
        {
             //String str = bf.readLine();
          out.flush();
         
            String[] xlp = bf.readLine().split("" "");
            
            //String st = bf.readLine();
      int n;//boolean bol=false;
           //  m;//long a,b,c;
           long k;long l;
          // int l;
           //int double avg  k;//pr(out,""vbc"");
       // boolean bol = false;
           //long mod=1000000000+7
      n =inInt(xlp[0]);//int m = inInt(xlp[1]);//long b=in(xlp[3]);//long k=in(xlp[4]);
      String[] arr = new String[n];

      for(int i=0;i<n;i++){
        arr[i] = bf.readLine();
      }
      int ans=0;
      for(int i=0;i<5;i++){
        int v = F(arr,(char)(i+'a'));
       // pr(out,v+"" ""+i);
        ans = Math.max(ans,F(arr,(char)(i+'a')));

      }

      pr(out,ans);
      


      

   }
    out.close();//
   bf.close();//
       
}}
","import java.lang.reflect.Array;
import java.util.*;
public class Rough {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);   
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            sc.nextLine();
            String s[] = new String[n];
            int f[][] = new int[n][5];
            for (int i = 0; i < n; i++) {
                s[i]  = sc.nextLine();

                for (int j = 0; j < s[i].length(); j++) {
                    f[i][s[i].charAt(j)-'a']++;
                }
            }

            int ans = 0;
            for ( int i = 0; i < 5; i++) {
                ArrayList<Integer> al = new ArrayList<>();

                for (int j = 0; j < n; j++) {
                    int o = 0;
                    for (int k = 0; k < 5; k++) {
                        if(k != i)
                            o+=f[j][k];
                    }
                    al.add(f[j][i]-o);
                }

                Collections.sort(al,Collections.reverseOrder());

                int max = 0;
                int x = 0;
                for (int j = 0; j < n; j++) {
                    x+=al.get(j);
                    if(x<=0)break;
                    max++;
                }
                ans = Math.max(max,ans);
            }

            System.out.println(ans);
        }
        sc.close();
    }
}
",0,Non-plagiarised
3c667d4f,be3b1289,"import java.util.*;
public class j
{
  public static void main(String args[])
  {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0)
    {
      int len=in.nextInt();
      int t=in.nextInt();
      int pos[]=new int[t];
      int temp[]=new int[t];
      for(int i=0;i<t;i++)
      pos[i]=in.nextInt();
      for(int i=0;i<t;i++)
      temp[i]=in.nextInt();
      long range[]=new long[len];
      Arrays.fill(range,Long.MAX_VALUE-10000);
      for(int i=0;i<t;i++)
      range[pos[i]-1]=temp[i];
      for(int i=1;i<len;i++)
      {
        range[i]=Math.min(range[i],1+range[i-1]);
      }
      for(int i=len-2;i>=0;i--)
      {
      range[i]=Math.min(range[i+1]+1,range[i]);
      }
      for(int i=0;i<len;i++)
      {
        System.out.print(range[i]+"" "");
      }System.out.println();
    }
  }
}
","import java.util.*;
import java.lang.*;
import java.io.*;


public class cf {
    static PrintWriter out;
    static 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
2bbf754b,3a12e509,"import java.util.*;

/** 
__                  __
( _)                ( _)
/ / \\              / /\_\_
/ /   \\            / / | \ \
/ /     \\          / /  |\ \ \
/  /   ,  \ ,       / /   /|  \ \
/  /    |\_ /|      / /   / \   \_\
/  /  |\/ _ '_| \   / /   /   \    \\
|  /   |/  0 \0\    / |    |    \    \\
|    |\|      \_\_ /  /    |     \    \\
|  | |/    \.\ o\o)  /      \     |    \\
\    |     /\\`v-v  /        |    |     \\
| \/    /_| \\_|  /         |    | \    \\
| |    /__/_ `-` /   _____  |    |  \    \\
\|    [__]  \_/  |_________  \   |   \    ()
/    [___] (    \         \  |\ |   |   //
|    [___]                  |\| \|   /  |/
/|    [____]                  \  |/\ / / ||
(  \   [____ /     ) _\      \  \    \| | ||
\  \  [_____|    / /     __/    \   / / //
|   \ [_____/   / /        \    |   \/ //
|   /  '----|   /=\____   _/    |   / //
__ /  /        |  /   ___/  _/\    \  | ||
(/-(/-\)       /   \  (/\/\)/  |    /  | /
(/\/\)           /   /   //
_________/   /    /
\____________/    (



*/

public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int  t=sc.nextInt();
		while(t-- >0) {
			int n=sc.nextInt();
			int[] arr=new int[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextInt();
			}
			String str=sc.next();
			
			ArrayList<Pair> plist=new ArrayList<>();
			for(int i=0;i<n;i++) {
				char ch=str.charAt(i);
				plist.add(new Pair(arr[i],ch));
			}
			
			//B-reduce
			//R-increse
			Collections.sort(plist);
			
			int counter=1;
			boolean flag=false;
			for(int i=0;i<plist.size();i++) {
				int val=plist.get(i).number;
				int clr=plist.get(i).color;
				
				if(clr=='B') {
					if(val<counter) {
						flag=true;
						break;
					}
				}
				else {
					if(val>counter) {
						flag=true;
						break;
					}
					
				}
				counter++;
			}
			System.out.println(flag?""NO"":""YES"");
			
			
		}
	}
	public static class Pair implements Comparable<Pair>{
		int number;
		char color;
		
		Pair(int number,char color){
			this.number=number;
			this.color=color;
		}
		
		
		
		
	}
}
","import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
",0,Non-plagiarised
1ea771ea,2f8c3bf3,"import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
","import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
		    int n=sc.nextInt();
		    int k=sc.nextInt();
		    
		    int idx[]=new int[k];
		    
		    for(int i=0;i<k;i++){
		        idx[i]=sc.nextInt();
		    }
		    
		    long arr[]=new long[n];
		    Arrays.fill(arr,Integer.MAX_VALUE);
		    for(int i=0;i<k;i++){
		        long temp=sc.nextLong();
		        arr[idx[i]-1]=temp;
		    }
		    
		    long left[]=new long[n];
		    long right[]=new long[n];
		    
		    Arrays.fill(left,Integer.MAX_VALUE);
		    Arrays.fill(right,Integer.MAX_VALUE);
		    
		    
		    left[0]=arr[0];
		    
		    for(int i=1;i<n;i++){
		       left[i]=Math.min(left[i-1]+1,arr[i]);
		    }
		    
		    right[arr.length-1]=arr[arr.length-1];
		    
		    for(int i=n-2;i>=0;i--){
		        right[i]=Math.min(right[i+1]+1,arr[i]);
		    }
		    
		    for(int i=0;i<n;i++){
		      //  System.out.print(left[i]+""--""+right[i]+""\\"");
		       
		       
		       System.out.print(Math.min(left[i],right[i])+"" "");
		    }
		    System.out.println();
		  
		}
	}
}
",0,Non-plagiarised
9291ca83,d61f51c5,"import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Practice {
    static HashMap<String, Integer> map = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            int[][] occurances = new int[5][n];
            for(int i=0;i<n;i++){
                String s = sc.next();
                int[] count = new int[5];
                int len = s.length();
                for(int j=0;j<s.length();j++){
                    count[s.charAt(j)-'a']++;
                }
                for(int j=0;j<5;j++){
                    occurances[j][i] = count[j] - (len-count[j]);
                }
            }
            int ans = 0;
            for(int i=0;i<5;i++){
                Arrays.sort(occurances[i]);
                int tmpAns = 0; int tmpSum=0;
                for(int j=n-1;j>=0;j--){
                    tmpSum+=occurances[i][j];
                    if(tmpSum>0) tmpAns++;
                    else break;
                }
                ans = Math.max(ans, tmpAns);
            }
            System.out.println(ans);
        }
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class InterestingStrory {
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        try {
            // Scanner sc=new Scanner(System.in);
            FastReader sc = new FastReader();
            int t =sc.nextInt();
            while (t-- > 0) {
                int n=sc.nextInt();
                int[][] occ=new int[n][5];
                for(int i=0;i<n;i++){
                    char[] warr=sc.next().toCharArray();
                    for(char ch:warr){
                        occ[i][ch-'a']++;
                    }
                }
                int ans=Integer.MIN_VALUE;;
                for(int c=0;c<5;c++){
                    int[] sums=new int[n];
                    for(int i=0;i<n;i++){
                        int sum=0;
                        for(int j=0;j<5;j++){
                            if(c==j){
                                sum+=occ[i][j];
                            }
                            else{
                                sum-=occ[i][j];
                            }
                        }
                        sums[i]=sum;
                    }
                    Arrays.sort(sums);
                    int currSum=0;
                    int l=n-1;
                    for(l=n-1;l>=0;l--){
                        if(currSum+sums[l]<=0){
                            break;
                        }
                        else{
                            currSum+=sums[l];
                        }
                    }
                    ans=Math.max(ans,n-l-1);
                }
                System.out.println(ans);
            }
        } catch (Exception e) {
            return;
        }

    }
    

    

    

    
    
    
    

    
}
",0,Non-plagiarised
9fd33d5a,c220c822,"import java.util.*;
import java.io.*;

public class Solution {

    private static ArrayList<Integer> prime = new ArrayList<>();

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

        Scanner in=new Scanner(System.in);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringBuffer out = new StringBuffer();

        int T = in.nextInt();

        OUTER:
        while(T-->0) {

            int n=in.nextInt(), k=in.nextInt();

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

            int t[]=new int[k];
            long ans[]=new long[n];
            for(int i=0; i<k; i++) {
                t[i]=in.nextInt();
                ans[a[i]]=t[i];
            }

            long temp=Integer.MAX_VALUE;

            long left[]=new long[n];
            for(int i=0; i<n; i++) {
                if(ans[i]!=0) {
                    temp=Math.min(temp, ans[i]);
                }
                left[i]=temp;
                temp+=1;
            }

            temp=Integer.MAX_VALUE;

            long right[]=new long[n];
            for(int i=n-1; i>=0; i--) {
                if(ans[i]!=0) {
                    temp=Math.min(temp, ans[i]);
                }
                right[i]=temp;
                temp+=1;
            }

            for(int i=0; i<n; i++) {
                ans[i]=Math.min(left[i], right[i]);
                out.append(ans[i]+"" "");
            }
            out.append(""\n"");
        }

        System.out.print(out);
    }

    

    

    

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

    public static void main(String args[]){
        InputReader in=new InputReader(System.in);
        TASK solver = new TASK();
        int t=1;
        t = in.nextInt();
        for(int i=1;i<=t;i++)
        {
            solver.solve(in,i);
        }
    }
    static class TASK {
        static int dp[] = new int[31];
        static {
            dp[0]=1;
            for(int i=1;i<31;i++)
            {
                dp[i]=dp[i-1]*2;
            }
        }
        void solve(InputReader in, int testNumber) {
            int n = in.nextInt();
            int k = in.nextInt();
            int a[] = new int[k];
            int l[] = new int[n+1];
            long pre[] = new long[n+2];
            long suff[] = new long[n+2];
            Arrays.fill(pre,Long.MAX_VALUE/2);
            Arrays.fill(suff,Long.MAX_VALUE/2);
            for(int i=0;i<k;i++)
            {
                a[i]=in.nextInt();
            }
            for(int i=0;i<k;i++)
            {
                int x = in.nextInt();
                l[a[i]]=x;
            }
            for(int i=1;i<=n;i++)
            {
                pre[i]=pre[i-1];
                if(l[i]!=0)
                {
                    pre[i]=Math.min(pre[i],l[i]-i);
                }
            }
            for(int i=n;i>=1;i--)
            {
                suff[i]=suff[i+1];
                if(l[i]!=0)
                {
                    suff[i]=Math.min(suff[i],l[i]+i);
                }
            }
            for(int i=1;i<=n;i++)
            {
                System.out.print(Math.min(pre[i]+i,suff[i]-i)+"" "");
            }
            System.out.println();







        }
    }


    

    
    
}
",0,Non-plagiarised
3c74c140,732c98a0,"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
    

    



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

import static java.lang.Math.*;
import static java.lang.System.out;
import static java.lang.Long.MAX_VALUE;

public final class Main {

    FastReader in;
    StringBuffer sb;
    public static void main(String[] args) {
        new Main().run();
    }

    void run(){
        in= new FastReader();
        start();
    }

    void start(){
        sb= new StringBuffer();
        for(int t=in.nextInt();t>0;t--)
            solve();
        out.print(sb);
    }

    void solve(){
        int n = in.nextInt();
        int[][] mat = new int[n][5];
        for(int i = 0; i<n; i++) {
            char[] pp =in.nextLine().toCharArray();
            for(char c : pp) {
                mat[i][c-'a']++;
            }
            int[] p = new int[5];
            int tt = 0;
            for(int j : mat[i])
                tt +=j;
            for(int j = 0; j<5; j++) {
                mat[i][j]=2*mat[i][j]-tt;
            }
        }
        int ans  = 0;
        for(int i = 0; i<5; i++) {
            int g = check(i,mat, n);
            ans = Math.max(g,ans);
        }
        sb.append(ans).append(""\n"");
    }

    int check(int i, int[][] mat, int n) {
        ArrayList<Integer> x = new ArrayList<>();
        for(int j = 0; j<n; j++) {
            x.add(mat[j][i]);
        }
        Collections.sort(x);
        int s = 0;
        int cnt = 0;
        int l = n-1;
        while(l>=0) {
            int u = x.get(l);
            if(s+u>0) {
                s+=u;
                cnt++;
            }
            else
                break;
            l--;
        }
        return cnt;
    }

    

    

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

    

    // sieve of eratosthenes code for precomputing whether numbers are prime or not up to MAX_VALUE
    long MAX= MAX_VALUE;
    int[] precomp= new int[(int) (MAX+1)];
    

    

    

    

    
    

    

    

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


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

public final class Main{
	public static void main(String[] args) throws IOException{
//		Scanner sc=new Scanner(System.in);
		FastReader sc=new FastReader();
		PrintWriter writer=new PrintWriter(System.out);
		
		int tc=sc.nextInt();
		while(tc-->0) {
			  int n=sc.nextInt();
	          long[] c=new long[n];
	          for(int i=0;i<n;i++) c[i]=sc.nextInt();   
	          long ans=c[0]*n+c[1]*n;
	          long x=Long.MAX_VALUE-1,y=Long.MAX_VALUE-1,sumx=0,sumy=0,cx=0,cy=0,min1=Long.MAX_VALUE-1,min2=Long.MAX_VALUE-1;
	          for(int i=0;i<n;i++) {
	          if(i%2==0){
	              x=Math.min(x,c[i]);
	              sumx+=c[i];
	              cx=i/2+1;
	              min1=sumx+x*(n-cx);
	          }
	          else {
	        	  y=Math.min(y,c[i]);
	        	  sumy+=c[i];cy=(i+1)/2;
	              min2=sumy+y*(n-cy);
	          }
	          if(i>=1) ans=Math.min(ans,min1+min2);
	         }
	          
	         System.out.println(ans);
		}
		writer.flush();
		writer.close();
  }
    
  
   
}
",1,Plagiarised
8f31b279,a3e272af,"import java.util.*;
import java.io.*;
public class JavaTract
{
	static class Pair implements Comparable<Pair>{
    	int first;
    	int second;
    	Pair(int x,int y){
        	this.first=x;
        	this.second=y;
    	}
    	
   	}	
    public static void main (String[] args) 
    {
        Scanner scan=new Scanner(System.in);
        int t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int m=scan.nextInt();
            int x=scan.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            // TreeSet<Pair> set = new TreeSet<>(); 
            Queue<Pair> set = new PriorityQueue<>();
            for(int i=1;i<=m;i++){
               
               set.add(new Pair(0,i));
            }
            
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                Pair temp=set.poll();
                
                int first = temp.first;
                int second = temp.second;

                System.out.print(second+"" "");
                
                set.add(new Pair(first+arr[i],second));
                
            }
            System.out.println();


        }
    }

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

public class Asd {

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

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

    }
  public static class Student {
    public int i1;
    public int value;
          
    // A parameterized student constructor
    public Student(int i1,int i2) {
      
        this.i1 = i1;
        this.value=i2;
    }
      
    public int getkey() {
        return i1;
    } 
    public int getValue() {
        return value;
    } 
}
   static class StudentComparator implements Comparator<Student>{
              
            // Overriding compare()method of Comparator 
                        // for descending order of cgpa
        
        }
    
    /* 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
5af25bd7,fa1bf524,"import java.io.*;
import java.util.*;
 
public class MySolution {
    public static void main(String[] args) throws Exception {
        BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder out = new StringBuilder();
        int numOfTestCases = Integer.parseInt(bu.readLine());
        for (int tc = 1; tc <= numOfTestCases; tc++) {
            int vertices = Integer.parseInt(bu.readLine());
            connections = new ArrayList[vertices];
            for (int i = 0; i < vertices; i++) {
                connections[i] = new ArrayList<Integer>();
                String st[] = bu.readLine().split("" "");
                a[i][0] = Integer.parseInt(st[0]);
                a[i][1] = Integer.parseInt(st[1]);
                s[i][0] = s[i][1] = 0;
            }
            for (int j = 0; j < vertices-1; j++) {
                String st[] = bu.readLine().split("" "");
                int u = Integer.parseInt(st[0]) - 1, v = Integer.parseInt(st[1]) - 1;
                connections[u].add(v);
                connections[v].add(u);
            }
            dfs(0, -1);
            out.append(Math.max(s[0][0], s[0][1]) + ""\n"");
        }
        System.out.print(out);
    }
 
    static int N = 100000;
    static int[][] a = new int[N][2];
    static long[][] s = new long[N][2];
    static ArrayList<Integer>[] connections;
 
    public static void dfs(int n, int parent) {
        for (int child : connections[n]) {
            if (child != parent) {
                dfs(child, n);
                s[n][0] += Math.max(s[child][0] + Math.abs(a[n][0] - a[child][0]), s[child][1] + Math.abs(a[n][0] - a[child][1]));
                s[n][1] += Math.max(s[child][0] + Math.abs(a[n][1] - a[child][0]), s[child][1] + Math.abs(a[n][1] - a[child][1]));
            }
        }
    }
}
","import java.util.*;
import java.io.*;

public class Solution {

    static LinkedList<Integer> graph[];
    static long key[][];
    static long value[][];

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

        Scanner in = new Scanner(System.in);
        StringBuffer out=new StringBuffer();
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int t=Integer.parseInt(br.readLine());
        String input[];

        OUTER:
        while(t--!=0) {

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

            value=new long[n][2];
            key=new long[n][2];

            for(int i=0; i<n; i++) {
                input= br.readLine().split(""\\s"");
                for(int j=0; j<2; j++) {
                    key[i][j] = Integer.parseInt(input[j]);
                }
            }

            graph=new LinkedList[n];
            for(int i=0; i<n; i++)
                graph[i]=new LinkedList();

            for(int i=1; i<n; i++) {
                input= br.readLine().split(""\\s"");
                int u=Integer.parseInt(input[0])-1, v=Integer.parseInt(input[1])-1;
                graph[u].add(v);
                graph[v].add(u);
            }

            int root=-1;
            for(int i=0; i<n; i++)
                if(graph[i].size()==1) {
                    root=i;
                    break;
                }

            solve(root, -1);

            out.append(Math.max(value[root][0], value[root][1])+""\n"");
        }

        System.out.print(out);
    }

    private static void solve(int vertex, int parent) {

        for(int child: graph[vertex]) {
            if(child!=parent) {
                solve(child, vertex);
                for(int i=0; i<2; i++) {
                    long max=Long.MIN_VALUE;
                    for(int j=0; j<2; j++) {
                        max=Math.max(max, Math.abs(key[vertex][i]-key[child][j])+value[child][j]);
                    }
                    value[vertex][i]+=max;
                }
            }
        }

//        System.out.println(vertex+"" ""+Arrays.toString(key[vertex])+"" ""+Arrays.toString(value[vertex]));
    }
}
",0,Non-plagiarised
489930000000,96cd6ee9,"import java.io.*;
import java.util.*;

public class Codeforce {

    

    static 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);
    }
}
","import java.io.*;
import java.util.*;
import java.math.BigInteger;


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

        double eps= 0.00000001;
        static final int MAXN = 100005;
        static final int MOD= 998244353;

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

        Map<Integer,Set<Integer>> dp= new HashMap<>();

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

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

        

        

        

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

        

        

        
        
        
        public void solve(InputReader in, PrintWriter out) {
            int test= in.nextInt();
            while(test-->0){
                int n= in.nextInt(), k= in.nextInt();
                int[] a= new int[k];
                int[] t= new int[k];
                for(int i=0;i<k;i++) a[i]= in.nextInt();
                for(int i=0;i<k;i++) t[i]= in.nextInt();
                int[] c= new int[n];
                Arrays.fill(c, Integer.MAX_VALUE);
                for(int i=0;i<k;i++){
                    c[a[i]-1]=t[i];
                }
                int[] L= new int[n];
                int[] R= new int[n];
                Arrays.fill(L, Integer.MAX_VALUE);
                Arrays.fill(R, Integer.MAX_VALUE);

                long p= Integer.MAX_VALUE;
                for(int i=0;i<n;i++){
                    p=Math.min(p+1,c[i]);
                    L[i]=(int)p;
                }
                p= Integer.MAX_VALUE;
                for(int i=n-1;i>=0;i--){
                    p= Math.min(p+1,c[i]);
                    R[i]=(int)p;
                }
                for(int i=0;i<n;i++){
                    out.print(Math.min(L[i],R[i])+"" "");
                }
                out.println();
            }
            
        }
    

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

    }

    


    

    
    // fast input reader class;
    
}
",1,Plagiarised
0b5cff5a,4fb09c5f,"import java.io.*;
import java.text.DecimalFormat;
import java.util.*;

public class E {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);


        int t= in.nextInt();
        while(t-->0) {

            int n = in.nextInt();
            int k = in.nextInt();
            int[] a= in.readArray(k);
            int[] temp = in.readArray(k);
            int[] pre = new int[n];
            Arrays.fill(pre,Integer.MAX_VALUE);
            int[] suf = new int[n];
            Arrays.fill(suf,Integer.MAX_VALUE);
            for(int i = 0;i<k;i++){
                pre[a[i]-1]=temp[i];
                suf[a[i]-1]=temp[i];
            }
            int min = Integer.MAX_VALUE;
            Arrays.sort(a);
            for(int i=a[0]-1;i<n;i++){
                min = Math.min(min,pre[i]);
                pre[i] = min;
                min++;

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

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




    
    
    

    

    
    
    

    
}
","import java.io.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;
import java.util.stream.Collectors;

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int q = sc.nextInt();
        while (q-- > 0) {
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] arr = new int[k];
            int[] t = new int[k];
            HashMap<Integer, Integer> hm = new HashMap<>();
            for (int i = 0; i < k; i++) {
                arr[i] = sc.nextInt() - 1;
            }

            for (int i = 0; i < k; i++) {
                t[i] = sc.nextInt();
                hm.put(arr[i], t[i]);
            }

            int[] left = new int[n];
            int[] right = new int[n];
            left[0] = hm.getOrDefault(0, -1);
            right[n - 1] = hm.getOrDefault(n - 1, -1);
            for (int i = 1; i < n; i++) {
                if (hm.containsKey(i)) {
                    if (left[i - 1] < 0) {
                        left[i] = hm.get(i);
                    } else {
                        left[i] = Math.min(hm.get(i), left[i - 1] + 1);
                    }
                } else {
                    left[i] = left[i - 1] < 0 ? -1 : left[i - 1] + 1;
                }
            }
            for (int i = n - 2; i >= 0; i--) {
                if (hm.containsKey(i)) {
                    if (right[i + 1] < 0) {
                        right[i] = hm.get(i);
                    } else {
                        right[i] = Math.min(hm.get(i), right[i + 1] + 1);
                    }
                } else {
                    right[i] = right[i + 1] < 0 ? -1 : right[i + 1] + 1;
                }
            }
            for (int i = 0; i < n; i++) {
                if (left[i] < 0) {
                    pw.print(right[i] + "" "");
                } else if (right[i] < 0) {
                    pw.print(left[i] + "" "");
                } else {
                    pw.print(Math.min(left[i], right[i]) + "" "");
                }
            }
            pw.println();
        }
        pw.flush();
        pw.close();
    }

    // inclusive
    

    

    
}
",0,Non-plagiarised
3cbcb1cc,6045e5d1,"import java.util.*;
import java.lang.*;
import java.io.*;

public class E {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		br.readLine();
		StringBuilder sb = new StringBuilder();
		while (t-- > 0) {
			String[] scn = (br.readLine()).trim().split("" "");
			int n = Integer.parseInt(scn[0]);
			int m = Integer.parseInt(scn[1]);
			long[] land = new long[n + 1];
			scn = (br.readLine()).trim().split("" "");
			String[] scn1 = (br.readLine()).trim().split("" "");
			for (int i = 0; i < m; i++) {
				int idx = (int) Long.parseLong(scn[i]);
				long temp = Long.parseLong(scn1[i]);
				land[idx] = temp;
			}
			long[] ans = new long[n + 1];
			long min = (long) (1e15);
			for (int i = 1; i <= n; i++) {
				if (land[i] != 0) {
					min = Math.min(min, land[i]);
				}
				ans[i] = min;
				min += 1;
			}
			min = (long) (1e15);
			for (int i = n; i >= 1; i--) {
				if (land[i] != 0) {
					min = Math.min(min, land[i]);
				}
				ans[i] = Math.min(min, ans[i]);
				min += 1;
			}
			for (int i = 1; i <= n; i++) {
				sb.append(ans[i] + "" "");
			}
			sb.append(""\n"");
			if (t != 0) {
				br.readLine();
			}
		}
		System.out.println(sb);
		return;

	}

	

	

	

	

	

	

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

public class E {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		br.readLine();
		StringBuilder sb = new StringBuilder();
		while (t-- > 0) {
			String[] scn = (br.readLine()).trim().split("" "");
			int n = Integer.parseInt(scn[0]);
			int m = Integer.parseInt(scn[1]);
			long[] land = new long[n + 1];
			scn = (br.readLine()).trim().split("" "");
			String[] scn1 = (br.readLine()).trim().split("" "");
			for (int i = 0; i < m; i++) {
				int idx = (int) Long.parseLong(scn[i]);
				long temp = Long.parseLong(scn1[i]);
				land[idx] = temp;
			}
			long[] ans = new long[n + 1];
			long min = (long) (1e15);
			for (int i = 1; i <= n; i++) {
				if (land[i] != 0) {
					min = Math.min(min, land[i]);
				}
				ans[i] = min;
				min += 1;
			}
			min = (long) (1e15);
			for (int i = n; i >= 1; i--) {
				if (land[i] != 0) {
					min = Math.min(min, land[i]);
				}
				ans[i] = Math.min(min, ans[i]);
				min += 1;
			}
			for (int i = 1; i <= n; i++) {
				sb.append(ans[i] + "" "");
			}
			sb.append(""\n"");
			if (t != 0) {
				br.readLine();
			}
		}
		System.out.println(sb);
		return;

	}

	

	

	

	

	

	

}
",1,Plagiarised
8c591975,b6724dd9,"import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Main {

    private static void run() throws IOException {
        int n, k;
        n = in.nextInt();
        k = in.nextInt();
        int[] a = new int[n];
        long[] t = new long[k];

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

        long[] dp = new long[n];

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

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

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

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

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

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

    

    static final long mod = 1000000007;

    

    

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

    

    

    

    

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

public class AirConditioners {

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

		InputReader in = new InputReader(inputStream);
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
		int t = in.nextInt();
		while (t-- != 0) {
			int n = in.nextInt();
			int k = in.nextInt();
			HashMap<Integer, Integer> hm = new HashMap<>();
			int[] ac = in.readArray(k);
			for (int idx = 0; idx < ac.length; idx++) {
				hm.put(ac[idx], in.nextInt());
			}
			Arrays.sort(ac);
			long[] lmin = new long[n];
			long val = (long) Integer.MAX_VALUE;
			int acdx = 0;
			for (int idx = 0; idx < lmin.length; idx++) {
				if (acdx < ac.length && ac[acdx] - 1 == idx) {
					val = (long) Math.min(val, hm.get(ac[acdx]));
					acdx++;
				}
				lmin[idx] = val;
				val++;
			}
			acdx = ac.length - 1;
			val = Integer.MAX_VALUE;
			for (int idx = lmin.length-1; idx >= 0; idx--) {
				if (acdx >= 0 && ac[acdx] - 1 == idx) {
					val = (long) Math.min(val, hm.get(ac[acdx]));
					acdx--;
				}
				lmin[idx] = Math.min(lmin[idx], val);
				val++;
			}
			for (long x : lmin) {
				out.write(x + "" "");
			}
			out.newLine();
		}
		out.close();
	}

	

}
",0,Non-plagiarised
74f4382e,bd584714,"import java.io.*;
import java.util.*;

public class Solution {

	

	

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

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

	
	static int pri[] = new int[(int) 1e5 + 5];
	
	
	public static void main(String[] args) throws IOException {

		int t = sc.nextInt();

		//sieve();
		int tc = 1;
		while (tc <= t) {

			// out.append(""Case #"" + tc + "": "");
			Solution run = new Solution();

			run.run();

			tc++;
		}

		System.out.println(out);

	}

	
	ArrayList<Integer> gr[];
	long a[][];
	

	public void run() throws IOException {

		int n = sc.nextInt();
		
		gr=new ArrayList[n+1];
		a=new long[n+1][2];
		for(int i=0;i<=n;i++)gr[i]=new ArrayList<>();
		
	
		for(int i=1;i<=n;i++) {
			
			a[i][0]=sc.nextInt();
			a[i][1]=sc.nextInt();
		}
		
		for(int i=0;i<n-1;i++) {
			
			int u=sc.nextInt();
			int v=sc.nextInt();
			
			gr[u].add(v);
			gr[v].add(u);
		}
		
		dp=new long[n+1][2];
		
		for(long a1[]:dp)Arrays.fill(a1, -1L);
		
		//dfs(1,-1);
		
		long res=Math.max(dfs(1,-1,0), dfs(1,-1,1));
		
		out.append(res+""\n"");
		
		
	}
	
	long dp[][];
	
	
	long dfs(int u, int pa,int ok) {
		
		
		
			
			if(dp[u][ok]!=-1)return dp[u][ok];
			
			
		
		
		
		long ans=0;
		for(int ch: gr[u]) {
			
			
			if(ch==pa)continue;
			long res=0;
			
			
				
				if(ok==0) {
					
					res=Math.max(dfs(ch,u,0)+Math.abs(a[u][0]-a[ch][0]), dfs(ch,u,1)+Math.abs(a[u][0]-a[ch][1]));
					
				}
				else {
					
					res=Math.max(dfs(ch,u,0)+Math.abs(a[u][1]-a[ch][0]), dfs(ch,u,1)+Math.abs(a[u][1]-a[ch][1]));
					
					
				}
			
			
			
			ans+=res;
			
			
			
			
		}
		
		return dp[u][ok]=ans;
	}
	
	
	void dfs(int u, int pa) {
		
		if(gr[u].size()==1) {
			dp[u][0]=dp[u][1]=0L;
		}
		
		
		for(int ch:gr[u]) {
			
			
			if(ch==pa)continue;
			
			
			dfs(ch,u);
		}
		
		
		
		for(int ch: gr[u]) {
			
			if(ch==pa)continue;
			
			long ans1=0;
			long ans2=0;
			
			
			ans1=Math.max(dp[ch][0]+Math.abs(a[u][0]-a[ch][0]), dp[ch][1]+Math.abs(a[u][0]-a[u][1]));
			
			dp[u][0]+=ans1;
			
			ans1=Math.max(dp[ch][0]+Math.abs(a[u][1]-a[ch][0]), dp[ch][1]+Math.abs(a[u][1]-a[u][1]));
			
			dp[u][1]+=ans2;
			
			
			
		}
		
		
	}

	

	

	static Reader sc = new Reader();

	

}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

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

    static class CParsasHumongousTree {
        int n;
        long[] l;
        long[] r;
        ArrayList<Integer>[] adj;
        long[][] dp;

        public void solve(int testNumber, Scanner sc, PrintWriter pw) {
            int t = 1;
            t = sc.nextInt();
            while (t-- > 0) {
                n = sc.nextInt();
                l = new long[n];
                r = new long[n];
                for (int i = 0; i < n; i++) {
                    l[i] = sc.nextInt();
                    r[i] = sc.nextInt();
                }
                adj = new ArrayList[n];
                for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
                for (int i = 0; i < n - 1; i++) {
                    int x = sc.nextInt() - 1;
                    int y = sc.nextInt() - 1;
                    adj[x].add(y);
                    adj[y].add(x);
                }
                dp = new long[n + 1][2];
                for (long[] x : dp) Arrays.fill(x, -1);
                long ans = solve(-1, 0, 0);
                for (long[] x : dp) Arrays.fill(x, -1);
                ans = Math.max(ans, solve(-1, 0, 1));
                pw.println(ans);
            }

        }

        long solve(int from, int i, int f) {
            if (dp[i][f] != -1) return dp[i][f];
            long ans = 0;
            long a = f == 0 ? l[i] : r[i];
            for (int x : adj[i]) {
                if (x != from)
                    ans += Math.max((Math.abs(l[x] - a) + solve(i, x, 0)), (Math.abs(r[x] - a) + solve(i, x, 1)));
            }
            return dp[i][f] = ans;
        }

    }

    
}
",0,Non-plagiarised
2b9dfed3,351c9206,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

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

	public static void process() throws IOException {

		int n = sc.nextInt(),k = sc.nextInt();
		int index[] = sc.readArray(k);
		long t[] = sc.readArrayLong(k);
		PriorityQueue<Pair> q = new PriorityQueue<Pair>();
		for(int i = 0; i<k; i++)q.add(new Pair(t[i]+index[i], index[i]));
		long ans[] = new long[n+1];
		Arrays.fill(ans, INF);
		int i = 1;
		while(!q.isEmpty() && i<=n) {
			while(!q.isEmpty() && q.peek().y < i) {
				q.poll();
			}
			if(q.isEmpty())break;
			Pair e = q.peek();
			ans[i]=min(ans[i],e.x-i);
			i++;
		}
//		System.out.println(Arrays.toString(ans));
		q.clear();
		for(i = 0; i<k; i++) {
			q.add(new Pair(t[i]+n-index[i], index[i]));
		}
		i = n;
		while(!q.isEmpty() && i>=1) {
			while(!q.isEmpty() && q.peek().y > i) {
				q.poll();
			}
			if(q.isEmpty())break;
			Pair e = q.peek();
			ans[i]=min(ans[i],e.x-(n-i));
			i--;
		}
		for( i = 1; i<=n; i++)out.print(ans[i]+"" "");
		out.println();

	}

	//=============================================================================
	//--------------------------The End---------------------------------
	//=============================================================================
	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
	private static int N = 0;

	

	static FastScanner sc;
	static FastWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new FastWriter(System.out);
		} else {
			sc = new FastScanner(""input.txt"");
			out = new FastWriter(""output.txt"");
		}
		long s = System.currentTimeMillis();
		int t = 1;
		t = sc.nextInt();
		int TTT = 1;
		while (t-- > 0) {
			//			google(TTT++);
			process();
		}
		out.flush();
		//		tr(System.currentTimeMillis()-s+""ms"");
	}

	private static boolean oj = System.getProperty(""ONLINE_JUDGE"") != null;

	

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

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

		

		/*
		 	@Override
		    public boolean equals(Object o) {
		        if (this == o) return true;
		        if (!(o instanceof Pair)) return false;
		        Pair key = (Pair) o;
		        return x == key.x && y == key.y;
		    }
		 
		    @Override
		    public int hashCode() {
		        int result = x;
		        result = 31 * result + y;
		        return result;
		    }
		*/
	}

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

	

	

	

	

	

	

	

	

	

	

	

	

	//custom multiset (replace with HashMap if needed)
	

	

	// compress Big value to Time Limit
	

	// Fast Writer 

	

	// Fast Inputs
	

}
","import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

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

	public static void process() throws IOException {

		int n = sc.nextInt(),k = sc.nextInt();
		int index[] = sc.readArray(k);
		long t[] = sc.readArrayLong(k);
		PriorityQueue<Pair> q = new PriorityQueue<Pair>();
		for(int i = 0; i<k; i++)q.add(new Pair(t[i]+index[i], index[i]));
		long ans[] = new long[n+1];
		Arrays.fill(ans, INF);
		int i = 1;
		while(!q.isEmpty() && i<=n) {
			while(!q.isEmpty() && q.peek().y < i) {
				q.poll();
			}
			if(q.isEmpty())break;
			Pair e = q.peek();
			ans[i]=min(ans[i],e.x-i);
			i++;
		}
//		System.out.println(Arrays.toString(ans));
		q.clear();
		for(i = 0; i<k; i++) {
			q.add(new Pair(t[i]+n-index[i], index[i]));
		}
		i = n;
		while(!q.isEmpty() && i>=1) {
			while(!q.isEmpty() && q.peek().y > i) {
				q.poll();
			}
			if(q.isEmpty())break;
			Pair e = q.peek();
			ans[i]=min(ans[i],e.x-(n-i));
			i--;
		}
		for( i = 1; i<=n; i++)out.print(ans[i]+"" "");
		out.println();

	}

	//=============================================================================
	//--------------------------The End---------------------------------
	//=============================================================================
	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
	private static int N = 0;

	

	static FastScanner sc;
	static FastWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new FastWriter(System.out);
		} else {
			sc = new FastScanner(""input.txt"");
			out = new FastWriter(""output.txt"");
		}
		long s = System.currentTimeMillis();
		int t = 1;
		t = sc.nextInt();
		int TTT = 1;
		while (t-- > 0) {
			//			google(TTT++);
			process();
		}
		out.flush();
		//		tr(System.currentTimeMillis()-s+""ms"");
	}

	private static boolean oj = System.getProperty(""ONLINE_JUDGE"") != null;

	

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

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

		

		/*
		 	@Override
		    public boolean equals(Object o) {
		        if (this == o) return true;
		        if (!(o instanceof Pair)) return false;
		        Pair key = (Pair) o;
		        return x == key.x && y == key.y;
		    }
		 
		    @Override
		    public int hashCode() {
		        int result = x;
		        result = 31 * result + y;
		        return result;
		    }
		*/
	}

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

	

	

	

	

	

	

	

	

	

	

	

	

	//custom multiset (replace with HashMap if needed)
	

	

	// compress Big value to Time Limit
	

	// Fast Writer 

	

	// Fast Inputs
	

}
",1,Plagiarised
49b94994,f0d91796,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main1582D {
    public static void main(String[] args) {
        final FastScanner in = new FastScanner(System.in);
        final PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int j = 0; j < n; j++) {
                a[j] = in.nextInt();
            }
            int[] b = solution(a, n);
            for (int j = 0; j < n; j++) {
                out.print(b[j]);
                out.print("" "");
            }
            out.println();
        }

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

    private static int[] solution(int[] a, int n) {
        int[] b = new int[n];
        int start = 0;

        if (n % 2 == 1) {
            if (a[0] + a[1] != 0) {
                b[0] = -a[2];
                b[1] = -a[2];
                b[2] = a[0] + a[1];
            } else if (a[0] + a[2] != 0) {
                b[0] = -a[1];
                b[1] = a[0] + a[2];
                b[2] = -a[1];
            } else {
                b[0] = a[1] + a[2];
                b[1] = -a[0];
                b[2] = -a[0];
            }
            start = 3;
        } else {
            b[0] = -a[1];
            b[1] = a[0];
            int gcd = gcd(b[0], b[1]);
            b[0] /= gcd;
            b[1] /= gcd;
            start = 2;
        }
        for (int i = start; i < n; i += 2) {
            b[i] = -a[i + 1];
            b[i + 1] = a[i];
        }
        return b;
    }

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

    
}
","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
6b83b22e,c59194c7,"import java.util.Scanner;

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

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
","import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer;
import java.util.*;
public class codeforcesB{
  
 public static void main(String args[]){
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int ar[]=new int[n];
      int sum=0;
      for(int i=0;i<n;i++){ar[i]=sc.nextInt();}
      if(n%2==0){
          for(int i=0;i<n;i++){
              if(i%2==0){sb.append(-1*ar[i+1]+"" "");}
              else{sb.append(ar[i-1]+"" "");}
            }
           
        }
      else{
          if(ar[1]+ar[0]!=0){
          sb.append(ar[2]+"" ""+ar[2]+"" ""+-1*(ar[1]+ar[0])+"" "");}
          else{
              if(ar[2]+ar[1]!=0){
                  sb.append(-1*(ar[2]+ar[1])+"" ""+ar[0]+"" ""+ar[0]+"" "");
              }
              else{
                  sb.append(ar[1]+"" ""+-1*(ar[2]+ar[0])+"" ""+ar[1]+"" "");
              }
          }
          for(int i=3;i<n;i++){
              if(i%2==1){sb.append(-1*ar[i+1]+"" "");}
              else{sb.append(ar[i-1]+"" "");}
            }
        }
      sb.append(""\n"");
    }
    System.out.print(sb.toString());
   }
}
",0,Non-plagiarised
00af3420,d92c5342,"import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }

    
}
","import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;
public class Main{
    
    
    static int MOD=1000003;
    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner();
        FastWriter out = new FastWriter();
        int t=in.nextInt();
        //int t=1;
        while (t-->0){
            int n=in.nextInt();
            String[] ar=new String[n];
            for (int i = 0; i < n; i++) {
                ar[i]=in.next();
            }
            int ans=0;
            for(char ch='a';ch<='e';ch++){
                int[] res=new int[n];
                for (int i = 0; i < n; i++) {
                    String ss=ar[i];
                    for (int j = 0; j < ss.length(); j++) {
                        if(ss.charAt(j)==ch){
                            res[i]++;
                        }else {
                            res[i]--;
                        }
                    }
                }
                Arrays.sort(res);int max=0,nn=0;
                for (int i = n-1; i>=0; i--) {
                    max+=res[i];
                    if(max>0){
                        nn++;
                    }else {
                        break;
                    }
                }
                ans=Math.max(ans,nn);
            }
            out.println(ans);
        }
        out.close();
    }
    //Arrays.sort(a, (o1, o2) -> (o1[0] - o2[0]));
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
}
",0,Non-plagiarised
11373c16,69b2fd22,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{ 
	public static void main (String[] args) throws java.lang.Exception
	{
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int n = scan.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            int x = scan.nextInt();
            if(x==1)
            a.add(i);
            else
            b.add(i);  
        }
        int x = a.size();
        if(x==0){
            pw.println(0);
            pw.flush();
            return;
        }
        int y = b.size();
        int dp[][] = new int[x][y];
        int min = Integer.MAX_VALUE;
        for(int i=0;i<y;i++){
            min = Math.min(Math.abs(a.get(0) - b.get(i)),min);
            dp[0][i] = min;
        }
        for(int i=1;i<x;i++){
            min = Integer.MAX_VALUE;
            for(int j=i;j<y;j++){
                min = Math.min(Math.abs(a.get(i)-b.get(j))+dp[i-1][j-1],min);
                dp[i][j] = min;
            }
        }
        pw.println(dp[x-1][y-1]);
        pw.flush();
	}
   
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

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


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

public class test3 {

	public static void main(String[] args) throws  IOException {
		FastReader f = new FastReader();
		int t = f.nextInt();
		while(t-->0) {
			 int n = f.nextInt();
			 int C[] = new int[n];
			 long ans=Long.MAX_VALUE,pre = 0;
			 PriorityQueue<Integer> epq = new PriorityQueue<Integer>();
			 PriorityQueue<Integer> opq = new PriorityQueue<Integer>();
			 for(int i = 0;i<n;i++) {
				 C[i] = f.nextInt();
				 if(i%2==0)epq.add(C[i]);
				 else opq.add(C[i]);
				 pre+=C[i];
				 if(i>0) {
					 ans  = Math.min(ans,pre+ ((long)n-(long)epq.size())*(long)epq.peek()
							 		+ ((long)n-(long)opq.size())*(long)opq.peek());
				 }
			 }
			 System.out.println(ans);
			}
    }
	
	
	
	

	
	
	
    
	  
		
	 
	 

 }
",1,Plagiarised
1c8bb204,7ed5a88d,"import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class BST {

    

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-->0){

            int n = Integer.parseInt(br.readLine());
            long [] arr = new long[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                long tmp = Long.parseLong(st.nextToken());
                arr[i] = tmp;

            }

            int h = 1;
            int v = 1;
            long minHor = arr[0];
            long minVir = arr[1];
            long sum0 = arr[0];
            long sum1 = arr[1];
            long total = (arr[0] + arr[1])*n;


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

                if(i%2==0){
                    h++;
                    sum0 += arr[i];
                    minHor = Math.min(arr[i] , minHor);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }else {
                    v++;
                    sum1 += arr[i];
                    minVir = Math.min(arr[i] , minVir);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }

            }


            System.out.println(total);

        }



    }




}
","import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.io.PrintStream;
            //import java.util.*;

        public class Solution {

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

            
                                    
            

        
        public static void main(String[] args) throws Exception {
            
            FastScanner s = new FastScanner();

            PrintStream debug = null;
            
            if(LOCAL){
                s = new FastScanner(""src/input.txt"");
                PrintStream o = new PrintStream(""src/sampleout.txt"");
                debug = new PrintStream(""src/debug.txt"");
                System.setOut(o);
            }

            


            int tcr = s.nextInt();

            
            for(int tc=0;tc<tcr;tc++){
                int n = s.nextInt();

                long arr[] = new long[n];

                for(int i=0;i<n;i++){
                    arr[i] = s.nextLong();
                }

                long min1 = arr[0];
                long min2 = arr[1];
                long sum1 = arr[0];
                long sum2 = arr[1];

                int cnt1 = 1;
                int cnt2 = 1;

                long ans = arr[0]*(n) + arr[1]*(n);

                for(int i=2;i<n;i++){
                    if((i % 2) == 0){
                        min1 = Math.min(min1,arr[i]);
                        sum1 += arr[i];
                        cnt1++;
                    }else{
                        min2 = Math.min(min2,arr[i]);
                        sum2 += arr[i];
                        cnt2++;
                    }
                    long temp = min1*(n - cnt1 + 1) + (sum1 - min1) + (min2*(n- cnt2 + 1) + (sum2 - min2));
                    ans = Math.min(ans,temp);
                }

                println(ans);
            }                
        }

        

        


        

       
  

        

        

        

        

        // return the (index + 1)
        // where index is the pos of just smaller element
        // i.e count of elemets strictly less than num
        
        
        //return (index of just greater element)
        //count of elements smaller than or equal to num

        
    
        

        public static void println(Object obj){
            System.out.println(obj.toString());
        }

        

        

        

        

    

        

        


        

        // Merge sort function
        

        

}
",0,Non-plagiarised
35eb27da,8559d49e,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-- > 0)
		{
		    int n = sc.nextInt();
		    sc.nextLine();
		    int a[][] = new int[26][26];
		    int b[][][] = new int[26][26][26];
		    
		    boolean bl = false;
		    String arr[] = new String[n];
		    for(int i = 0 ; i < n ; i++)
		    {
		        arr[i] = sc.nextLine();
		        
		        if(arr[i].length() == 1)
		        {
		            bl = true;
		        }
		        
		        else if(arr[i].length() == 2)
		        {
		            //a[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'] = 1;
		            if(arr[i].charAt(0)==arr[i].charAt(1))
		            bl = true;
		        }
		        
		        else
		        {
		           //b[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'][arr[i].charAt(2)-'a'] = 1; 
		           if(arr[i].charAt(0) == arr[i].charAt(2))
		           bl = true;
		        }
		    }
		    
		    if(bl)
		    System.out.println(""YES"");
		    
		    else
		    {
		        for(int i = 0; i < n ; i++)
		        {
		            if(arr[i].length() == 2)
		            {
		                int p1 = arr[i].charAt(0)-'a';
		                int p2 = arr[i].charAt(1)-'a';
		                
		                if(a[p2][p1] == 1)
		                bl = true;
		                
		                for(int j = 0;  j < 26 ; j++)
		                {
		                    if(b[p2][p1][j] == 1)
		                    bl = true;
		                }
		                a[p1][p2] = 1;
		            }
		            
		            else
		            {
		                 int p1 = arr[i].charAt(0)-'a';
		                int p2 = arr[i].charAt(1)-'a';
		                int p3 = arr[i].charAt(2)-'a';
		                
		                if(a[p3][p2] == 1)
		                bl = true;
		                
		                if(b[p3][p2][p1] == 1)
		                bl = true;
		                
		                b[p1][p2][p3] = 1;
		            }
		        }
		        if(bl)
		        System.out.println(""YES"");
		        
		        else
		        System.out.println(""NO"");
		    }
		}
	}
}
","import java.io.*;
import java.util.*;
public class Ishu
{
    static Scanner scan = new Scanner(System.in);
    static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out)); 
    static void tc() throws Exception
    {
    int n = scan.nextInt();
    String[] str = new String[n];
    int i, j;
    
    for(i=0;i<n;++i)
        str[i] = scan.next();
        
    String ans = ""NO"";
    for(i=0;i<n;++i)
        {
        String cur = str[i];
        int len = cur.length();
        if(cur.charAt(0) == cur.charAt(len - 1))
            {
            output.write(""YES\n"");
            output.flush();
            return;
            }
        }
        
    Map<String, Integer> map = new HashMap<String, Integer>();
    Map<String, Integer> par = new HashMap<String, Integer>();
    
    for(i=0;i<n;++i)
       {
       String cur = str[i];
       int len = cur.length();
       if(len == 2)
            {
            if(!map.containsKey(cur))
                map.put(cur, 0);
                
            int value = map.get(cur);
            ++value;
            map.remove(cur);
            map.put(cur, value);
            }
       else 
            {
            String pre = cur.substring(0, 2);
            if(!par.containsKey(pre))
                par.put(pre, 0);
            int value = par.get(pre);
            ++value;
            par.remove(pre);
            par.put(pre, value);
            
            if(!map.containsKey(cur))
                map.put(cur, 0);
            value = map.get(cur);
            ++value;
            map.remove(cur);
            map.put(cur, value);
            }     
       }
       
    for(i=n-1;i>=0;--i)
        {
        String cur = str[i];
        int len = cur.length();
        if(len == 2)
            {
            int value = map.get(cur);
            --value;
            map.remove(cur);
            if(value > 0)
                map.put(cur, value);
            }
        else
            {
            String pre = cur.substring(0, 2);
            int value = par.get(pre);
            --value;
            par.remove(pre);
            if(value > 0)
                par.put(pre, value);
                
            value = map.get(cur);
            --value;
            map.remove(cur);
            if(value > 0)
                map.put(cur, value);
            }    
        
        if(len == 2)
            {
            StringBuffer buffer = new StringBuffer(cur);
            buffer.reverse();
            String rev = String.valueOf(buffer);
            
            if(map.containsKey(rev) || par.containsKey(rev))
                {
                ans = ""YES"";
                break;
                }    
            }
        else
            {
            String suf = cur.substring(1, 3);
            StringBuffer buffer = new StringBuffer(suf);
            buffer.reverse();
            String rev = String.valueOf(buffer);
            
            if(map.containsKey(rev))
                {
                ans = ""YES"";
                break;
                }
            
            buffer = new StringBuffer(cur);
            buffer.reverse();
            rev = String.valueOf(buffer);
            
            if(map.containsKey(rev))
                {
                ans = ""YES"";
                break;
                }
            }
        }
        
    output.write(ans + ""\n"");
    output.flush();
    }
    
    public static void main(String[] args) throws Exception
    {
    int t = 1;
    t = scan.nextInt();
    while(t-- > 0)
        tc();
    }
}
",0,Non-plagiarised
0df4050e,6f02c6d9,"import java.io.*;
import java.util.*;

public class MainClass {
    public static void main(String[] args) {
        Reader in = new Reader(System.in);
        int t = in.nextInt();
        StringBuilder stringBuilder = new StringBuilder();
        while (t-- > 0) {
            ArrayList<Integer> reds = new ArrayList<>();
            ArrayList<Integer> blue = new ArrayList<>();
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt() - 1;
            }
            char[] s = in.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (s[i] == 'R') {
                    reds.add(a[i]);
                } else {
                    blue.add(a[i]);
                }
            }
            Collections.sort(reds, Collections.reverseOrder());
            Collections.sort(blue);
            boolean ff = true;
            int start = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < start) {
                    ff = false;
                    break;
                }
                start++;
            }
            start = n - 1;
            for (int i = 0; i < reds.size(); i++) {
                if (reds.get(i) > start) {
                    ff = false;
                    break;
                }
                start--;
            }
            stringBuilder.append(ff?""YES"":""NO"").append(""\n"");
        }
        System.out.println(stringBuilder);
    }
}

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

    

    

    

}
",1,Plagiarised
8532d5ed,b9595381,"import java.util.*;
import java.io.*;

public class C_Interesting_Story{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        ArrayList<String> list = new ArrayList<String>();
        for(int i=0;i<n;i++){
            String str=s.nextToken();
            list.add(str);
        }
        long max=Integer.MIN_VALUE;
        for(int i=97;i<102;i++){
            char ch=(char)i;
            ArrayList<Integer> nice = new ArrayList<Integer>();
            for(int j=0;j<n;j++){
                String obj=list.get(j);
                int count=0;
                for(int k=0;k<obj.length();k++){
                     char ch2=obj.charAt(k);
                     if(ch2==ch){
                         count++;
                     }
                }
                int num=obj.length()-count;
                nice.add(count-num);

            }
            Collections.sort(nice,Collections.reverseOrder());
            long sum=0;
            long counting=0;
            for(int j=0;j<nice.size();j++){
                sum+=nice.get(j);
                if(sum>0){
                    counting++;
                }
                else{
                    break;
                }
            }
            max=Math.max(max,counting);

        }
        res.append(max+""\n"");
        p++;
    }
    System.out.println(res);
    }
    




}
","import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
    
static int dest1;
static int dest2;
public static void main(String args[]){
       	FastScanner in = new FastScanner();
		int test=in.nextInt();
                while(test-->0){
                    int n=in.nextInt();
                    int count[][]=new int[n][5];
                    int total[]=new int[n];
                    String words[]=new String[n];
                    for(int i=0;i<n;i++){
                        words[i]=in.next();
                        for(int j=0;j<words[i].length();j++)
                            count[i][words[i].charAt(j)-'a']++;
                        
                        total[i]=words[i].length();
                    }
                    int max=Integer.MIN_VALUE;
                   for(int i=0;i<5;i++){
                       
                      Integer ans[]=new Integer[n];
                      for(int j=0;j<n;j++){
                          ans[j]=count[j][i]-(total[j]-count[j][i]);
                      }
                      Arrays.sort(ans,Collections.reverseOrder());
                      int j=0;
                      int r=0;
                      while(j<n && r+ans[j]>0){
                          r+=ans[j];
                          j++;
                      }
                      max=Math.max(j,max);
                      
                   }
                   System.out.println(max);
                   
                    
                }
}

       



}


",0,Non-plagiarised
8a729537,e270e909,"import java.io.*;
import java.util.*;

public class test3 {

	public static void main(String[] args) throws  IOException {
		FastReader f = new FastReader();
		int t = f.nextInt();
		while(t-->0) {
			 int n = f.nextInt();
			 int C[] = new int[n];
			 long ans=Long.MAX_VALUE,pre = 0;
			 PriorityQueue<Integer> epq = new PriorityQueue<Integer>();
			 PriorityQueue<Integer> opq = new PriorityQueue<Integer>();
			 for(int i = 0;i<n;i++) {
				 C[i] = f.nextInt();
				 if(i%2==0)epq.add(C[i]);
				 else opq.add(C[i]);
				 pre+=C[i];
				 if(i>0) {
					 ans  = Math.min(ans,pre+ ((long)n-(long)epq.size())*(long)epq.peek()
							 		+ ((long)n-(long)opq.size())*(long)opq.peek());
				 }
			 }
			 System.out.println(ans);
			}
    }
	
	
	
	

	
	
	
    
	  
		
	 
	 

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

public class GFG {
    
    
    
	public static void main (String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int t = sc.nextInt();
	     while(t-- > 0){
	         int n = sc.nextInt();
	         long pre = 0,ans = Long.MAX_VALUE;
	         long[] arr = new long[n];
	         PriorityQueue<Long> epq = new PriorityQueue<>();
	         PriorityQueue<Long> opq = new PriorityQueue<>();
	         for(int i=0;i<n;i++)
	         {
	             arr[i] = sc.nextLong();
	             if(i%2==0)
	             epq.add(arr[i]);
	             else
	             opq.add(arr[i]);
	             pre+=arr[i];
	             if(i>0)
	             ans = Math.min(ans,pre+(n-epq.size())*epq.peek()+(n-opq.size())*opq.peek());
	         }
	         System.out.println(ans);
	     }    
	}
}
",1,Plagiarised
93ee4612,da5cf40b,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int numTests = in.nextInt();
            for (int test = 0; test < numTests; test++) {
                int n = in.nextInt();
                char[] a = in.next().toCharArray();
                char[] b = in.next().toCharArray();
                int ka = 0;
                int kb = 0;
                int k11 = 0;
                int k01 = 0;
                for (int i = 0; i < n; i++) {
                    if (a[i] == '1') {
                        ++ka;
                    }
                    if (b[i] == '1') {
                        ++kb;
                    }
                    if (a[i] == '1' && b[i] == '1') {
                        ++k11;
                    }
                    if (a[i] == '0' && b[i] == '1') {
                        ++k01;
                    }
                }
                if (ka == 0) {
                    out.println(kb == 0 ? 0 : -1);
                    continue;
                }
                int ans = Integer.MAX_VALUE;
                if (ka == kb) {
                    ans = Math.min(ans, 2 * (ka - k11));
                }
                if (ka == n - kb + 1) {
                    int cur = 0;
                    if (k11 == 0) {
                        cur = 1 + 2 * (kb - k01);
                    } else {
                        cur = 1 + 2 * (kb - k01 - 1);
                    }
                    ans = Math.min(ans, cur);
                }

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

    }

    
}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    /* start */
   
       public static void main(String [] args)
    {
        // int testcases = 1;
        int testcases = i();
        while(testcases-->0)
        {
            
            solve();
        }
        out.flush();
        out.close();
    }
    static void solve()
    { 
        int n = i();
        char c[] = inputC();
        char d[] = inputC();
        int x01=0,x10=0,x00=0,x11=0;
        for(int i=0;i<n;i++)
        {
            if(c[i]=='0'&&d[i]=='0')x00++;
            if(c[i]=='0'&&d[i]=='1')x01++;
            if(c[i]=='1'&&d[i]=='0')x10++;
            if(c[i]=='1'&&d[i]=='1')x11++;
        }

        int ans = Integer.MAX_VALUE;
        if(x01==0 && x10==0)
        {
            System.out.println(0);
            return ;
        }
        if(x11==x00+1)
        {
            ans = Math.min(x11+x00,ans);
        }
      if(x01==x10)
        {
            ans = Math.min(x01+x10,ans);
        }
        if(ans == Integer.MAX_VALUE){
            ans = -1;
        }
        System.out.println(ans);
    }
    
    /* end */
     

    static int i() {
        return sc.nextInt();
    }


    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    

    

    

    
      
     

      

     
    
     

    
    

    

    

    

    

    

    

     

      

        
    
        
        //pair class
        
}
",0,Non-plagiarised
1eda0725,d2901569,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int k[]=new int[n];
            int h[]=new int[n];
            for(int i=0;i<n;i++)
            {
                k[i]=input.nextInt();
            }
            for(int i=0;i<n;i++)
            {
                h[i]=input.nextInt();
            }
            ArrayList<int []> list=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                int p=k[i]-h[i]+1;
                if(list.size()==0) list.add(new int[]{p,k[i]});
                else
                {
                    while(list.size()>0)
                    {
                        int j=list.size()-1;
                        int a[]=list.get(j);
                        int l=a[0],r=a[1];
                        int l1=p,r1=k[i];
                        if(l1>r)
                        {
                            list.add(new int[]{l1,r1});
                            break;
                        }
                        else if(l1>=l && l1<=r)
                        {
                            list.remove(j);
                            list.add(new int[]{l,r1});
                            break;
                        }
                        else
                        {
                            list.remove(j);
                        }
                    }
                    if(list.size()==0) list.add(new int[]{p,k[i]});
                }
            }
            long sum=0;
            for(int i=0;i<list.size();i++)
            {
                long d=list.get(i)[1]-list.get(i)[0]+1;
                long val=d*(d+1)/2;
                sum+=val;
            }
            out.println(sum);
        }
        out.close();
    }
    
}
","import java.util.*;
import java.util.Scanner;


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

		Scanner sc=new Scanner(System.in);
		int tt=sc.nextInt();
//		
//		
		while(tt-->0){
				int n=sc.nextInt();
			
				int k[]=new int[n];
				int h[]=new int[n];
				
				for(int i=0;i<n;i++) {
					k[i]=sc.nextInt();
				}
				for(int i=0;i<n;i++) {
					h[i]=sc.nextInt();
				}
				long ans=0;
				int start=k[0]-h[0]-1;
				int end=k[0];
				int last=0;
				for(int j=0;j<n;j++) {
					 start=k[j]-h[j]+1;
					 end=k[j];
					 last=j;
				for(int i=j+1;i<n;i++) {
					int temp=k[i]-h[i]+1;
					
					if(temp<=end) {
						start=Math.min(start, temp);
						end=Math.max(end, k[i]);
						last=i;
					}
					
					
					
				}
				j=last;
				
				long va=end-start+1;
				
				ans+=(va*(va+1))/2;
				
				}
				System.out.println(ans);
				
			
		}
	}
		
		
	
		
		
	
	
	


}
",0,Non-plagiarised
927384f2,d4779c71,"import java.util.*;
import java.io.*;

public class Main{
	      
	
	public static void main(String[] args) throws IOException{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int n = pint(in);
		Stack<Integer> min = new Stack<Integer>();
		Stack<Integer> max = new Stack<Integer>();
		
		int[] a = new int[n];
		int[] dp = new int[n];
		StringTokenizer st = new StringTokenizer(in.readLine());
		a[0] = pint(st);
		min.add(0);
		max.add(0);
		for(int i = 1; i < n; i++) {
			a[i] = pint(st);
			int h = dp[i - 1] + 1;
			while(!max.isEmpty() && a[i] > a[max.peek()]) {
				int k = a[max.peek()];
				h = Math.min(h, dp[max.pop()] + 1);
				while(!max.isEmpty() && a[max.peek()] == k) {max.pop();}
			}
			if(!max.isEmpty()) {
				h = Math.min(h, dp[max.peek()] + 1);
			}
			while(!min.isEmpty() && a[i] < a[min.peek()]) {
				int k = a[min.peek()];
				h = Math.min(h, dp[min.pop()] + 1);
				while(!min.isEmpty() && a[min.peek()] == k) {min.pop();}
			}
			if(!min.isEmpty()) {
				h = Math.min(h, dp[min.peek()] + 1);
			}
			dp[i] = h;
			min.add(i);
			max.add(i);
		}
		System.out.println(dp[n - 1]);
	}
	
    static int pint(BufferedReader in) throws IOException {return Integer.parseInt(in.readLine());}
    static int pint(StringTokenizer st) {return Integer.parseInt(st.nextToken());}
}
","import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class D {
    static Scanner sc = new Scanner(System.in);
    static int[] height;
    static int[] dp;

    public static void main(String[] args) {
        int n = sc.nextInt();
        height = new int[n];
        dp = new int[n];
        dp[0] = 0;
        for (int i = 0; i < n; i++) {
            height[i] = sc.nextInt();
        }
        Stack<Integer> rise = new Stack<Integer>();
        Stack<Integer> fail = new Stack<Integer>();
        rise.push(0);
        fail.push(0);
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i-1]+1;

            if (rise.isEmpty()) {
                rise.push(i);
            } else if (height[rise.peek()] < height[i]) {
                rise.push(i);
            } else {
                while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
                    rise.pop();
                    if (!rise.isEmpty()) {
                        dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
                    }
                }
                while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
                    rise.pop();
                }
                rise.push(i);
            }


            if (fail.isEmpty()) {
                fail.push(i);
            } else if (height[fail.peek()] > height[i]) {
                fail.push(i);
            } else {
                while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
                    fail.pop();
                    if (!fail.isEmpty()){
                        dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
                    }
                }
                while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
                    fail.pop();
                }
                fail.push(i);
            }
        }

        System.out.println(dp[n - 1]);

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

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","import java.util.*;
import java.io.*;


public class Main{

    public static void main(String[] args) throws java.io.IOException {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        int[][] dp=new int[n][n];
        int[][] min=new int[n][n];
        ArrayList<Integer> ones=new ArrayList<>();
        ArrayList<Integer> zero=new ArrayList<>();
        for(int i=0;i<n;++i) {
            arr[i] = sc.nextInt();
            if(arr[i]==1)
                ones.add(i);
            else
                zero.add(i);
        }
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j) {
                min[i][j] = Integer.MAX_VALUE;
                dp[i][j] = Integer.MAX_VALUE;
            }
        int len=ones.size();
        int zlen=zero.size();
        int minn=0;
        for(int i=0;i<len;++i)
        {
            int cur = ones.get(i);
            for(int j=i;j<zlen;j++)
            {
                int curz = zero.get(j);
                int cost = Math.abs(cur-curz);
                if(i!=0 && curz-1>=0)
                {
                    cost+=min[i-1][curz-1];
                }
                dp[i][curz]=cost;
            }
            minn=Integer.MAX_VALUE;
            for(int j=0;j<n;++j)
            {
                if(dp[i][j]<minn)
                    minn=dp[i][j];
                min[i][j]=minn;
            }
        }
        System.out.println(minn);
    }
}
",0,Non-plagiarised
3380fa52,e1a5831a,"import java.util.*;
import java.io.*;
import java.math.*;

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

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

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		for(int q=0;q<t;q++){
		    //  int n = Integer.parseInt(br.readLine());
		      String s = br.readLine();
                  String s1[] = br.readLine().split("" "");
                  int n = Integer.parseInt(s1[0]);
                  int k = Integer.parseInt(s1[1]);
                  String s2[] = br.readLine().split("" "");
                  int a[] = new int[k];
                  for(int i=0;i<k;i++){
                        a[i] = Integer.parseInt(s2[i]);
                  }
                  String s3[] = br.readLine().split("" "");
                  int b[] = new int[k];
                  for(int i=0;i<k;i++){
                        b[i] = Integer.parseInt(s3[i]);
                  }
                  long ans[] = new long[n];
                  for(int i=0;i<n;i++){
                        ans[i] = Integer.MAX_VALUE;
                  }
                  for(int i=0;i<k;i++){
                        ans[a[i]-1] = b[i];
                  }
                  for(int i=1;i<n;i++){
                        ans[i] = Math.min(ans[i],ans[i-1]+1);
                  }
                  for(int i=n-2;i>=0;i--){
                        ans[i] = Math.min(ans[i],ans[i+1]+1);
                  }
                  
                  for(int i=0;i<n;i++){
                        System.out.print(ans[i]+"" "");
                  }
                  System.out.println();
		}
	}
}
",0,Non-plagiarised
0e87b87f,6369a7a2,"import java.io.*;
import java.util.*;
public class table {
    
    public static void main(String[] args) throws java.io.IOException {
        File file = new File(""hoofball.in""); // change this
        FastReader input = new FastReader(); // change this
        PrintWriter output = new PrintWriter(""hoofball.out""); // change this or ph

        int testcases = input.nextInt();
        for (int t = 0; t < testcases; t++) {
            int rows = input.nextInt();
            int columns = input.nextInt();
            char[][] matrix = new char[rows][columns];
            for (int i = 0; i < rows; i++) {
                matrix[i] = input.next().toCharArray();
            }
            int counter = 0;
            ArrayList<String> list = new ArrayList<String>();
            for (int r = 0; r < rows - 1; r++) {
                for (int c = 0; c < columns - 1; c++) {
                    int r1 = r + 1;
                    int c1 = c + 1;
                    int r2 = r + 2;
                    int c2 = c + 2;
                    while (matrix[r][c] == '1' || matrix[r+1][c] == '1' || matrix[r][c+1] == '1' || matrix[r+1][c+1] == '1') {
                        if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 0 1 1 1
                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r+1][c] = '0';
                            matrix[r][c+1] = '0';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 1 0 1 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r][c+1] = '0';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 1 1 0 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r+1][c] = '0';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 1 1 1 0
                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r+1][c] = '0';
                            matrix[r][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 1 1 0 0
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c+1] = '1';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 0 0 1 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '1';
                            matrix[r+1][c] = '1';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 1 0 1 0
                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r+1][c] = '1';
                            matrix[r][c+1] = '0';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 0 1 0 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '1';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 1 0 0 0
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '0';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c+1] = '1';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '0') { // 0 1 0 0
                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r+1][c] = '0';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c+1] = '1';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 0 0 1 0
                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r+1][c] = '1';
                            matrix[r][c+1] = '0';
                            matrix[r+1][c+1] = '1';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 0 0 0 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '1';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '1') { // 1 1 1 1
                            list.add(r2 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c2);
                            matrix[r+1][c] = '0';
                            matrix[r][c+1] = '0';
                            matrix[r+1][c+1] = '0';
                        } else if (matrix[r][c] == '1' && matrix[r+1][c] == '0' && matrix[r][c+1] == '0' && matrix[r+1][c+1] == '1') { // 1 0 0 1
                            list.add(r1 +"" ""+ c1 +"" ""+ r1 +"" ""+ c2 +"" ""+ r2 +"" ""+ c1);
                            matrix[r][c] = '0';
                            matrix[r][c+1] = '1';
                            matrix[r+1][c] = '1';
                        } else if (matrix[r][c] == '0' && matrix[r+1][c] == '1' && matrix[r][c+1] == '1' && matrix[r+1][c+1] == '0') { // 0 1 1 0
                            list.add(r1 +"" ""+ c1 +"" ""+ r2 +"" ""+ c1 +"" ""+ r2 +"" ""+ c2);
                            matrix[r][c] = '1';
                            matrix[r+1][c] = '0';
                            matrix[r+1][c+1] = '1';
                        } else {
                            System.out.println(""error"");
                        }
                        counter++;
                    }
                }
            }
            System.out.println(counter);
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
        }

        output.close();
    }
}
","import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class C2 {
    static ArrayList<Integer[]> list;

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            list = new ArrayList<>();
            int n = in.nextInt();
            int m = in.nextInt();
            char[][] arr = new char[n][m];
            for (int j = 0; j < n; j++) {
                arr[j] = in.next().toCharArray();
            }
            for (int j = 0; j < n; j += 2) {
                for (int k = 0; k < m; k += 2) {
                    if (j == n - 1) j = n - 2;
                    if (k == m - 1) k = m - 2;
                    int cnt = 0;
                    while (arr[j][k] == '1' || arr[j + 1][k] == '1' || arr[j][k + 1] == '1' || arr[j + 1][k + 1] == '1') {
//                        System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);

                        if (checkThree(arr, j, k)) {
//                            System.out.println(""3:"");
//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
                            continue;
                        } else if (checkTwo(arr, j, k)) {
//                            System.out.println(""2:"");
//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
                            checkThree(arr, j, k);
//                            System.out.println(""3:"");
//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
                            continue;
                        } else if (checkDiagonal(arr, j, k)) {
//                            System.out.println(""/2:"");
//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
                        } else if (checkOne(arr, j, k)) {
//                            System.out.println(""1:"");
//                            System.out.println(arr[j][k] + "" "" + arr[j][k + 1] + ""\n"" + arr[j + 1][k] + "" "" + arr[j + 1][k + 1]);
                        }
//                        cnt++;
//                        if (cnt == 10) return;
//                        System.out.println();
                    }
//                    System.out.println(""qwe"");
//                    System.out.println(""qwe"");
                }
            }
            out.println(list.size());
            for (Integer[] integers : list) {
                for (int j = 0; j < integers.length; j++) {
                    out.print((integers[j] + 1) + "" "");
                }
                out.println();
            }
        }
        out.close();
    }

    public static boolean checkThree(char[][] arr, int i, int j) {
        if (arr[i][j] == '1' && arr[i][j + 1] == '1' && arr[i + 1][j] == '1') {
            arr[i][j] = '0';
            arr[i][j + 1] = '0';
            arr[i + 1][j] = '0';
            list.add(new Integer[]{i, j, i, (j + 1), (i + 1), j});
            return true;
        } else if (arr[i][j] == '1' && arr[i][j + 1] == '1' && arr[i + 1][j + 1] == '1') {
            arr[i][j] = '0';
            arr[i][j + 1] = '0';
            arr[i + 1][j + 1] = '0';
            list.add(new Integer[]{i, j, i, (j + 1), (i + 1), j + 1});
            return true;
        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1' && arr[i][j] == '1') {
            arr[i + 1][j] = '0';
            arr[i + 1][j + 1] = '0';
            arr[i][j] = '0';
            list.add(new Integer[]{i + 1, j, i + 1, j + 1, (i), j});
            return true;
        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1' && arr[i][j + 1] == '1') {
            arr[i + 1][j] = '0';
            arr[i + 1][j + 1] = '0';
            arr[i][j + 1] = '0';
            list.add(new Integer[]{i + 1, j, i + 1, j + 1, (i), j + 1});
            return true;
        }
        return false;
    }

    public static boolean checkDiagonal(char[][] arr, int i, int j) {
        if (arr[i][j] == '1' && arr[i + 1][j + 1] == '1') {
            arr[i][j] = '0';
            arr[i][j + 1] = '1';
            arr[i + 1][j] = '1';
            list.add(new Integer[]{i, j, i, j + 1, (i + 1), j});
            return true;
        } else if (arr[i + 1][j] == '1' && arr[i][j + 1] == '1') {
            arr[i + 1][j] = '0';
            arr[i][j] = '1';
            arr[i + 1][j + 1] = '1';
            list.add(new Integer[]{i + 1, j, i, j, (i + 1), j + 1});
            return true;
        }
        return false;
    }

    public static boolean checkOne(char[][] arr, int i, int j) {
        if (arr[i][j] == '1') {
            arr[i][j] = '0';
            arr[i + 1][j] = '1';
            arr[i][j + 1] = '1';
            list.add(new Integer[]{i, j, i + 1, j, (i), j + 1});
            return true;
        } else if (arr[i + 1][j] == '1') {
            arr[i + 1][j] = '0';
            arr[i][j] = '1';
            arr[i + 1][j + 1] = '1';
            list.add(new Integer[]{i + 1, j, i, j, (i + 1), j + 1});
            return true;
        } else if (arr[i][j + 1] == '1') {
            arr[i][j + 1] = '0';
            arr[i][j] = '1';
            arr[i + 1][j + 1] = '1';
            list.add(new Integer[]{i, j + 1, i, j, (i + 1), j + 1});
            return true;
        } else if (arr[i + 1][j + 1] == '1') {
            arr[i + 1][j + 1] = '0';
            arr[i + 1][j] = '1';
            arr[i][j + 1] = '1';
            list.add(new Integer[]{i + 1, j + 1, i + 1, j, (i), j + 1});
            return true;
        }
        return false;
    }

    public static char changeValue(char c) {
        return c == '1' ? '0' : '1';
    }

    public static boolean checkTwo(char[][] arr, int i, int j) {
        if (arr[i][j] == '1' && arr[i][j + 1] == '1') {
            arr[i][j] = '0';
            arr[i + 1][j + 1] = changeValue(arr[i + 1][j + 1]);
            arr[i + 1][j] = changeValue(arr[i + 1][j]);
            list.add(new Integer[]{i, j, i + 1, j + 1, (i + 1), j});
            return true;
        } else if (arr[i][j] == '1' && arr[i + 1][j] == '1') {
            arr[i][j] = '0';
            arr[i + 1][j + 1] = changeValue(arr[i + 1][j + 1]);
            arr[i][j + 1] = changeValue(arr[i][j + 1]);
            list.add(new Integer[]{i, j, i + 1, j + 1, (i), j + 1});
            return true;
        } else if (arr[i + 1][j] == '1' && arr[i + 1][j + 1] == '1') {
            arr[i + 1][j] = '0';
            arr[i][j + 1] = changeValue(arr[i][j + 1]);
            arr[i][j] = changeValue(arr[i][j]);
            list.add(new Integer[]{i + 1, j, i, j + 1, (i), j});
            return true;
        } else if (arr[i][j + 1] == '1' && arr[i + 1][j + 1] == '1') {
            arr[i][j + 1] = '0';
            arr[i][j] = changeValue(arr[i][j]);
            arr[i + 1][j] = changeValue(arr[i + 1][j]);
            list.add(new Integer[]{i, j + 1, i, j, (i + 1), j});
            return true;
        }
        return false;
    }

    
}
",0,Non-plagiarised
585af783,f7a0ea6d,"import java.util.*;
import java.io.*;
public class codeforces {

    public static void main(String []args){
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        while(t-->0)   {
            int n = sc.nextInt();
            String s[] = new String[n];
            for(int i=0;i<n;i++)
                s[i] = sc.next();
            int a[][] = new int[n][6];
            for(int i=0;i<n;i++)
                for(int j=0;j<s[i].length();j++){
                    a[i][s[i].charAt(j)-'a']++;
                }
            for(int i=0;i<n;i++)
                a[i][5] = s[i].length();
            int ans=0;
           for(int i=0;i<5;i++)
           {
             ans = Math.max(ans,help(a,i,n));
           }
           System.out.println(ans);
        }
    }
    public static int help(int a[][],int i,int n){
        int total=0,count=0,count1=0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        for(int j=0;j<n;j++)
        {
            if(2*a[j][i]-a[j][5]>0)
            {
                total+=(2*a[j][i]-a[j][5]);
                count++;
            }
            else if(2*a[j][i]-a[j][5]==0)
                count1++;
            else
                pq.add(a[j][5]-2*a[j][i]);
        }
        if(count>0)
        {
            count+=count1;
            int value=0;
            while(!pq.isEmpty()&&value<total){
                value+=pq.peek();
                pq.remove();
                count++;
            }
            if(value>=total)
                count--;
        }
        return count;
    }
    
    
}
","import java.util.*;

public class Solution {
	
	private static Scanner in = new Scanner(System.in);
	
	public static void main(String args[]) {
		
		int t = in.nextInt();
		
		while(t-->0) {
			solution();
		}
	}
	
	private static void solution() {
		
		int ans=0;
		int n = in.nextInt();
		String s[] = new String[n];
		int occurance[][] = new int[n][5];
		for(int i=0;i<n;i++) {
			s[i] = in.next();
			for(int j=0;j<s[i].length();j++) {
				occurance[i][s[i].charAt(j)-'a']++;
			}
		}
		
//		for(int i=0;i<n;i++)
//		{
//			for(int j=0;j<5;j++)
//				System.out.println(occurance[i][j]);
//			System.out.println();
//		}
		
		for(int i=0;i<5;i++) {
			int arr[] = new int[n];
			for(int j=0;j<n;j++) {
				arr[j] = s[j].length() - (2 * occurance[j][i]);
			}
			Arrays.sort(arr);
			
//			for(int j=0;j<n;j++)
//				System.out.println(arr[j]);
			
			int temp=0;
			int count=0;
			for(int j=0;j<n;j++) {
				if(temp+arr[j] < 0)
				{
					count++;
					temp += arr[j];
				}
				else 
					break;
			}
			ans = Math.max(ans, count);
		}
		System.out.println(ans);
	}
}
",0,Non-plagiarised
35bb6075,ed728769,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.util.*;

public class Main {

    static final long M = 1000000007;

    // use main for only io
    public static void main(String args[]) {
        FastReader io = new FastReader();
        new Solver().solve(io);
    }
}

//class Pair{
//    int key;String value;
//
//    public Pair(int key, String value){
//        this.key = key;
//        this.value = value;
//    }
//}



class Solver {
    static final int M = 998244353;

    void solve(FastReader io) {
       int t = io.nextInt();

       while(t-- > 0){
           int n = io.nextInt();

           String s[] = new String[n];

           for(int i = 0;i < n;i++)s[i] = io.nextLine();

           int ans = 0;

           for(int i = 0;i < 5;i++){
               int count[] = new int[n];

               for(int j = 0;j < n;j++){
                   int freq = 0;
                   for(int k = 0;k < s[j].length();k++){
//                       System.out.println(s[j].charAt(k) - 'a');
                       if((s[j].charAt(k) - 'a') == i){

                           freq++;
                       }
                   }
//                    System.out.println(i + "" "" + freq);
                   count[j] = 2*freq - s[j].length();
               }


               Arrays.sort(count);
//                for(int it : count)System.out.print(it + "" "");
//                System.out.println();

               int curr = 0;
               int j = n - 1;
               for(;j >= 0 && (curr + count[j] > 0);j--){
                   curr += count[j];
               }

               ans = Math.max(ans, n - j - 1);

           }

           System.out.println(ans);
       }
    }

    // returns the first key greater than or equal to val
    

    // returns the first key strictly greater than val
    
    

    

    

    

    

    

    
}



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

public class Solution
{
    
    
   
  
  
  
  
  
  static long dp[][];
  
  
 
  
    // Updates a node in Binary Index Tree (BITree)
    // at given index in BITree. The given value 
    // 'val' is added to BITree[i] and all of 
    // its ancestors in tree.
    
    
    
   
    public static void main(String []args) throws IOException
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
       // sc.nextLine();
        while(t-- > 0)
        {
            int n = sc.nextInt();
            sc.nextLine();
            //String s = sc.nextLine();
            int arr[][] = new int[26][n];
            for(int i = 0 ; i < n ; i++)
            {
                String s = sc.nextLine();
                
                for(int j = 0 ; j < 26 ; j++)
                {
                    int cnt = 0;
                    for(int k = 0 ; k < s.length() ; k++)
                    {
                        if(s.charAt(k)-'a' == j)
                        cnt++;
                    }
                    arr[j][i] = 2*cnt-s.length();
                }
            }
            
            int ans = 0;
            for(int i = 0 ; i < 26 ; i++)
            {
             Arrays.sort(arr[i]);   
             int tot = 0;
             for(int j = n-1 ; j >= 0 ;j--)
             {
                 tot += arr[i][j];
                 if(tot <= 0)
                 break;
                 
                 ans = Math.max(ans,n-j);
             }
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
cc669e02,d88fa51c,"import java.util.*;
public class Codeforces {


	// CHECK CONSTRAINTS ALWAYS EDGE CASE MISSED 
	
static int mod = 1000000007;	




public static void main(String[] args) {
     Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
   int t   =  sc.nextInt();
   while(t-->0) {
	  	 
	int n =  sc.nextInt();
	long k = sc.nextLong();
	long a[] = new long[n+1];
	for(int i = 1 ; i<=n;i++) {
		a[i] = sc.nextLong();
	}
	a[0] = -1;
	Arrays.sort(a);
	
	long sum = 0;
	for(int i = 1 ; i<=n;i++) {
		sum+=a[i];
	}
	
	if(sum<=k) {
		System.out.println(0);
	}
	else if(sum == k+1) {
		System.out.println(1);
	}
	else {
		long ans = sum-k;
		
		long diff = sum - k;
	         sum = 0;
	  for(int i = n ; i>1 ; i--) {
		long x = 0;
		  sum+=a[i];
		  if(sum - (n-i+1)*a[1] >= diff) {
			  x = 0;
		  }
		  else {
			  x = (long) Math.max(Math.ceil((double)(diff - sum + ((n-i+1)*a[1]))/(n-i+2)) , 0);
	      
		  }
		
		  ans = Math.min(ans, x +n-i+1);
		  
	  }
	  System.out.println(ans);
	         
	         
	}
	
	
	
	

		
	 
	   
	   
	   
	   
	   
	   
	   
   }
     }
    }
    }
","import java.util.*;
import java.io.*;
import java.math.BigInteger;
 
public class code{
 
    
    
    
    //@SuppressWarnings(""unchecked"")
    public static void main(String[] arg) throws IOException{
        //Reader in=new Reader();
        
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner(System.in);
        
        int t=in.nextInt();
        
        while(t-- > 0){
          int n=in.nextInt();
          long k=in.nextLong();

          PriorityQueue<Long> pq=new PriorityQueue<Long>();
          long[] sum=new long[n+1];

          for(int i=0;i<n;i++){
            long a=in.nextLong();
            pq.offer(a);
            //sum[i+1]=arr[i]+sum[i];
          }

          
          for(int i=1;i<=n;i++){
            sum[i]=pq.poll()+sum[i-1];
          }

          long min=(long)1e18;
          for(int i=0;i<n;i++){
            long x=sum[1]-floor(k-sum[n-i]+sum[1],(long)i+1);
            min=Math.min(min,(long)i+Math.max(0L,x));
          }

          out.println(min);
        }
 
        out.flush();
    }

    public static long floor(long a,long b){
      long z=a/b;
      if(b*z>a) z--;
      return z;
    }
 
}
",0,Non-plagiarised
51d88c51,c2b7b017,"import java.awt.Container;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

import java.util.*;

public class Main
{
   
    public static boolean check(int a[],int value)
    {
           int b[]= new int[a.length];
           for (int i = a.length-1; i >=2; i--) {
            if(a[i]+b[i]<value)
            {
                return false;
            }
            int d = Math.min(a[i], (a[i]+b[i]-value));
            b[i-1]+=d/3;
            b[i-2]+=(2*(d/3));
            
        }
        
        
        
        if(a[0]+b[0]<value||a[1]+b[1]<value)
        {
            return false;
        }
        return true;
        
    }
   
    public static void main(String[] args)
    {
        FastScanner input = new FastScanner();
        StringBuilder result = new StringBuilder();
        int tc = input.nextInt();
        work:
        while (tc-- > 0) {
          int n = input.nextInt();
        int a[]= new int[n];
     
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            a[i] = input.nextInt();
            min = Math.min(min, a[i]);
            max = Math.max(max, a[i]);
            
        }
        int low = min;
        int high  = max;
        int ans = 0;
        while(low<=high)
        {
            int mid = low+(high-low)/2;
            if(check(a, mid))
            {
                ans = mid;
                low = mid+1;
            }
            else
            {
                high = mid-1;
            }
            
            
        }
        result.append(ans+""\n"");
           
        }
        System.out.println(result);
        
       
    }

    

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

//
public class Example {
    

    public static void main(String[] args) {
        FastReader sc = new FastReader();

        int t= sc.nextInt();
        while(t>0){
            t--;
            int ans=Integer.MAX_VALUE;
            int n=sc.nextInt();
            int[] ar= new int[n];
            int l=Integer.MAX_VALUE;
            int h=Integer.MIN_VALUE;
            for(int i=0;i<n;i++){
                ar[i]=sc.nextInt();
                l=Math.min(l,ar[i]);
                h=Math.max(h,ar[i]);

            }
            int[] extra;
            while(l<=h){
                int mid=l+(h-l)/2;
                if(possibleans(ar,mid)){
                    ans=mid;
                    l=mid+1;
                }else{
                    h=mid-1;
                }
            }
            System.out.println(ans);


        }
    }

    private static boolean possibleans(int[] ar, int mid) {
int[] extra=new int[ar.length];
        for(int i=ar.length-1;i>=2;i--){
            if((ar[i]+extra[i]-mid)<0){
                return false;
            }
            int d=Math.min(ar[i],extra[i]+ar[i]-mid);
            extra[i-1]=extra[i-1]+d/3;
            extra[i-2]+=2*(d/3);

        }
        int a=ar[0]+extra[0];
        int b=ar[1]+extra[1];
        return (a>=mid && b>=mid);

    }

    
}
",1,Plagiarised
624b8db5,e9986d44,"import java.io.*;
import java.util.*;
public class C
{
    private static ArrayDeque<Integer>[] edge;
    private static HashMap<String,Integer> map;

    private static String getHash(int u, int v)
    {
        if(u>v)
        {
            int tmp=u;
            u=v;
            v=tmp;
        }

        return u+"" ""+v;
    }
    private static void DFS(int u, int p, int[] ans, int val)
    {
        for(int v:edge[u])
        {
            if(v==p) continue;
            ans[map.get(getHash(u,v))]=val;

            DFS(v,u,ans,5-val);
            val=5-val;
        }
    }
    public static void main(String[] args) throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int i,N;

        int T=Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();

        while (T-->0)
        {
            N=Integer.parseInt(br.readLine().trim());
            edge=new ArrayDeque[N];
            for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();

            map=new HashMap<>();
            int[] ans=new int[N-1];
            int[] deg=new int[N];

            for(i=0;i<N-1;i++)
            {
                String[] s=br.readLine().trim().split("" "");
                int u=Integer.parseInt(s[0])-1;
                int v=Integer.parseInt(s[1])-1;

                edge[u].add(v); edge[v].add(u);
                deg[u]++; deg[v]++;

                map.put(getHash(u,v),i);
            }

            for(i=0;i<N;i++) if(deg[i]>2) break;
            if(i<N)
            {
                sb.append(-1).append(""\n"");
                continue;
            }

            DFS(0,0,ans,2);
            for(int x:ans) sb.append(x).append("" "");
            sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;



public class cp23 {
	static BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
	static int mod = 1000000007;
	static String toReturn = """";

	static int steps = Integer.MAX_VALUE;
	static int maxlen = 1000005;
	
	
	
	/*MATHEMATICS FUNCTIONS START HERE
	MATHS
	MATHS
	MATHS
	MATHS*/
	

	
	
	
	
	
	/*
	 * static long [] seive(long n) {
	 * 
	 * }
	 */
	/*MATHS
	MATHS
	MATHS
	MATHS
	MATHEMATICS FUNCTIONS END HERE */
	
	/*SWAP FUNCTION START HERE
	  SWAP
	  SWAP
	  SWAP
	  SWAP
	 */
	
	/*SWAP
	  SWAP
	  SWAP
	  SWAP
	 SWAP FUNCTION END HERE*/
	
	
	
	/*BINARY SEARCH METHODS START HERE
	 * BINARY SEARCH
	 * BINARY SEARCH
	 * BINARY SEARCH
	 * BINARY SEARCH
	 */
	
	
	
	/*BINARY SEARCH
	 * BINARY SEARCH
	 * BINARY SEARCH
	 * BINARY SEARCH
	 * BINARY SEARCH
	 BINARY SEARCH METHODS END HERE*/
	
	
	/*RECURSIVE FUNCTION START HERE
	 * RECURSIVE
	 * RECURSIVE
	 * RECURSIVE
	 * RECURSIVE
	 */
	
	
	/*RECURSIVE
	 * RECURSIVE
	 * RECURSIVE
	 * RECURSIVE
	 * RECURSIVE
	 RECURSIVE FUNCTION END HERE*/
	
	/*GRAPH FUNCTIONS START HERE
	 * GRAPH
	 * GRAPH
	 * GRAPH
	 * GRAPH
	 * */
	static class edge{
		int from, to, weight;
		public edge(int x, int y, int z) {
			this.from = x;
			this.to = y;
			this.weight = z;
		}
	}
	static void addEdge(ArrayList<ArrayList<edge>> graph, int from, int to, int weight) {
		edge temp = new edge(from, to, weight);
		edge temp1 = new edge(to, from, weight);
		graph.get(from).add(temp);
		graph.get(to).add(temp1);
	}
	static int ans = 0;
	static void dfs(ArrayList<ArrayList<edge>> graph, int vertex, boolean [] visited, int [] toReturn, int weight) {
		//System.out.println(graph.get(vertex).size());
		if(visited[vertex]) return;
		visited[vertex] = true;
		if(graph.get(vertex).size() > 2) return;
		for(int i = 0; i < graph.get(vertex).size(); i++) {
			edge temp = graph.get(vertex).get(i);
			if(!visited[temp.to]) {
				//System.out.println(temp.to);
				toReturn[temp.weight] = weight;
				dfs(graph, temp.to, visited, toReturn, 5 - weight);
				weight = 5 - weight;
			}
		}
	}
	
	
	
	
	/*GRAPH FUNCTIONS END HERE
	 * GRAPH
	 * GRAPH
	 * GRAPH
	 * GRAPH
	 */
	/*disjoint Set START HERE
	 * disjoint Set
	 * disjoint Set
	 * disjoint Set
	 * disjoint Set
	 */
	static int [] rank;
	static int [] parent;
	
	
	/*disjoint Set END HERE
	 * disjoint Set
	 * disjoint Set
	 * disjoint Set
	 * disjoint Set
	 */
	
	
	/*INPUT START HERE
	 * INPUT
	 * INPUT
	 * INPUT
	 * INPUT
	 * INPUT
	 */
	
	static int nexInt() throws NumberFormatException, IOException {
		return Integer.parseInt(sc.readLine());
	}
	
	
	static int [] inputIntArr() throws NumberFormatException, IOException{
		String [] s = sc.readLine().split("" "");
		int [] toReturn = new int[s.length];
		for(int i = 0; i < s.length; i++) {
			toReturn[i] = Integer.parseInt(s[i]);
		}
		return toReturn;
	}
	/*INPUT
	 * INPUT
	 * INPUT
	 * INPUT
	 * INPUT
	 * INPUT END HERE
	 */
	static void solve() throws IOException {
		
		int n = nexInt();
		ArrayList<ArrayList<edge>> tree = new ArrayList<>();
		for(int i = 0; i < n; i++) tree.add(new ArrayList<edge>());
		for(int i = 0; i < n - 1; i++) {
		int [] s1 = inputIntArr();
		addEdge(tree, s1[0] - 1, s1[1] - 1, i);
		}
		int vertex = 0;
		for(int i = 0; i < tree.size(); i++) {
			if(tree.get(i).size() > 2) {
				System.out.println(-1);
				return;
			}else if(tree.size() == 1) {
				vertex = i;
			}
		}
		int [] toReturn = new int[n - 1];
		//toReturn.add(2);
		dfs(tree, vertex, new boolean[n], toReturn,  2);
		//System.out.println(toReturn.size());
		
		
			for(int i = 0; i <  toReturn.length; i++) 
				if(toReturn[i] != 0)System.out.print(toReturn[i] + "" "");
			System.out.println();
		
		
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		 int t = Integer.parseInt(sc.readLine()); for(int i = 0; i < t; i++) 
		  solve();
		
		
	}
	}
",0,Non-plagiarised
c1fef98f,f870e76b,"import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Test{

        static FastReader scan;

        static void solve(){
            scan.nextLine();
            int n=scan.nextInt();
            int k=scan.nextInt();
            int []arr=new int[n+1];

            int []block=new int[k];
            int []temp=new int[k];

            for(int i=0;i<k;i++){
                block[i]=scan.nextInt();
            }

            for(int i=0;i<k;i++){
                temp[i]=scan.nextInt();
            }

            for(int i=0;i<k;i++){
                arr[block[i]]=temp[i];
            }
            int []dp=new  int[n+1];
            int prev=Integer.MAX_VALUE-1000;
            for(int i=1;i<=n;i++){
                if(arr[i]==0){
                    if(prev==Integer.MAX_VALUE-1000){
                        dp[i]=prev;
                    }
                    else{
                        prev=prev+1;
                        dp[i]=prev;
                    }
                }
                else{
                    prev=Math.min(prev+1,arr[i]);
                    dp[i]=prev;
                }
            }

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

            for(int i=1;i<=n;i++){
                System.out.print(dp[i]+"" "");
            }
            System.out.println();

        }

        public static void main (String[] args) throws java.lang.Exception{
            scan=new FastReader();
            int t=scan.nextInt();
            while(t-->0){
                solve();                  
            }
        }

        

                

        

        

        

        

           

        

        

        

        
        

        
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;

public class Main {

	static InputStream inputStream = System.in;
	static OutputStream outputStream = System.out;
	static InputReader in = new InputReader(inputStream);
	static PrintWriter out = new PrintWriter(outputStream);

	public static void main(String[] args) {

		int t = in.nextInt();

		while (t-- > 0) {

			int n = in.nextInt();

			int k = in.nextInt();

			int[] v1 = new int[k];
			int[] v2 = new int[k];

			for (int i = 0; i < k; i++) {
				v1[i] = in.nextInt();
			}

			for (int i = 0; i < k; i++) {
				v2[i] = in.nextInt();
			}
			
			
			
			//wejhfduiwehiofhw

			int[] res = new int[n + 2];

			Arrays.fill(res, 2000000000);

			for (int i = 0; i < k; i++) {
				res[v1[i]] = v2[i];

			}

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

				int val = Math.min(res[i], res[i - 1] + 1);

				res[i] = val;

			}
			
			//ewhfowiejp
			
			
			
			
			
			
			
			
			
			//wedhciuwahidochqowi
			
			
			
			
			
			
			
			
			//wjdhoiqwnlidhqw
			for (int i = n; i >= 1; i--) {
				int val1 = Math.min(res[i], res[i + 1] + 1);
				res[i] = val1;
				// out.println(res[i]);
			}

			for (int i = 1; i <= n; i++) {
				int r = res[i];
				out.print(r + "" "");

			}

			out.println();

		}

		out.close();
	}

	

	

}
",0,Non-plagiarised
169e34bf,fae0662f,"import java.util.*;
public class D{
  static Scanner sc;
  public static void solve(){
    int n=sc.nextInt();
    Integer a[]=new Integer[n];
    int flag;
    for(int i=0;i<n;i++) a[i]=sc.nextInt();
    String s=sc.next();
    ArrayList<Integer> x=new ArrayList<>();
    ArrayList<Integer> y=new ArrayList<>();
    for(int i=0;i<n;i++){
      if(s.charAt(i)=='B') x.add(a[i]);
      else y.add(a[i]);
    }
    Collections.sort(x);
    Collections.sort(y);
    int p=n;
    int q=1;
    for(int i=y.size()-1;i>=0;i--){
      if(y.get(i)>p){System.out.println(""NO""); return;}
      p-=1;
    }
    for(int i=0;i<x.size();i++){
      if(x.get(i)<q){System.out.println(""NO""); return;}
      q+=1;
    }
    System.out.println(""YES"");
  }
  public static void main(String args[]){
      sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0) solve();
  }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
	
	public static void main(String[] args) throws IOException {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		
		int t = fs.nextInt();
		for (int tc = 0; tc < t; tc++) {
			int n = fs.nextInt();
			int[] a = fs.readArray(n);
			String s = fs.nextLine();
			
			// let all blue to be 1 -> blueCount
			ArrayList<Integer> blues = new ArrayList<Integer>();
			ArrayList<Integer> reds = new ArrayList<Integer>();
			
			for (int i = 0; i < s.length(); i++) {
				if (s.charAt(i) == 'B') {
					blues.add(a[i]);
				} else {
					reds.add(a[i]);
				}
			}
			
			Collections.sort(blues);
			Collections.sort(reds);
			
			boolean ok = true;
			
			for (int i = 1; i <= blues.size(); i++) {
				if (blues.get(i - 1) < i) {
					ok = false;
					break;
				}
			}
			
			for (int i = blues.size() + 1; i <= n; i++) {
				if (reds.get(i - blues.size() - 1) > i) {
					ok = false;
					break;
				}
			}
			
			if (ok) {
				out.println(""YES"");
			} else {
				out.println(""NO"");
			}
		}
		
		out.close();
	}
	
	
}
",1,Plagiarised
5af25bd7,77ec956f,"import java.io.*;
import java.util.*;
 
public class MySolution {
    public static void main(String[] args) throws Exception {
        BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder out = new StringBuilder();
        int numOfTestCases = Integer.parseInt(bu.readLine());
        for (int tc = 1; tc <= numOfTestCases; tc++) {
            int vertices = Integer.parseInt(bu.readLine());
            connections = new ArrayList[vertices];
            for (int i = 0; i < vertices; i++) {
                connections[i] = new ArrayList<Integer>();
                String st[] = bu.readLine().split("" "");
                a[i][0] = Integer.parseInt(st[0]);
                a[i][1] = Integer.parseInt(st[1]);
                s[i][0] = s[i][1] = 0;
            }
            for (int j = 0; j < vertices-1; j++) {
                String st[] = bu.readLine().split("" "");
                int u = Integer.parseInt(st[0]) - 1, v = Integer.parseInt(st[1]) - 1;
                connections[u].add(v);
                connections[v].add(u);
            }
            dfs(0, -1);
            out.append(Math.max(s[0][0], s[0][1]) + ""\n"");
        }
        System.out.print(out);
    }
 
    static int N = 100000;
    static int[][] a = new int[N][2];
    static long[][] s = new long[N][2];
    static ArrayList<Integer>[] connections;
 
    public static void dfs(int n, int parent) {
        for (int child : connections[n]) {
            if (child != parent) {
                dfs(child, n);
                s[n][0] += Math.max(s[child][0] + Math.abs(a[n][0] - a[child][0]), s[child][1] + Math.abs(a[n][0] - a[child][1]));
                s[n][1] += Math.max(s[child][0] + Math.abs(a[n][1] - a[child][0]), s[child][1] + Math.abs(a[n][1] - a[child][1]));
            }
        }
    }
}
","import java.io.*;
import java.util.*;

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

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

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

    static ArrayList<Integer> g[];
    static int N=100000,a[][]=new int[N][2];
    static long s[][]=new long[N][2];
    static void dfs(int n,int p)
    {
        for(int x:g[n])
        if(x!=p)
        {
            dfs(x,n);
            s[n][0]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][0]),s[x][1]+Math.abs(a[x][1]-a[n][0]));
            s[n][1]+=Math.max(s[x][0]+Math.abs(a[x][0]-a[n][1]),s[x][1]+Math.abs(a[x][1]-a[n][1]));
        }
    }
}
",1,Plagiarised
8ad1ad84,f652c678,"import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	 static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<Integer> g[];
	static long L[],R[],dp[][];
	public static void main(String args[])throws IOException
	{  					
		int T=i();
		outer:while(T-->0)
		{
			int N=i();
			setGraph(N);
			for(int i=1; i<=N; i++)
			{
				L[i]=l();
				R[i]=l();
			}
			for(int i=1; i<N; i++)
			{
				int a=i(),b=i();
				g[a].add(b);
				g[b].add(a);
			}
			f(1,-1);
			out.println(Math.max(dp[0][1], dp[1][1]));
		}
		out.close();
		//print(L);
		//print(R);
		
		//print(dp[0]);
		//print(dp[1]);
		

	}	
	static void f(int n,int p)
	{
		for(int c:g[n])
		{
			if(c!=p)
			{
			f(c,n);
			long a=dp[0][c]+Math.abs(L[c]-L[n]);
			long b=dp[1][c]+Math.abs(R[c]-L[n]);
			dp[0][n]+=Math.max(a, b);
			a=dp[0][c]+Math.abs(L[c]-R[n]);
			b=dp[1][c]+Math.abs(R[c]-R[n]);
			dp[1][n]+=Math.max(a, b);
			}
		}
	}
	

	
	


	
	

	
	
	
	

	

	
	
	
	
	

	
	static void setGraph(int N)
	{
		g=new ArrayList[N+1];
		dp=new long[2][N+1];
		L=new long[N+1];
		R=new long[N+1];
		for(int i=0; i<=N; i++)
		{

			g[i]=new ArrayList<Integer>();
		}
	}

	
	
	
	
	
	

	//Debugging Functions Starts

	
	
	
	
	

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

	static long l()
	{
		return in.nextLong();
	}

	

	

	//IO FUNCTIONS END

}



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

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

public class C {
    static long mod = (long) 1e9 + 7;
    static long mod1 = 998244353;
    static ArrayList<Integer>[] adj;
    static HashMap<String,Long> hmap;
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);


        int t = in.nextInt();
        while (t-- > 0) {

            int n = in.nextInt();
            adj = new ArrayList[n + 1];
            for (int i = 0; i <= n; i++)
                adj[i] = new ArrayList<>();
            long[][] dp = new long[n + 1][2];
            hmap=new HashMap<>();
            for (int i = 1; i <= n; i++) {
                dp[i][0] = in.nextLong();
                dp[i][1] = in.nextLong();
            }
            for (int i = 0; i < n - 1; i++) {
                int u = in.nextInt();
                int v = in.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            long[] x=DFS(dp,1,-1);
            out.println(Math.max(x[0],x[1]));
        }
        out.close();
    }

    static long[] DFS(long[][] dp,int s,int prev) {

        long max=0;
        long min=0;
        for (int i : adj[s]) {
            if (i != prev) {
                long[] dd=DFS(dp,i,s);
                min+=Math.max(Math.abs(dp[s][0]-dp[i][0])+dd[0],Math.abs(dp[s][0]-dp[i][1])+dd[1]);
                max+=Math.max(Math.abs(dp[s][1]-dp[i][0])+dd[0],Math.abs(dp[s][1]-dp[i][1])+dd[1]);
            }
        }
        return new long[] {min,max};

    }


    static final Random random = new Random();

    

    

    

    

    

    

    

    

    
}
",0,Non-plagiarised
3a12e509,fae0662f,"import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
	
	public static void main(String[] args) throws IOException {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		
		int t = fs.nextInt();
		for (int tc = 0; tc < t; tc++) {
			int n = fs.nextInt();
			int[] a = fs.readArray(n);
			String s = fs.nextLine();
			
			// let all blue to be 1 -> blueCount
			ArrayList<Integer> blues = new ArrayList<Integer>();
			ArrayList<Integer> reds = new ArrayList<Integer>();
			
			for (int i = 0; i < s.length(); i++) {
				if (s.charAt(i) == 'B') {
					blues.add(a[i]);
				} else {
					reds.add(a[i]);
				}
			}
			
			Collections.sort(blues);
			Collections.sort(reds);
			
			boolean ok = true;
			
			for (int i = 1; i <= blues.size(); i++) {
				if (blues.get(i - 1) < i) {
					ok = false;
					break;
				}
			}
			
			for (int i = blues.size() + 1; i <= n; i++) {
				if (reds.get(i - blues.size() - 1) > i) {
					ok = false;
					break;
				}
			}
			
			if (ok) {
				out.println(""YES"");
			} else {
				out.println(""NO"");
			}
		}
		
		out.close();
	}
	
	
}
",0,Non-plagiarised
29cf2e70,b2001d68,"import java.util.*;
import java.io.*;
 
public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();
 
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }
 
            Collections.sort(blue);
            Collections.sort(red);
 
            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class D753 {
    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        try {
            // Scanner sc=new Scanner(System.in);
            FastReader sc = new FastReader();
            int t = sc.nextInt();
            while (t-- > 0) {
                int n=sc.nextInt();
                int[] arr=new int[n];
                for(int i=0;i<n;i++){
                    arr[i]=sc.nextInt();
                }
                
                char[] color=sc.next().toCharArray();
                ArrayList<Integer> b=new ArrayList<>();
                ArrayList<Integer> r=new ArrayList<>();
                for(int i=0;i<n;i++){
                    if(color[i]=='B')b.add(arr[i]);
                    else r.add(arr[i]);
                }
                Collections.sort(b);
                Collections.sort(r);
                boolean ok=true;
                int cur=1;
                for(int i:b){
                    if(i>=cur)cur++;
                    else{
                        ok=false;
                        break;
                    }
                    //cur++;
                }
                for(int i:r){
                    if(i<=cur)cur++;
                    else{
                        ok=false;
                        break;
                    }
                }
                if(ok)System.out.println(""YES"");
                else System.out.println(""NO"");
            }
        } catch (Exception e) {
            return;
        }

    }
    

    

    

    

    

    
    

    

    

    

    
}
",1,Plagiarised
1adac634,ee0bc145,"import java.io.*;
import java.util.*;


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

    public static void main(String[] args) {

        t = fs.nextInt();

        while (t-- > 0) {

            n = fs.nextInt();

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

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

            List<Pair> arr = new ArrayList<>();

            for(i=0;i<n;i++){
                int a = k[i]-h[i]+1;

                arr.add(new Pair(a,k[i]));
            }

            Collections.sort(arr);

            ans=0;

            List<Pair> comp = new ArrayList<>();
            int temp = arr.get(0).x;
            int tempy = arr.get(0).y;
            for(i=1;i<n;i++){

                if(arr.get(i).x > tempy){
                    comp.add(new Pair(temp, tempy));
                    temp = arr.get(i).x;
                    tempy = arr.get(i).y;
                }

                else tempy = Math.max(tempy, arr.get(i).y);
            }

            comp.add(new Pair(temp, tempy));


            for(i=0;i<comp.size();i++){

                long a = comp.get(i).y - comp.get(i).x +1 ;

                ans+=(((a)*(a+1))/2);
            }

            out.println(ans);


        }

        out.close();
    }

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

        return (a*b)%mod;
    }

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

        fact[1] = 1;

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


    

    

    

    static long add(long a, long b) {
        return ((a % mod) + (b % mod)) % mod;
    }

    

    

    

    


    static class Pair implements Comparable<Pair> {
        public int x, y;

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

        


    }

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

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0) {
            int n = sc.nextInt();
            int[] k = new int[n];
            int[] h = new int[n];
            for (int i = 0; i < n; ++i) k[i] = sc.nextInt();
            for (int i = 0; i < n; ++i) h[i] = sc.nextInt();
            Stack<Pair> stk = new Stack<>();
            stk.push(new Pair(0, 0));

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

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


    
}
",0,Non-plagiarised
05ca89ed,163d0dde,"import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer; 
import java.util.*;
  
public class er106c
{ 
    //By shwetank_verma
	public static void main(String[] args) 
    { 
        FastReader sc=new FastReader(); 
        try{
           
                int t=1;
                t=sc.nextInt();
                while(t-->0){
                int n=sc.nextInt();
                long o=n,e=n;
                long maxo=Integer.MAX_VALUE;
                long maxe=Integer.MAX_VALUE;
                long ans=Long.MAX_VALUE;
                long temp=0;
                
                int a[]=new int[n];
                for(int i=0;i<n;i++){
                    a[i]=sc.nextInt();
                }
                for(int i=0;i<n;i++) {
                	if(i%2==1) {
                		temp+=a[i];
                		e--;
                		maxe=Long.min(maxe, a[i]);
                		ans=Long.min(ans,temp+(o*maxo)+(e*maxe));
                	}
                	else {
                		temp+=a[i];
                		o--;
                		maxo=Long.min(maxo, a[i]);
                		ans=Long.min(ans,temp+(o*maxo)+(e*maxe));
                	}
                }
                System.out.println(ans);
                
                
        
                }
           
            
        }catch(Exception e){
            return;
        }
    }
     
    static int mod=1000000007;
    static boolean primes[]=new boolean[1000007];
    static ArrayList<Integer> b=new ArrayList<>();
    
    
    
    
      


  
     
}
","import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.*;
  
public class aa
{ 
     
   
    public static void main(String[] args) 
    {
            FastReader d=new FastReader();
            int t,i,j,c,z,k,l,n;
            int mod = (int) 1e9 + 7;
            int Inf=Integer.MAX_VALUE;
            int negInf=Integer.MIN_VALUE;
        t=d.nextInt();
        //t=1;
        //String s;
        //char ch,ch1,ch2,ch3;
        while(t-->0)
        {
            z=c=0;
            n=d.nextInt();
            int a[]=new int[n];
            for(i=0;i<n;i++)
            a[i]=d.nextInt();
            //s=d.nextLine();//dont need extra d.nextLine()
            long p=0;
            long ans;
            long x,y;
            long e,o;
            ans=Long.MAX_VALUE;
            x=y=Integer.MAX_VALUE;
            e=o=n;
            for(i=0;i<n;i++) {
                if(i%2==1) {
               	p+=a[i];
               	e--;
               	x=Long.min(x, a[i]);
               	ans=Long.min(ans,p+(o*y)+(e*x));
               	}
               	else {
               	p+=a[i];
               	o--;
               	y=Long.min(y, a[i]);
               	ans=Long.min(ans,p+(o*y)+(e*x));
                	}
                }
                System.out.println(ans);
        }
    } 
}
",1,Plagiarised
4552d8a0,ec4c7e8e,"import java.util.*;
import java.io.*;

////***************************************************************************
 /* public class E_Gardener_and_Tree implements Runnable{

       public static void main(String[] args) throws Exception {
        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
       }
    public void run(){
         WRITE YOUR CODE HERE!!!!
         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
       }

  }
*/
/////**************************************************************************


public class D_Blue_Red_Permutation{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
      //  PrintWriter out=new PrintWriter(System.out);
        //end of program
        //out.println(answer);
        //out.close();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        long array[]= new long[n];
        for(int i=0;i<n;i++){
            array[i]=s.nextLong();
        }
        String str=s.nextToken();
        ArrayList<Long> red = new  ArrayList<Long>();
        ArrayList<Long> blue = new  ArrayList<Long>();
        for(int i=0;i<n;i++){
            if(str.charAt(i)=='R'){
                red.add(array[i]);
            }
            else{
                blue.add(array[i]);
            }
        }
        Collections.sort(blue);
        int check1=0;
        for(int i=0;i<blue.size();i++){
            int yo=i+1;
            if(blue.get(i)<yo){
                check1=1;
                break;
            }
        }
        Collections.sort(red,Collections.reverseOrder());
        int number=n;
        int check2=0;
        for(int i=0;i<red.size();i++){
             if(red.get(i)>number){
                 check2=1;
                 break;
             }
             number--;
        }
        if(check1==0 && check2==0){
            res.append(""YES\n"");
        }
        else{
            res.append(""NO\n"");
        }
        p++;
    }
    System.out.println(res);
    }
    




}
","import java.util.*;
public class the_child_and_set
{
	public static void main(String args[])
	{
		Scanner in=new Scanner(System.in);
		int t=in.nextInt();
		in.nextLine();
		while(t--!=0)
		{
			int n=in.nextInt();
			int arr[]=new int[n];
			for(int i=0;i<n;i++)
			{
				arr[i]=in.nextInt();
			}
			in.nextLine();
			String s=in.nextLine();
			int rc=0;
			int bc=0;
			for(int i=0;i<n;i++)
			{
				if(s.charAt(i)=='B')
					bc++;
				else
					rc++;
			}
			int r[]=new int[rc];
			int b[]=new int[bc];
			int bi=0;
			int ri=0;
			for(int i=0;i<n;i++)
			{
				if(s.charAt(i)=='B')
				{
					b[bi]=arr[i];
					bi++;
				}
				else
				{
					r[ri]=arr[i];
					ri++;
				}
			}
			Arrays.sort(b);
			Arrays.sort(r);
			boolean flag=true;
			for(int i=0;i<bi;i++)
			{
				if(b[i]<(i+1))
				{
					flag=false;
					break;
				}
			}
			if(flag)
			{
				for(int i=0;i<ri;i++)
				{
					if(r[i]>bi+(i+1))
					{
						flag=false;
						break;
					}
				}
			}
			if(flag)
				System.out.println(""YES"");
			else
				System.out.println(""NO"");
		}
	}
}
",0,Non-plagiarised
0c0af0ff,d6a8d884,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("""");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    
    
    void solve() throws IOException {
        for (int tc=ni();tc>0;tc--) {
            int n=ni();
            int[]A=new int[n];
            long[]T=new long[n];
            A[0]=ni();
            T[0]=A[0];
            long total=0;
            for (int i=1;i<n;i++) { A[i]=ni(); T[i]=T[i-1]+A[i]; } 
            
            long[]B=new long[n];
            long lefteven=n-1;
            long leftodd=n;
            int mineven=A[0];
            int minodd=A[1];
            long ans=Long.MAX_VALUE;
            
            for (int i=1;i<n;i++) {
                if (i%2==1) {
                    leftodd--;
                    minodd=Math.min(minodd,A[i]);
                    B[i]=T[i]+lefteven*mineven+leftodd*minodd;
                }
                else {
                    lefteven--;
                    mineven=Math.min(mineven,A[i]);
                    B[i]=T[i]+lefteven*mineven+leftodd*minodd;
                }
                ans=Math.min(ans,B[i]);
            }
            
            out.println(ans);
        }
        out.flush();
    }
    
    
    
    
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}
","import java.util.*;
import java.io.*;
import java.math.*;
import java.text.*;
public class C{
public static void main(String[] omkar) throws Exception
{
   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
   StringTokenizer st = new StringTokenizer(in.readLine());
   StringBuilder sb = new StringBuilder();
   int cases = Integer.parseInt(st.nextToken());
   for(int i = 0; i < cases; i++)
   {
      solve(in, st, sb);
   }  
   System.out.println(sb);
        }
 public static void solve(BufferedReader in, StringTokenizer st, StringBuilder sb) throws Exception
 {
      st = new StringTokenizer(in.readLine());
      int n = Integer.parseInt(st.nextToken());
      int[] arr = readArr(n, in, st);
      int[] mins = new int[n];
      mins[0] = arr[0];
      mins[1] = arr[1]; 
      for(int i = 2; i < n; i++)
      {
         mins[i] = Math.min(arr[i], mins[i-2]);
      }
      long[] sums = new long[n];
      sums[0] = (long)(arr[0]);
      for(int i = 1; i < n; i++)
      {
         sums[i] = sums[i-1]+(long)(arr[i]);
      }
      long minc = Long.MAX_VALUE;
      long temp;
      for(int i = 1; i < n; i++)
      {
         temp = sums[i];
         temp += (long)(mins[i])*(long)(n-(i+2)/2);
         temp += (long)(mins[i-1])*(long)(n-(i+1)/2);
         minc = Math.min(minc, temp);
      }
      sb.append(minc+""\n"");
 }
 public static int[] readArr(int N, BufferedReader in, StringTokenizer st) throws Exception
      {
         int[] arr = new int[N];
         st = new StringTokenizer(in.readLine());
         for(int i=0; i < N; i++)
            arr[i] = Integer.parseInt(st.nextToken());
         return arr;
      }


}
",0,Non-plagiarised
25597bcb,86232d21,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class PhoenixAndTowers { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        
    }

    

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int T = Integer.parseInt(f.readLine());
        for (int i = 0; i < T; i++) {
            StringTokenizer st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(f.readLine());
            List<Integer> list = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                int a = Integer.parseInt(st.nextToken());
                list.add(a);
            }
            ArrayList<Integer> copy = new ArrayList<>(list);
            Collections.sort(list);
            TreeSet<List<Integer>> set = new TreeSet<>(new ListComparator());
            for (int j = 1; j <= m; j++) {
                List<Integer> temp = new ArrayList<>();
                temp.add(0);
                temp.add(j);

                set.add(temp);
                // System.out.println(temp);
            }
            // System.out.println(set);
            Map<Integer, LinkedList<Integer>> map = new HashMap<>();
            for (int j = n - 1; j >= 0; j--) {
                if (map.containsKey(list.get(j))) {
                    map.get(list.get(j)).addLast(set.first().get(1));
                } else {
                    map.put(list.get(j), new LinkedList<>());
                    map.get(list.get(j)).addLast(set.first().get(1));
                }
                List<Integer> temp = new ArrayList<>();
                temp.add(set.first().get(0) + list.get(j));
                temp.add(set.pollFirst().get(1));
                set.add(temp);
            }
            // System.out.println(set);

            if (set.last().get(0) - set.first().get(0) > x) {
                out.println(""NO"");
            } else {
                out.println(""YES"");
                for (int j = 0; j < n; j++) {
                    out.print(map.get(copy.get(j)).pollFirst() + "" "");
                }
                out.println();
            }
        }
        out.close();
    }

}
","import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class C {

	static class Token implements Comparable<Token> {
		final int i, h;

		Token(int i, int h) {
			this.i = i;
			this.h = h;
		}

		
	}

	static void solve() throws Exception {
		int tests = scanInt();
		for (int test = 0; test < tests; test++) {
			int n = scanInt(), m = scanInt();
			scanInt();
			PriorityQueue<Token> pq = new PriorityQueue<>();
			int h[] = new int[m];
			int ans[] = new int[n];
			for (int i = 0; i < m; i++) {
				pq.add(new Token(i, 0));
			}
			for (int i = 0; i < n; i++) {
				Token cur = pq.remove();
				pq.add(new Token(cur.i, h[cur.i] += scanInt()));
				ans[i] = cur.i;
			}
			out.println(""YES"");
			for (int i = 0; i < n; i++) {
				out.print((ans[i] + 1) + "" "");
			}
			out.println();
		}
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}
",0,Non-plagiarised
81a9086f,baebdc56,"import java.io.*;
import java.util.*;
 
public class D 
{	
	static long mod=998244353;
	static long[] facts, factInvs;
	
	public static void main(String[] args)throws IOException 
	{	
		FastReader f=new FastReader();
		StringBuffer sb = new StringBuffer();
		
		int n=f.nextInt();
		int k=f.nextInt();
		
		Time time[]=new Time[n];
		for(int i=0;i<n;i++)
		{
			int x=f.nextInt();
			int y=f.nextInt();
			
			time[i]=new Time(x,y);
		}
		Arrays.sort(time);
		precomp();
//		for(Time t : time)
//			System.out.println(t.x+"" ""+t.y);
		
		int curr=0;
		long ans=0;
		Queue<Integer> pq=new PriorityQueue<>();
		for(int i=0;i<n;i++)
		{	
//			System.out.println(""time seg = ""+time[i].x+"" ""+time[i].y);
			int x=time[i].x;
			pq.add(time[i].y);
			curr++;
			while(!pq.isEmpty() && pq.peek()<x)
			{	
				pq.poll();
				curr--;
			}
//			System.out.println(""curr = ""+curr);

			if(curr<k)
				continue;
			else
			{	
				long add=getNcR(curr-1,k-1)%mod;
				ans=(ans%mod + add)%mod;
//				System.out.println(""add = ""+add);
			}
		}
		System.out.println(ans);
	}
	
	static void precomp() 
	{
		facts=new long[1000000];
		factInvs=new long[1000000];
		factInvs[0]=facts[0]=1;
		
		for (int i=1; i<facts.length; i++)
			facts[i]=mul(facts[i-1], i);
		
		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
		
		for (int i=facts.length-2; i>=0; i--)
			factInvs[i]=mul(factInvs[i+1], i+1);
	}
	
	static long getNcR(int n, int k) {
		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
	}
	
	static long mul(long a, long b) {
		return a*b%mod;
	}
	
	static long modInv(long x) {
		return exp(x, mod-2);
	}
	
	static long exp(long base, long e) 
	{
		if (e==0) 
			return 1;
		long half=exp(base, e/2);
		if (e%2==0) 
			return mul(half, half);
		else
			return mul(half, mul(half, base));
	}
	
	static class Time implements Comparable<Time>
	{
		int x,y;
		Time(int x,int y)
		{
			this.x=x;
			this.y=y;
		}
		
	}
	
	 
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class D {
	
	static final int mod=998244353;
	
	static long[] facts, factInvs;

	public static void main(String[] args) {
		precomp();
		FastScanner fs=new FastScanner();
		int n=fs.nextInt(), k=fs.nextInt();
		Seg[] segs=new Seg[n];
		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
		Event[] events=new Event[n*2];
		for (int i=0; i<n; i++) {
			events[2*i]=new Event(segs[i], true);
			events[2*i+1]=new Event(segs[i], false);
		}
		long ans=0;

		Arrays.sort(events);
		int counter=0;
		for (Event e:events) {
			if (e.start) {
				counter++;
			}
			else {
				counter--;
				if (counter+1<k)
					continue;
				else
					ans=add(ans, nCk(counter, k-1));
			}
		}
		System.out.println(ans);
	}

	static final Random random=new Random();
	
	
	
	static long add(long a, long b) {
		return (a+b)%mod;
	}
	
	static long mul(long a, long b) {
		return a*b%mod;
	}
	
	static long exp(long base, long e) {
		if (e==0) return 1;
		long half=exp(base, e/2);
		if (e%2==0) return mul(half, half);
		return mul(half, mul(half, base));
	}
	
	static long modInv(long x) {
		return exp(x, mod-2);
	}
	
	static void precomp() {
		facts=new long[1_000_000];
		factInvs=new long[1_000_000];
		factInvs[0]=facts[0]=1;
		for (int i=1; i<facts.length; i++)
			facts[i]=mul(facts[i-1], i);
		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
		for (int i=facts.length-2; i>=0; i--)
			factInvs[i]=mul(factInvs[i+1], i+1);
	}
	
	static long nCk(int n, int k) {
		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
	}
	
	static class Seg {
		int l, r;
		public Seg(int l, int r) {
			this.l=l;
			this.r=r;
		}
	}
	
	static class Event implements Comparable<Event> {
		boolean start;
		Seg s;
		public Event(Seg s, boolean start) {
			this.s=s;
			this.start=start;
		}

		
		
		
	}
	
	

	
}
",0,Non-plagiarised
14b0fb8e,6490bbe8,"import java.io.*;

import java.util.*;
 public class Solution {
	 
	static long res;
	public static void main(String[] args) throws Exception
    {
		FastReader fr=new FastReader();
        int n=fr.nextInt();
        ArrayList<Integer> oc=new ArrayList<>();
        ArrayList<Integer> em=new ArrayList<>();
        res=Long.MAX_VALUE;
        for(int i=0;i<n;i++) {
        	int v=fr.nextInt();
        	if(v==1)
        		oc.add(i);
        	else
        		em.add(i);
        }
        Collections.sort(oc);
        Collections.sort(em);
        long dp[][]=new long[5001][5001];
        for(int i=0;i<dp.length;i++) {
        	for(int j=0;j<dp[i].length;j++) {
        		dp[i][j]=-1;
        	}
        }
        System.out.println(getMin(oc,em,0,0,dp));
        
        
		
    }
	public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
	   if(idx==oc.size())
		   return 0;
		long available=em.size()-j;
		long req=oc.size()-idx;
		if(available<req)
			return Integer.MAX_VALUE;
		if(dp[idx][j]!=-1)
			return dp[idx][j];
		
		long ch1=getMin(oc,em,idx,j+1,dp);
		long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
		
		return dp[idx][j]=Math.min(ch1,ch2);
		
	}
	
		
	
	 

	
	 
	 
	 
	 
	 
	 
	 
	
		
	 
	 
	 
	 
	 
	
	 
	 
	
	 
	 
            	  
             
             
    }


	
	 
	
	

	 
 
  


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

//           THIS TEMPLATE MADE BY AKSH BANSAL.

public class Solution {
    
    private static boolean[] isPrime;
    
    
    
    // static ArrayList<Integer>[] adj;
    // static void getAdj(int n,int q, FastReader sc){
    //     adj = new ArrayList[n+1];
    //     for(int i=1;i<=n;i++){
    //         adj[i] = new ArrayList<>();
    //     }
    //     for(int i=0;i<q;i++){
    //         int a = sc.nextInt();
    //         int b = sc.nextInt();

    //         adj[a].add(b);
    //         adj[b].add(a);
    //     }
    // }
    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        // primes();
        // ________________________________

        // int t = sc.nextInt();
        // StringBuilder output = new StringBuilder();

        // while (t-- > 0) {

        //     output.append(solver()).append(""\n"");
        // }

        // out.println(output);
        // _______________________________

        int n = sc.nextInt();
        int arr[] = new int[n];
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        out.println(solver(n, arr));
        // ________________________________
        out.flush();
    }

    public static long solver(int n, int[] arr) {
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            if(arr[i] ==1){
                a.add(i);
            }
            else{
                b.add(i);
            }
        }
        // System.out.println(""__""+ a);
        // System.out.println(""__""+ b);
        long inf = (long)1e10;
        int aLen = a.size(), bLen = b.size();
        long[][] dp = new long[bLen+1][aLen+1];
        for(int i=0;i<bLen+1;i++)Arrays.fill(dp[i],inf);
        // dp[0][0] = 0;
        for(int i=0;i<=bLen;i++){
            dp[i][0] = 0;
        }
        for(int i=1;i<=bLen;i++){
            for(int j=1;j<=i && j<=aLen;j++){
                int aa = a.get(j-1);
                int bb = b.get(i-1);
                // System.out.println((i-1)+"" ""+(j-1)+""__""+ aa+"" ""+bb);
                dp[i][j] = Math.min(
                    Math.abs(aa-bb)+dp[i-1][j-1],
                    dp[i-1][j]
                );
                // System.out.println((i-1)+"" ""+(j-1)+""__""+ dp[i][j]);
            }
        }
        // for(int i=0;i<=bLen;i++){
        //     for(int j=0;j<=aLen;j++){
        //         System.out.print(dp[i][j]+"" "");
        //     }
        //     System.out.println(""__"" );
        // }
        return dp[bLen][aLen]==inf?0:dp[bLen][aLen];
    }
}
",0,Non-plagiarised
701c3f35,d56bcb0c,"import java.util.*;
import java.io.*;

public class Menorah {

	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(f.readLine());
		while(t-->0) {
			int n=Integer.parseInt(f.readLine());
			String s=f.readLine();
			String s2=f.readLine();
			int[] arr=new int[4];
			//0 00 1 01 2 10 3 11
			for(int i=0;i<n;i++) {
				if(s.charAt(i)=='0') {
					if(s2.charAt(i)=='0') {
						arr[0]++;
					}
					else {
						arr[1]++;
					}
				}
				else {
					if(s2.charAt(i)=='0') {
						arr[2]++;
					}
					else {
						arr[3]++;
					}
				}
			}
			int min=Integer.MAX_VALUE;
			if(arr[1]==arr[2]) {
				min=arr[1]*2;
			}
			int temp=arr[1];
			arr[1]=arr[3];
			arr[3]=temp;
			temp=arr[0];
			arr[0]=arr[2];
			arr[2]=temp;
			arr[3]++;
			arr[1]--;
			if(arr[1]==arr[2]) {
				min=Math.min(min, arr[1]*2+1);
			}
			System.out.println(min!=Integer.MAX_VALUE?min:-1);
		}
	}

}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
    static int func(char a[],char b[]){
        int n=a.length;
        int a1=0,b1=0;
        for(int i=0;i<n;i++){
            if(a[i]=='1')a1++;
            if(b[i]=='1')b1++;
        }
        if(a1!=b1)return 100000000;
        int cnt=0;
        for(int i=0;i<n;i++){
            if(a[i]=='1'&&b[i]!='1')cnt++;
        }
        return cnt*2;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    //int t=1;
	   int t=Integer.parseInt(br.readLine());
	    while(--t>=0){
	           int n=Integer.parseInt(br.readLine());
	           char a[]=br.readLine().toCharArray();
	          char b[]=br.readLine().toCharArray();
	         int x=func(a,b);
	         int ind=-1;
	         for(int i=0;i<n;i++){
	             if(a[i]==b[i]&&a[i]=='1'){
	                 ind=i;
	                 break;
	             }
	         }
	         int y=100000000;
	         if(ind>=0){
	             for(int i=0;i<n;i++){
	                 if(i==ind)continue;
	                 if(a[i]=='1')a[i]='0';
	                 else a[i]='1';
	             }
	             y=func(a,b)+1;
	         }
	         if(x>=1000000&&y>=1000000){
	             System.out.println(-1);
	         }
	         else
	        System.out.println(Math.min(x,y));
	     
	        
	    }
	    
	}
}
",0,Non-plagiarised
04df7bb8,85125ecb,"import java.math.BigInteger;
										import java.sql.Array;
									    import java.util.ArrayList;
										import java.util.Arrays;
										import java.util.Collection;
										import java.util.Collections;
										import java.util.Comparator;
										import java.util.Deque;
										import java.util.HashMap;
										import java.util.HashSet;
										import java.util.InputMismatchException;
										import java.util.LinkedList;
										import java.util.PriorityQueue;
										import java.util.Queue;
										import java.util.Scanner;
										import java.util.Set;
										import java.util.Stack;
										import java.io.BufferedReader;
										import java.io.IOException;
										import java.io.InputStream;
										import java.io.InputStreamReader;
										import java.util.Scanner;
										import java.util.StringTokenizer;
										import java.util.TreeMap;
										import java.util.TreeSet;
										
											
											
											
											
											
											public class Main {
							
												
												static HashMap<Integer,Boolean>map;
												
											static long dp[][];
											static 	boolean flag;
										static	HashSet<Long>hs;
											static long mod=(long)(1e9+7);
												public static void main(String[] args) {
												StringBuilder ans=new StringBuilder();
												FastReader sc=new FastReader();
													
												
												int t=sc.nextInt();
												
												
												while(t-->0) {
													
													int n=sc.nextInt();
													
													
													//int n=sb.length();
													
													
													
													int k=sc.nextInt();
													
													
													long L[]=new long[n];
													long R[]=new long[n];
													int a[]=new int[k];
													int temp[]=new int[k];
													
													for(int i=0;i<k;i++)
														a[i]=sc.nextInt();
													
													for(int i=0;i<k;i++)
														temp[i]=sc.nextInt();
													
													int c[]=new int [n];
													Arrays.fill(c, Integer.MAX_VALUE);
													for(int i=0;i<k;i++)
														c[a[i]-1]=temp[i];
												
													long p=Integer.MAX_VALUE;
													
													for(int i=0;i<n;i++)
													{
														p=Math.min(p+1, c[i]);
														
														L[i]=p;
														
														
													}
													p=Integer.MAX_VALUE;
													for(int i=n-1;i>=0;i--)
													{
														p=Math.min(p+1, c[i]);
														
														R[i]=p;
														
														
													}
													
													for(int i=0;i<n;i++)
													{
														ans.append(Math.min(L[i], R[i])+"" "");
													}
											ans.append(""\n"");
													
												}
												System.out.println(ans);
												
												}
													
											
													


												
												
							
												
												
												
												
												
												
												
												
											
												
												
												
												
												
												
												
												
												
												
												
												
												
													
													
												
												
												
												
												
												
												
												
												
												
												
												
												
												
												
									
												
												
											
												
										
												
												
												
												
												
											 
												
											 
												
												
												
											
												
											
												
												
												
												
												
												 
												  
												
												   
												
									
												//System.out.println(count);
												
											
												
												
												
												
												
												
										
										
												
										
												
												
												
												
												//	System.out.println(max);
										
												
											
												
											
									
				//System.out.println(ans.toString());
				//main(						
											
							
					
				
						
												
												
												
								
												
								
												
												
								
												
												
												
												
												
												
												
									
									
												
												
												
												
								
								
								
							
								
									
												
												
												
								
												
												
												
									
							
												
									
									
												
												
												
												
												
												
												
												
												
												
												
									
										
										
										
										
				
				
					
				
				
										
											
																					
											
									    
									 
										
											}
","import java.io.*;
import java.util.Arrays;
import java.util.Hashtable;

public class AirConditionersUpsolve{
    

    // region variables
    static InputReader sc = new InputReader();
    static OutputStream outputStream = System.out;
    static PrintWriter w = new PrintWriter(outputStream);
    // endregion

    private static void initiateIO()
            throws IOException {if (System.getProperty(""ONLINE_JUDGE"") == null) { try { w = new PrintWriter(""output.txt"");sc = new InputReader(new FileInputStream(""input.txt"")); } catch (Exception e) { throw new IOException(); }} }

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

        initiateIO();

        int t = sc.nextInt();
        while(t-- > 0) {
            solve();
        }

        w.close();

    }

    static void solve() throws IOException {
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] ac = new int[n+1];
        Arrays.fill(ac, Integer.MAX_VALUE);
        int[] pos = new int[k+1];
        for(int i = 1; i <= k; i++) {
            pos[i] = sc.nextInt();
        }
        for(int i = 1; i <= k; i++) {
            int posi = pos[i];
            int temp = sc.nextInt();
            ac[posi] = temp;
        }

        long[] prev = new long[n+1];

        long temp = Integer.MAX_VALUE;
        for(int i = 1; i <= n; i++) {
            temp = Math.min(temp+1, ac[i]);
            prev[i] = temp;
        }

        long[] next = new long[n+1];

        temp = Integer.MAX_VALUE;
        for(int i = n; i > 0; i--) {
            temp = Math.min(temp+1, ac[i]);
            next[i] = temp;
        }

        for(int i = 1; i <= n; i++) {
            w.print(Math.min(prev[i], next[i])+"" "");
        }
        w.println();
    }
}
",1,Plagiarised
0d11fb94,8c79c384,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;


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

    static List<Integer> zeros = new ArrayList<>();
    static List<Integer> ones = new ArrayList<>();
    static int oneCount = 0;
    static int[][] dp = new int[5005][5005];

    public static void main(String[] args) {
        t = 1;

        while (t-- > 0) {

            n = fs.nextInt();

            for(int i = 0;i<n;i++){
                x = fs.nextInt();
                if(x==1){
                    ones.add(i);
                    oneCount++;
                }
                else
                    zeros.add(i);
            }

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

            out.println(minCost(0,0));
        }

        out.close();
    }

    static int minCost(int zIndex, int oIndex){

        if(oIndex == ones.size())
            return 0;
        if(zIndex == zeros.size())
            return 1000000007;

        if(dp[zIndex][oIndex]==-1)
            dp[zIndex][oIndex]= Math.min(Math.abs(zeros.get(zIndex) - ones.get(oIndex))+minCost(zIndex+1, oIndex+1) , minCost(zIndex+1, oIndex));

        return dp[zIndex][oIndex];
    }


    

    

    

    

    


}
","import java.util.*;

import javax.print.attribute.HashAttributeSet;


import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
public class CP {
	  
	 static int mod  = 1000000007;
	 
	 
	 
	 
	 	
	 
	 

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

		static void TEST_CASE() {
			int n = sc.nextInt();
			int[] arr = new int[n];
			for(int i = 0 ; i< n ;i++) {
				arr[i] = sc.nextInt();
			}
			
			ArrayList<Integer> ao = new ArrayList<Integer>();
			ArrayList<Integer> az = new ArrayList<Integer>();
			for(int i = 0 ; i< n ;i++) {
				if(arr[i] == 1) ao.add(i);
				else az.add(i);
			}
			long[][] dp = new long[n+1][n+1];
			for(int i = 0 ; i<n ; i++) Arrays.fill(dp[i], -1);
			
			sb.append(fnc(dp, ao, az, 0, 0));
			
		}
		static long fnc(long[][] dp ,ArrayList<Integer> ao , ArrayList<Integer> az ,int i , int j) {
			if(i == ao.size()) return 0;
			if(j == az.size()) return Long.parseLong(""1000000000000"");
			if(dp[i][j] != -1) return dp[i][j];
			long a = Math.abs(ao.get(i) - az.get(j)) + fnc(dp, ao, az, i+1, j+1);
			long b = fnc(dp, ao, az, i, j+1);
			dp[i][j] = Math.min(a, b);
			return dp[i][j];
			
		}
		
}
",0,Non-plagiarised
680ba922,ee4b9467,"import java.util.*;
import java.io.*;

public class Solution
{
    
    
   
  
  
  
  
  
  
  
 
  
    // 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.io.*;
import java.util.*;
 
public class _1615c {
    FastScanner scn;
    PrintWriter w;
    PrintStream fs;

    long MOD = 1000000007;
    int MAX = 200005;
    
    
    
    
    boolean LOCAL;
    
    //SUFFICIENT DRY RUN????LOGIC VERIFIED FOR ALL TEST CASES???
    
    void solve(){
        
        int t=scn.nextInt();
            while(t-->0)
            {
                int n=scn.nextInt();
                String s1= scn.next();
                String s2 = scn.next();

                int op1=0,op0=0,one=0,zr=0;
                for(int i=0;i<n;i++){
                    char ch1 = s1.charAt(i);
                    char ch2 = s2.charAt(i);
                    
                    if(ch1=='1'&&ch2=='0'){
                        op1++;
                    }else if(ch1=='0'&&ch2=='1'){
                        op0++;
                    }else if(ch1==ch2){
                        if(ch1=='0'){
                            zr++;
                        }else{
                            one++;
                        }
                    }
                }
                
                if((one-zr)==1&&op1==op0){
                    w.println(Math.min(2*op1,one+zr));
                }else if((one-zr)==1){
                    w.println(one+zr);
                }else if(op1==op0){
                    w.println(2*op1);
                }else{
                    w.println(-1);
                }
            
            
            }
        
    }
 
    void run() {
        try {
            long ct = System.currentTimeMillis();
            scn = new FastScanner(new File(""input.txt""));
            w = new PrintWriter(new File(""output.txt""));
            fs=new PrintStream(""error.txt"");
            System.setErr(fs);
            LOCAL=true;
 
            solve();
 
            w.close();
            System.err.println(System.currentTimeMillis() - ct);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
 
    void runIO() {
 
        scn = new FastScanner(System.in);
        w = new PrintWriter(System.out);
        LOCAL=false;
 
        solve();
 
        w.close();
    }
 
    
 
    
    
    
    
    
     // TC- O(logmax(a,b))
    
 
    public static void main(String[] args) {
        new _1615c().runIO();
    }
}
",0,Non-plagiarised
132281000000000,f415c0bf,"import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   
	   
	 
	   
	   
	    
	 
	   
	
	static boolean function(long a[],long x) {
		
		long arr[] = new long[a.length];
		
		for(int i=0;i<arr.length;i++) {
			arr[i] = a[i];
		}
		
		for(int i=arr.length-1;i>=2;i--) {
			
			if(arr[i] < x) {
				return false;
			}
			long d = Math.min(a[i],(arr[i]-x))/3;
			
			arr[i-1] += d;
			arr[i-2] += 2*d;
		}
		
		return (arr[0]>=x && arr[1]>=x);
	}
	   public static void main(String args[]) throws Exception { 
		
		   Scanner sc = new Scanner();
		   StringBuilder res = new StringBuilder();
		
		   int tc = sc.nextInt();
		  
		   while(tc-->0) { 
			  
			int n = sc.nextInt();
			
			long a[] = new long[n];
			
			for(int i=0;i<n;i++) {
				a[i] = sc.nextLong();
			}
			
			long l = 1;
			long r = 1000000000;
			
			long ans = 1;
			
			while(l<=r){
				
				long mid = l + (r-l)/2;
				
				if(function(a,mid)){
					ans = mid;
					l = mid+1;
				}
				else {
					r = mid-1;
				}
			}
			
			res.append(ans+""\n"");
		   }
		   System.out.println(res);
	   }
}
","import java.util.Scanner;

public class BalancedStoneHeaps {

    static boolean check(long[] a, long k) {
        int n = a.length;
        long[] temp = new long[n];
        for (int i = 0; i < n; i++) {
            temp[i] = a[i];
        }
        for (int i = n - 1; i >= 2; i--) {
            if (temp[i] < k) {
                
                return false;
            }
            long p = Math.min(a[i] / 3, (temp[i] - k) / 3);
            temp[i - 1] += p;
            temp[i - 2] += 2 * p;

        }

        if (temp[0] >= k && temp[1] >= k) {
            return true;
        }

        return false;

    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = scan.nextInt();
            }
            long l = 0;
            long r = a[n - 1];
            long res = 0;
            while (l <= r) {
                long mid = (l + r) / 2;
                if (check(a, mid)) {
                    l = mid + 1;
                    res = Math.max(res, mid);
                } else {
                    r = mid - 1;
                }
            }
            System.out.println(res);
        }
    }
}
",1,Plagiarised
9028caf7,e6b7a899,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

public class Main {
	static final long MOD=1000000007;
	static final long MOD1=998244353;
	static long ans=0;
	//static ArrayList<Integer> ans=new ArrayList<>();
	public static void main(String[] args){
		PrintWriter out = new PrintWriter(System.out);
		InputReader sc=new InputReader(System.in);
		int N = sc.nextInt();
		int[] A = sc.nextIntArray(N);
		ArrayList<Integer> a1 = new ArrayList<Integer>();
		ArrayList<Integer> a2 = new ArrayList<Integer>();
		for (int i = 0; i < A.length; i++) {
			if (A[i]==0) {
				a1.add(i);
			}else {
				a2.add(i);
			}
		}
		int[][] dp = new int[a1.size()+1][a2.size()+1];
		for (int i = 0; i < dp.length; i++) {
			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
		}
		dp[0][0] = 0;
		for (int i = 1; i <= a1.size() ; i++) {
			int pos1 = a1.get(i-1);
			for (int j = 0; j <= a2.size(); j++) {
				dp[i][j] = dp[i-1][j];
				if (j-1>=0) {
					int pos2 = a2.get(j-1);
					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
				}
			}
		}
		System.out.println(dp[a1.size()][a2.size()]);
	}
	
}
",0,Non-plagiarised
45b19e51,f9adc043,"import java.util.*;
import java.io.*;

public class Main {
    static FastScanner sc = new FastScanner(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static StringBuilder sb = new StringBuilder();
    static long mod = (long) 1e9 + 7;

    public static void main(String[] args) throws Exception {
        int n = sc.nextInt();
        for(int i = 0; i < n; i++) solve();
        pw.flush();
    }

    public static void solve() {
        int n = sc.nextInt();
        long[] a = sc.nextLongArray(n);
        long left = 1;
        long right = (long)1e9;
        long[] dec = new long[2];
        while(right-left > 1){
            long mid = (right+left)/2L;
            dec[0] = dec[1] = 0;
            boolean ok = true;
            for(int i = n-1; i >= 2; i--){
                long a1 = a[i] + dec[1];
                if(a1 < mid){
                    ok = false;
                    break;
                }
                long d = (Math.min(a[i],a1-mid))/3L;
                dec[1] = dec[0]+d;
                dec[0] = d*2;
                //pw.println(dec[0] + "" "" + dec[1] + "" "" + mid + "" "" + d);
            }
            if(ok && a[0]+dec[0] >= mid && a[1]+dec[1] >= mid){
                left = mid;
            }else{
                right = mid;
            }
            /*
            for(int i = 2; i < n; i++){
                long a1 = a[i-2]-dec[0];
                long a2 = a[i-1]-dec[1];
                long d = Math.max(0,(mid-a1+1)/2L);
                if(d*3 > a[i]){
                    if(i != 0){
                        a[i] = 
                    }
                    ok = false;
                    break;
                }else{
                    dec[0] = dec[1] - d;
                    dec[1] = d*3;
                }
                //pw.println(dec[0] + "" "" + dec[1] + "" "" + mid);
            }
            if(ok && a[n-1]-dec[1] >= mid){
                left = mid;
            }else{
                right = mid;
            }
            */
        }
        pw.println(left);
    }

    
}


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

public class C {
	public static void main(String[] args) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int bruh = in.nextInt();

		for (int cases = 0; cases < bruh; cases++) {
			int n = in.nextInt();
			long lo = (int) 1e9, hi = 0;
			long [] a = new long[n];
			
			for (int i = 0; i < n; i++) {
				a[i] = in.nextInt();
				lo = Math.min(lo, a[i]);
				hi = Math.max(hi, a[i]);
			}
			
			long m = 0;
			//System.out.println(Arrays.toString(a));
			
			while (lo <= hi) {
				m = (lo + hi) / 2;
				if (works(a, m)) {
					lo = m + 1;
				}
				else {
					hi = m - 1;
				}
			}
			
			out.println(hi);
		}

		out.close();

	}


	static boolean works(long[] a, long m) {
		long[] d = Arrays.copyOf(a, a.length);
		
		for (int i = a.length - 1; i > 1; i--) {
			if (d[i] < m) {
				//System.out.println(m + "":x"" + Arrays.toString(d));
				return false;
			}
			long canGive = (d[i] - m) / 3 * 3;
			canGive = Math.min(canGive, a[i]);
			d[i - 1] += canGive / 3;
			d[i - 2] += canGive / 3 * 2;
			d[i] -= canGive;
		}
		
		//System.out.println(m + "": "" + Arrays.toString(d));
		
		if (d[0] < m || d[1] < m) return false;
		return true;
	}
	
	
}
",0,Non-plagiarised
2c7a0000,69b2fd22,"import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//int cases = Integer.parseInt(br.readLine());
		//while(cases-- > 0) {
			int n = Integer.parseInt(br.readLine());
			String[] str = br.readLine().split("" "");
			int[] a = new int[n];
			int k = 0;
			ArrayList<Integer> pos = new ArrayList<>();
			for(int i=0; i<n; i++) {
				a[i] = Integer.parseInt(str[i]);
				if(a[i] == 1) {
					k++;
					pos.add(i);
				}
			}
			int[][] dp = new int[n+1][k+1];
			for(int i=0; i<=n; i++) {
				Arrays.fill(dp[i], Integer.MAX_VALUE);
			}
			dp[0][0] = 0;
			for(int i=0; i<n; i++) {
				for(int j=0; j<=k; j++) {
					if(dp[i][j] == Integer.MAX_VALUE) {
						continue;
					}
					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
					if(j < k && a[i] == 0) {
						dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j]+Math.abs(pos.get(j)-i));
					}
				}
			}
			System.out.println(dp[n][k]);
		//}
	}
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
",0,Non-plagiarised
18d20d2e,d8a171a3,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;

public class C {
    public static void main(String[] args) {
        FastScanner scanner = new FastScanner();
        int t = scanner.nextInt();
        for (int i=0; i < t;i++) {
            int n = scanner.nextInt();
            String start = scanner.nextLine().trim();
            String finish = scanner.nextLine().trim();
            int ans = solve(start, finish, n);
            System.out.println(ans);
        }
    }

    public static int solve(String start, String finish, int n) {
        int nOnesInA = 0;
        for (char c : start.toCharArray()) {
            if (c == '1') {
                nOnesInA++;
            }
        }
        int nOnesInB = 0;
        for (char c : finish.toCharArray()) {
            if (c == '1') {
                nOnesInB++;
            }
        }
        int ans = Integer.MAX_VALUE;
        if (nOnesInA == nOnesInB) {
            ans = simpleSolve(start, finish, n);
        }
        if ((n - nOnesInA) + 1 == nOnesInB) {
            int newAns = simpleSolve(flip(start, n), finish, n) + 1;
            if (newAns < ans) {
                ans = newAns;
            }
        }
        if (ans == Integer.MAX_VALUE) {
            return -1;
        }
        return ans;
    }

    public static int simpleSolve(String start, String finish, int n) {
        int ans = 0;
        for (int i=0; i < n; i++) {
            if ((start.charAt(i) == '1') && (finish.charAt(i) == '0')) {
                ans+=2;
            }
        }
        return ans;
    }

    public static String flip(String start, int n) {
        char[] flipped = new char[n];
        for(int i=0; i<n; i++) {
            if (start.charAt(i) == '1') {
                flipped[i] = '0';
            } else {
                flipped[i] = '1';
            }
        }
        return String.valueOf(flipped);
    }

    
}
","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
9862c742,cf27732e,"import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner s  = new Scanner(System.in);
		int t = s.nextInt();
		while(t-- > 0){
		    int n = s.nextInt();
		    int[] arr = new int[n];
		    for(int i=0;i<n;i++)
		        arr[i] = s.nextInt();
		    String str = s.next();
		    List<Integer> left = new ArrayList<>();
		    List<Integer> right = new ArrayList<>();
		    for(int i=0;i<arr.length;i++){
		        if(str.charAt(i) == 'B')
		            left.add(arr[i]);
		        else right.add(arr[i]);
		    }
		    Collections.sort(left);
		    Collections.sort(right);
		    boolean flag = false;
		    for(int i=0;i<left.size();i++)
		        if(left.get(i) < i+1){
		            flag = true;
		            break;
		        }
		    if(!flag){
		        for(int i=0;i<right.size();i++)
    		        if(right.get(i) > left.size()+i+1){
    		            flag = true;
    		            break;
    		        }
		    }
		    if(flag)
		        System.out.println(""NO"");
		    else System.out.println(""YES"");
		}
	}
}
","import java.util.*;



import java.io.*;

public class code  {
	// remember long, to reformat ctrl + shift +f
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
 
	  
 
	public static void main(String[] args) throws Exception {

		int t=sc.nextInt();
		while(t-->0) {
            int n=sc.nextInt();
            int []vals=new int[n];
            boolean numLine[]=new boolean[n+1];

            for(int i=0;i<n;i++)vals[i]=sc.nextInt();
            String s=sc.nextLine();
            ArrayList<Integer>b=new ArrayList<Integer>();
            ArrayList<Integer>r=new ArrayList<Integer>();
            for(int i=0;i<n;i++) {
            	if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
            	else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
            }
          Collections.sort(b);
          Collections.sort(r);
          int small=1;
          for(int i=0;i<b.size();i++) {
        	  
        	  int y=b.get(i);
        	  if(y<small)continue;
        	  numLine[small]=true;
        	  small++;
          }
         // pw.println(Arrays.toString(numLine));
          int large=n;
          for(int i=r.size()-1;i>=0;i--) {
        	  
        	  int y=r.get(i);
        	  if(y>large)continue;
        	 // y=Math.max(large, y);
        	  numLine[large]=true;
        	  large--;
          }
          //pw.print(Arrays.toString(numLine));
          boolean can=true;
          for(int i=1;i<=n;i++) {
        	  if(numLine[i]==false) {
        		  pw.println(""no"");
        		  can=false;
        		  break;
        	  }
        	  
          }
          if(can)pw.println(""yes"");
          
           
            	
            	
            

			
		}
		
	 pw.close();

	}

	// --------------------stuff ----------------------
	

	

}
",0,Non-plagiarised
4.4428E+067,9debf95c,"import java.util.*;
import java.io.*;

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



    }
    




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


    }


}







",0,Non-plagiarised
d221162a,ee4f7b06,"import java.util.*;
import java.io.*;

public class Main2 {
	
	static long mod = 998244353;
//	static Scanner sc = new Scanner(System.in);
	static FastReader sc = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);
	public static void main (String[] args) {
		int t = 1;
//    	t = sc.nextInt();
	    z : while(t-->0) {
	    	int n = sc.nextInt();
	    	int a[] = new int[n];
	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
	    	List<Integer> a1 = new ArrayList<>();
	    	ArrayList<Integer> a2 = new ArrayList<>();
	    	for (int i = 0; i < n; i++) {
	    		if(a[i] == 0) a1.add(i);
	    		else a2.add(i);
			}
	    	long dp[][] = new long[n+1][n+1];
	    	for (int i = 0; i <= n; i++) {
	    		Arrays.fill(dp[i],-1);
			}
	    	out.write(find(0,0,a1,a2,dp)+""\n"");
	    }
		out.close();
	}
	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
		if(j == a2.size()) return 0;
		
		int req = a2.size()-j;
		int ava = a1.size()-i;
		
		if(ava<req) return Integer.MAX_VALUE/2;
		
		if(dp[i][j] != -1) return dp[i][j];
		
		long ans1 = find(i+1,j,a1,a2,dp);
		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
		
		return dp[i][j] = Math.min(ans1, ans2);
	}
}
","import java.io.*;
    import java.util.*;
    import java.lang.Math;


    public class Main {

          static Scanner sc;
          static StringBuilder ans;


          /*-------------- for input in an value ---------------------*/
          static int ni()     { return sc.nextInt();       }
          
          
          




          /*-------------- for input in an array ---------------------*/
          
          
              
          


          /*-------------- File vs Input ---------------------*/
          
          static void runIo() throws Exception  {
               sc = new Scanner(System.in);
          }    

          

          

          
          
           
          
                   

          

          

          
  

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

               // runFile();

               runIo();              

               int t;
               t = 1;     
            
               // t =  sc.nextInt();
          
               ans = new StringBuilder();
          
               while( t-- > 0 ) {   
                    solve();
               }                
          
               System.out.println(ans+""""); 
 
          }
    
          static int N ; 
          static int M ; 
          static ArrayList<Integer> f;
          static ArrayList<Integer> e;
          static long dp[][];

          static long find(int i, int j ) {
               
               if( i == N )   return 0;
               if( j == M )   return Integer.MAX_VALUE;


               if (dp[i][j] != -1 )
                    return dp[i][j];

               return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) +  find(i+1, j+1) );
          }       


          public static void solve() {          
          
               int n = ni();
               f = new ArrayList();
               e = new ArrayList();               

               for(int i = 0; i<n; i++) {
                    int v = ni();
                    if( v == 0 ) {
                         e.add(i);
                    }
                    else
                         f.add(i);
               }

               N = f.size();
               M = e.size();               

               dp = new long[N][M];

               for(int i = 0; i<N; i++)
                    Arrays.fill(dp[i], -1);

               ans.append(find(0, 0)+""\n"");
          }
 
     }
",0,Non-plagiarised
317a209c,921b6e4a,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.io.*;
import java.util.*;

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

				     public class A{
				     
				  static InputStream inputStream = System.in;
		            static FastScanner scan=new FastScanner();
		          

				   
				     public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	 static boolean vis[]=new boolean[26];
	 static LinkedList<Integer>edges[];
	 static int cnt=0;
	 static ArrayList<Integer>arr=new ArrayList();
	 

			public static void main(String[] args)  throws Exception 
		      {
			
				//	scan=new FastScanner(""lifeguards.in"");
				//out = new PrintWriter(""lifeguards.out"");
				 
				 /*
				 currently doing 
				 1-digit dp
				 2-ds like fenwick and interval tree and sparse table 
				 */
				 /*
				 READING 
				 1-Everything About Dynamic Programming codeforces
				 2-DYNAMIC PROGRAMMING: FROM NOVICE TO ADVANCED topcoder
				 3-Introduction to DP with Bitmasking codefoces
				 4-Bit Manipulation hackerearth 
				 */


				    int tt=1;
				 
		

				     


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

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

out.println();
				    
				    
		           

		            }

				  	    out.close();
		 		  
				   
				}
				

				   
				     
				     
				    
				    
				    
				     
				    
				    
				     

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

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

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

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

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

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

    // Pair

    

    // FastReader Class

    

    // Req Functions
    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    // debug

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

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    
}
",0,Non-plagiarised
d9199dfd,ff1fc018,"import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
","import java.util.*;

public class mentor1 {
    public static boolean solve(int n, String color, int[] arr){
        List<Integer> Barr = new ArrayList<Integer>();
        List<Integer> Rarr = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            if(color.charAt(i) == 'B')Barr.add(arr[i]);
            else Rarr.add(arr[i]);
        }
        Barr.sort(Comparator.naturalOrder());
        Rarr.sort(Comparator.reverseOrder());
        for (int i = 0; i < Barr.size(); i++) {
            if(Barr.get(i)< i + 1)return false;
        }
        for (int i = 0; i < Rarr.size(); i++) {
            int expect = n-i;
            if(Rarr.get(i) > expect)return false;
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        for (int i = 0; i < n; i++) {
            int m = input.nextInt();
            int[] arr = new int[m];
            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
            String color = input.next();
            if(solve(m,color,arr)) System.out.println(""YES"");
            else System.out.println(""NO"");
        }
    }
}
",0,Non-plagiarised
595f5d6c,ae775964,"import java.math.BigInteger;
//import static java.lang.Math.max;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;

import java.util.Scanner;

public class ahh {
//trihund
	static Scanner scn = new Scanner(System.in);
	static boolean vis[][];

	

	static FastReader s = new FastReader();
	static int MOD = 1000000007;

	public static void main(String[] args) {
		
		int n=scn.nextInt(),count=0;
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
		{
			arr[i]=scn.nextInt();
		}
		ArrayList<Integer>zer=new ArrayList<Integer>(),one=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(arr[i]==0)
				zer.add(i);
			else
				one.add(i);
		}
		count=one.size();
		long memo[][]=new long[one.size()+1][zer.size()+1];
		for(int i=0;i<=one.size();i++)
		{
			for(int j=0;j<=zer.size();j++)
				memo[i][j]=-1;
		}
		System.out.println(arm(one, zer, 0, 0, count,memo));
				
		
	}

	public static long arm(ArrayList<Integer>one,ArrayList<Integer>zer,int i,int j,int count,long memo[][])
	{	if(count==0)
		return 0;
		if(i==one.size()||j==zer.size())
			return Integer.MAX_VALUE;
		
		if(memo[i][j]!=-1)
			return memo[i][j];
		
		long a=Integer.MAX_VALUE,b=Integer.MAX_VALUE;
		a=arm(one, zer, i+1, j+1,count-1,memo)+Math.abs(one.get(i)-zer.get(j));
		b=arm(one, zer, i, j+1,count,memo);
		memo[i][j]=Math.min(a, b);
		return Math.min(a, b);
	}
	

	

	

}








","import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.sound.sampled.ReverbType;


public class Edu109 {
	static PrintWriter out;
	static Scanner sc;
	static int[]a;
	static int A,B,n,m,h,ans,sum;
	public static void main(String[]args) throws IOException {
		sc=new Scanner(System.in);
		out=new PrintWriter(System.out);
		D();
		out.close();
	}
	  
		
		
		
		
		
		
		static long[][]mem;
		static int ones;
		static ArrayList<Integer>pos;
		static void D() throws IOException {
			int t=1;
			while(t-->0) {
				n=ni();
				a=nai(n);
				mem=new long[n][n];
				ones=0;
				pos=new ArrayList<Integer>();
				for(int i=0;i<n;i++) {
					Arrays.fill(mem[i], -1);
					if(a[i]==1)pos.add(i);
				}
				ones=pos.size();
				long ans=solve(0,0);
				out.println(ans);
			}
		}
		private static long solve(int i, int j) {
			if(i==n||j>=ones)return j==ones?0:(long)1e14;
			if(mem[i][j]!=-1)return mem[i][j];
			long lv=solve(i+1,j);
			if(a[i]==0) {
				int pr=Math.abs(i-pos.get(j));
				lv=Math.min(lv, pr+solve(i+1,j+1));
			}
			return mem[i][j]=lv;
		}
		
		
		
		
	

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

	
	
	
	
	

	
}
",0,Non-plagiarised
1ea771ea,3c667d4f,"import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
","import java.util.*;
public class j
{
  public static void main(String args[])
  {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0)
    {
      int len=in.nextInt();
      int t=in.nextInt();
      int pos[]=new int[t];
      int temp[]=new int[t];
      for(int i=0;i<t;i++)
      pos[i]=in.nextInt();
      for(int i=0;i<t;i++)
      temp[i]=in.nextInt();
      long range[]=new long[len];
      Arrays.fill(range,Long.MAX_VALUE-10000);
      for(int i=0;i<t;i++)
      range[pos[i]-1]=temp[i];
      for(int i=1;i<len;i++)
      {
        range[i]=Math.min(range[i],1+range[i-1]);
      }
      for(int i=len-2;i>=0;i--)
      {
      range[i]=Math.min(range[i+1]+1,range[i]);
      }
      for(int i=0;i<len;i++)
      {
        System.out.print(range[i]+"" "");
      }System.out.println();
    }
  }
}
",0,Non-plagiarised
39073790,d735b078,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class DisJump {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
//		int t = sc.nextInt();
        int t = 1;
        while (t-- != 0) {
            solver.solve(sc, out);
        }
        out.close();

    }

    

    static class Solver {
        public void solve(InputReader sc, PrintWriter out) {
            int n = sc.nextInt();
            int[] h = sc.nextIntArray(n);
            ArrayList<Integer>[] g = new ArrayList[n];
            for(int i = 0; i < n; i++) g[i] = new ArrayList<>();
            for(int rot = 0; rot < 2; rot++) {
                int[] stk = new int[n];
                int at = -1;
                for(int i = 0; i < n; i++) {
                    while (at!=-1 && h[stk[at]]<h[i]) g[stk[at--]].add(i);
                    if(at!=-1) {
                        g[stk[at]].add(i);
                        if(h[stk[at]]==h[i]) at--;
                    }
                    stk[++at] = i;
                }
                for(int i = 0; i < n; i++) h[i] = -h[i];
            }
            int[] qu = new int[n];
            int[] dist = new int[n];
            Arrays.fill(dist,-1);
            int qTop = 0;
            int qEnd = 1;
            qu[0] = 0;
            dist[0] = 0;
            while (qTop<qEnd) {
                int front = qu[qTop];
                for(int v : g[front]) {
                    if(dist[v]==-1) {
                        qu[qEnd] = v;
                        dist[v] = dist[front]+1;
                        qEnd++;
                    }
                }
                qTop++;
            }
            out.println(dist[n-1]);
        }
    }

    

    

    

    

    


}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;

// 1 0 1 0 0
public class D {

	// Right side greater
	public static int[] rightGreaterEle(long[] a) {
		int n = a.length;
		int ans[] = new int[n];
		ans[n - 1] = -1;
		Stack<Integer> st = new Stack<>();
		st.add(n - 1);
		for (int i = n - 2; i >= 0; i--) {
			if (st.isEmpty() || a[st.peek()] >= a[i]) {
				ans[i] = st.peek();
				st.push(i);
			} else {

				while (!st.isEmpty() && a[st.peek()] < a[i]) {
					st.pop();
				}
				if (st.isEmpty())
					ans[i] = -1;
				else
					ans[i] = st.peek();
				st.push(i);
			}
		}
		return ans;

	}

	// Right side smaller
	public static int[] rightSideSmaller(long[] a) {
		int n = a.length;
		int ans[] = new int[n];
		ans[n - 1] = -1;
		Stack<Integer> st = new Stack<>();
		st.add(n - 1);
		for (int i = n - 2; i >= 0; i--) {
			if (st.isEmpty() || a[st.peek()] <= a[i]) {
				ans[i] = st.peek();
				st.push(i);
			} else {

				while (!st.isEmpty() && a[st.peek()] > a[i]) {
					st.pop();
				}
				if (st.isEmpty())
					ans[i] = -1;
				else
					ans[i] = st.peek();
				st.push(i);
			}
		}
		return ans;

	}

	// Left side greater
	public static int[] leftSideGreater(long[] a) {
		int n = a.length;
		int ans[] = new int[n];
		ans[0] = -1;
		Stack<Integer> st = new Stack<>();
		st.push(0);
		for (int i = 1; i < n; i++) {
			if (st.isEmpty() || a[st.peek()] >= a[i]) {
				ans[i] = st.peek();
				st.push(i);
			} else {

				while (!st.isEmpty() && a[st.peek()] < a[i]) {
					st.pop();
				}
				if (st.isEmpty())
					ans[i] = -1;
				else
					ans[i] = st.peek();
				st.push(i);
			}
		}
		return ans;

	}

	// Left side smaller
	public static int[] leftSideSmaller(long[] a) {
		int n = a.length;
		int ans[] = new int[n];
		ans[0] = -1;
		Stack<Integer> st = new Stack<>();
		st.push(0);
		for (int i = 1; i < n; i++) {
			if (st.isEmpty() || a[st.peek()] <= a[i]) {
				ans[i] = st.peek();
				st.push(i);
			} else {

				while (!st.isEmpty() && a[st.peek()] > a[i]) {
					st.pop();
				}
				if (st.isEmpty())
					ans[i] = -1;
				else
					ans[i] = st.peek();
				st.push(i);
			}
		}
		return ans;

	}

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int n = sc.nextInt();
		long a[] = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = sc.nextLong();

		int rg[] = rightGreaterEle(a);
		int rs[] = rightSideSmaller(a);

		int lg[] = leftSideGreater(a);
		int ls[] = leftSideSmaller(a);

		int dp[] = new int[n];
		Arrays.fill(dp, Integer.MAX_VALUE);

		dp[0] = 0;
		for(int i=1;i<n;i++) dp[i]=dp[i-1]+1;
		
		for (int i = 0; i < n; i++) {
			
		
			// Where from we can reach at ith index
			//System.out.println(l1+"" ""+l2+"" ""+r1+"" ""+r2);
			int l1 = ls[i], l2 = lg[i];
			if (l1 != -1)
				dp[i] = Math.min(dp[i], dp[l1] + 1);
			if (l2 != -1)
				dp[i] = Math.min(dp[i], dp[l2] + 1);

			//System.out.println(""from left ""+dp[i]);
			int r1 = rs[i], r2 = rg[i];

			if (r1 != -1)
				dp[r1] = Math.min(dp[r1], dp[i] + 1);
			if (r2 != -1)
				dp[r2] = Math.min(dp[r2], dp[i] + 1);
			
//			if(i==4)
//			System.out.println(dp[l1]+"" ""+dp[l2]+"" ""+dp[r1]+"" ""+dp[r2]);
//			System.out.println((i+1)+"" ""+dp[i]);

		}
		System.out.println(dp[n-1]);

	}

	

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

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","import java.util.*;
import java.io.*;

public class Main2 {
	
	static long mod = 998244353;
//	static Scanner sc = new Scanner(System.in);
	static FastReader sc = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);
	public static void main (String[] args) {
		int t = 1;
//    	t = sc.nextInt();
	    z : while(t-->0) {
	    	int n = sc.nextInt();
	    	int a[] = new int[n];
	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
	    	List<Integer> a1 = new ArrayList<>();
	    	ArrayList<Integer> a2 = new ArrayList<>();
	    	for (int i = 0; i < n; i++) {
	    		if(a[i] == 0) a1.add(i);
	    		else a2.add(i);
			}
	    	long dp[][] = new long[n+1][n+1];
	    	for (int i = 0; i <= n; i++) {
	    		Arrays.fill(dp[i],-1);
			}
	    	out.write(find(0,0,a1,a2,dp)+""\n"");
	    }
		out.close();
	}
	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
		if(j == a2.size()) return 0;
		
		int req = a2.size()-j;
		int ava = a1.size()-i;
		
		if(ava<req) return Integer.MAX_VALUE/2;
		
		if(dp[i][j] != -1) return dp[i][j];
		
		long ans1 = find(i+1,j,a1,a2,dp);
		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
		
		return dp[i][j] = Math.min(ans1, ans2);
	}
}
",0,Non-plagiarised
2470b521,f6ca6fc8,"import com.sun.security.jgss.GSSUtil;

import javax.swing.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

//ankit singh

public class Main {

   static int inf=Integer.MAX_VALUE/2;
    public static void main(String[] args) {
       Scanner input=new Scanner(System.in);
       int nn=input.nextInt();
        int a[]=new int[nn];
        ArrayList<Integer> one=new ArrayList<>();
        ArrayList<Integer> zero=new ArrayList<>();
        for (int i = 0; i <nn ; i++) {
            a[i]=input.nextInt();
            if(a[i]==1){
                one.add(i);
            }else zero.add(i);
        }
        if (one.size()==0) {
            System.out.println(0);
            return;
        }
        int n=one.size();
        int m=zero.size();
        int dp[][]=new int[n+1][m+1];
        int ans=0;
        for (int i = 1; i <=n ; i++) {
             dp[i][0]=inf;
            for (int j = 1; j <=m ; j++) {
                dp[i][j]=inf;

                //take the current
                dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));

                //take previos
                dp[i][j]=Math.min(dp[i][j],dp[i][j-1]);


            }
        }
        ans=inf;
        for (int i = 1; i <=m ; i++) {
            ans=Math.min(ans,dp[n][i]);
        }
        System.out.println(ans);



    }

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

public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		ArrayList<Integer>  o=new ArrayList<Integer>();
		ArrayList<Integer>  e=new ArrayList<Integer>();
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		int dp[][]=new int[o.size()+1][e.size()+1];
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++){
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",0,Non-plagiarised
4eac0eea,f4d6d28d,"import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.Math.*;
// import java.math.*;

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

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

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

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

            String[] words = new String[n];
            int i=0;
            while(n-- >0){
                words[i] = br.readLine();
                i++;
            }

            answer.add(new Solver().solve(words));
        }

        for (int ans : answer ) System.out.println(ans);

    }

    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
    
    
    
    

    
    

    
    

}


class Solver{
    public int solve(String[] words) throws IOException{

        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};
        // char[] alphabets = {'a'};

        int[][] arr = new int[5][words.length];

        int i=0;
        for(String s : words) {
            char[] wordArr = s.toCharArray();
            int j=0;
            for (char alpha : alphabets) {

                int counter = 0;
                for(char letter : wordArr){
                    if(alpha == letter){
                        counter++;
                    }
                }
                arr[j][i] = 2*counter - s.length();
                // System.out.println( alpha + ""  "" + (2*counter - s.length()));
                j++;
            }
            // System.out.println(""********"");

            i++;

        }

        int[] ans = new int[5];

        int m=0;
        for (int[] ar : arr) {
            // Arrays.sort(ar, Collections.reverseOrder());
            Arrays.sort(ar);
            int val=0;
            int counter = 0;
            for(i=ar.length-1; i>=0; i--){
                val += ar[i];
                if(val>0){
                    counter++;
                } else break;
            }
            ans[m] = counter;
            m++;
            // cp.printArr(ar);
        }

        // cp.printArr(ans);

        return Arrays.stream(ans).max().getAsInt();
    }
}
","import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.Math.*;

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

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

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

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

            String[] words = new String[n];
            int i=0;
            while(n-- >0){
                words[i] = br.readLine();
                i++;
            }

            answer.add(new Solver().solve(words));
        }

        for (int ans : answer ) System.out.println(ans);

    }

    static StringTokenizer readLine() throws IOException { return new StringTokenizer(br.readLine()); }
    static int tokenInt() { return Integer.parseInt(st.nextToken()); }
    
    
    
    

    
    

    
    

}


class Solver{
    public int solve(String[] words) throws IOException{

        char[] alphabets = {'a', 'b', 'c', 'd', 'e'};

        int[][] arr = new int[5][words.length];

        int i=0;
        for(String s : words) {
            char[] wordArr = s.toCharArray();
            int j=0;
            for (char alpha : alphabets) {
                int counter = 0;
                for(char letter : wordArr){
                    if(alpha == letter)
                        counter++;
                }
                arr[j][i] = 2*counter - s.length();
                j++;
            }
            i++;
        }

        int[] ans = new int[5];

        int m=0;
        for (int[] ar : arr) {
            Arrays.sort(ar);
            int val=0;
            int counter=0;
            for(i=ar.length-1; i>=0; i--){
                val += ar[i];
                if(val>0) counter++;
                else break;
            }
            ans[m] = counter;
            m++;
        }

        return Arrays.stream(ans).max().getAsInt();
    }
}
",1,Plagiarised
aa8091b0,eec856c0,"import java.util.*;
 
import java.io.*;
 
public class AiseHi {
	static Scanner sc = new Scanner(System.in);
	static int mod = (int)(1e9+7);
	public static void main (String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		int t = 1;
    	t = sc.nextInt();
    	z : while(t-->0) {
    		int n = sc.nextInt();
    		int m = sc.nextInt();
    		int x = sc.nextInt();
    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
    		for(int i=1;i<=m;i++) {
    			myQueue.add(new twoval(0,i));
    		}
    		List<twoval> arrayList = new ArrayList<>();
    		int myArray[] = new int[n];
    		for(int i=0;i<n;i++) {
    			int aasjd = sc.nextInt();
    			arrayList.add(new twoval(aasjd,i));
    			myArray[i] = aasjd;
    		}
    		Collections.sort(arrayList);
    		int ans[] = new int[n];
    		for(int i=n-1;i>=0;i--) {
    			twoval p = myQueue.poll();
    			long aasjd = p.myArray;
    			int idx = p.b;
    			aasjd += arrayList.get(i).myArray;
    			ans[arrayList.get(i).b] = idx;
    			myQueue.add(new twoval(aasjd,idx));
    		}
    		long dasdaknw[] = new long[m];
    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
    		for(int i=0;i<n;i++) {
    			dasdaknw[ans[i]-1] += myArray[i];
    		}
    		for(int i=0;i<m;i++) {
    			min = Math.min(min, dasdaknw[ans[i]-1]);
    			max = Math.max(max, dasdaknw[ans[i]-1]);
    		}
    		if(max-min>x) {
    			out.write(""NO\n"");
    			continue;
    		}
    		out.write(""YES\n"");
    		for(int aasjd : ans) out.write(aasjd+"" "");
    		out.write(""\n"");
    	}
		out.close();
	}
	
	static boolean prime[] = new boolean[2000009];
	static int fac[] = new int[2000009];
	
	
	
}
 
class twoval implements Comparable<twoval>{
	long myArray;
	int b;
	twoval(long aasjd,int r){
		this.myArray = aasjd;
		this.b = r;
	}
	
}
","import java.io.*;
import java.util.*;
 
public class Main {
	
	static FastReader sc = new FastReader();
	static long mod = (long) (1e9+7);
	static boolean spe[];
	static int spen[];
	static int dep[];
	static List<Integer> tre[];
	static int par[][];
	public static void main (String[] args){
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;
        t = sc.nextInt();
        z :for(int tc=1;tc<=t;tc++){
    		int n = sc.nextInt();
    		int m = sc.nextInt();
    		int x = sc.nextInt();
    		PriorityQueue<pairClass> priority = new PriorityQueue<>();
    		for(int i=1;i<=m;i++) {
    			priority.add(new pairClass(0,i));
    		}
    		List<pairClass> list = new ArrayList<>();
    		int a[] = new int[n];
    		for(int i=0;i<n;i++) {
    			int value = sc.nextInt();
    			list.add(new pairClass(value,i));
    			a[i] = value;
    		}
    		Collections.sort(list);
    		int answer[] = new int[n];
    		for(int i=n-1;i>=0;i--) {
    			pairClass p = priority.poll();
    			long value = p.a;
    			int idx = p.b;
    			value += list.get(i).a;
    			answer[list.get(i).b] = idx;
    			priority.add(new pairClass(value,idx));
    		}
    		long totalSum[] = new long[m];
    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
    		for(int i=0;i<n;i++) {
    			totalSum[answer[i]-1] += a[i];
    		}
    		for(int i=0;i<m;i++) {
    			min = Math.min(min, totalSum[answer[i]-1]);
    			max = Math.max(max, totalSum[answer[i]-1]);
    		}
    		if(max-min>x) {
    			out.write(""NO\n"");
    			continue;
    		}
    		out.write(""YES\n"");
    		for(int value : answer) out.write(value+"" "");
    		out.write(""\n"");
        }
		out.close();
	}
}
class pairClass implements Comparable<pairClass>{
	long a;
	int b;
	pairClass(long value,int r){
		this.a = value;
		this.b = r;
	}
	
}
",1,Plagiarised
1410e423,e90a198b,"import java.io.*;
import java.util.*;

public class C {

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

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		
		int t = Integer.parseInt(br.readLine());
		
		while(t --> 0) {
			
			int n = Integer.parseInt(br.readLine());
			
			char[] lineA = br.readLine().toCharArray();
			char[] lineB = br.readLine().toCharArray();
			
			boolean[] a = new boolean[n];
			boolean[] b = new boolean[n];
			
			int ac = 0;
			int aic = 0;
			int bc = 0;
			int stay = 0;
			int flip = 0;
			
			for(int i = 0; i < n; i++) {
				
				if(lineA[i] == '1') {
					
					ac++;
					a[i] = true;
					
				}else
					aic++;
				
				if(lineB[i] == '1') {
					
					bc++;
					b[i] = true;
					
				}
				
				if(a[i] == b[i])
					stay++;
				else
					flip++;
				
			}
			
			if(ac != bc && aic + 1 != bc) {
				
				pw.println(-1);
				
			}else {
				
				if(ac == aic+1)
					pw.println(Math.min(stay, flip));
				else if(ac == bc)
					pw.println(flip);
				else
					pw.println(stay);
				
			}
			
		}
		
		pw.close();

	}

}
","import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class Template {
    
	static int mod = 1000000007;

	public static void main(String[] args){
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int yo = sc.nextInt();
        while (yo-- > 0) {
            int n = sc.nextInt();
            String s = sc.next();
            String t = sc.next();
            int op1 = cal(s,t,n);
            int op2 = helper(s,t,n,'0');
            int op3 = helper(s,t,n,'1');
            int ans = min(min(op1,op2),op3);
            if(ans == Integer.MAX_VALUE){
                out.println(""-1"");
            }
            else {
                out.println(ans);
            }
        }
        out.close();
	}
    
    static int helper(String str1, String str2, int n, int ch){
        char[] s = str1.toCharArray();
        char[] t = str2.toCharArray();
        int idx = -1;
        for(int i = 0; i < n; i++){
            if(s[i] == '1' && t[i] == ch){
                idx = i;
                break;
            }
        }
        if(idx == -1){
            return Integer.MAX_VALUE;
        }
        for(int i = 0; i < n; i++){
            if(i == idx) continue;
            if(s[i] == '1') s[i] = '0';
            else s[i] = '1';
        }
        int ans = cal(String.valueOf(s),String.valueOf(t),n);
        if(ans == Integer.MAX_VALUE) return ans;
        return 1 + ans;
    }
    static int cal(String s, String t, int n){
        int op01 = 0;
        int op10 = 0;
        for(int i = 0; i < n; i++){
            if(s.charAt(i) != t.charAt(i)){
                if(s.charAt(i) == '1') op10++;
                else op01++;
            }
        }
        if(op10 != op01){
            return Integer.MAX_VALUE;
        }
        return op01 + op10;
    }
    
    /*
    Source: hu_tao
         Random stuff to try when stuck:
            - use bruteforcer
            - check for n = 1, n = 2, so on
            -if it's 2C then it's dp
            -for combo/probability problems, expand the given form we're interested in
            -make everything the same then build an answer (constructive, make everything 0 then do something)
            -something appears in parts of 2 --> model as graph
            -assume a greedy then try to show why it works
            -find way to simplify into one variable if multiple exist
            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
            -find lower and upper bounds on answer
            -figure out what ur trying to find and isolate it
            -see what observations you have and come up with more continuations
            -work backwards (in constructive, go from the goal to the start)
            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
            -draw something
            -simulate a process
            -dont implement something unless if ur fairly confident its correct
            -after 3 bad submissions move on to next problem if applicable
            -do something instead of nothing and stay organized
            -write stuff down
         Random stuff to check when wa:
            -if code is way too long/cancer then reassess
            -switched N/M
            -int overflow
            -switched variables
            -wrong MOD
            -hardcoded edge case incorrectly
         Random stuff to check when tle:
            -continue instead of break
            -condition in for/while loop bad
         Random stuff to check when rte:
            -switched N/M
            -long to int/int overflow
            -division by 0
            -edge case for empty list/data structure/N=1
            
      */

	

	

	

	

	

	
    
    
    
    

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
",0,Non-plagiarised
51cc7026,51d88c51,"import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class C_Balanced_Stone_Heaps {
	
	
    public static int t, n;
    public static int H[];
	private static long startTime = System.currentTimeMillis();
	public static void main(String[] args) {
		FastReader sc =new FastReader();
		t = sc.nextInt();
        while (t-->0) {
            n = sc.nextInt();
            H = new int[n];
            int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
			for (int i = 0; i < n; i++) {
                H[i] = sc.nextInt();
                max = Math.max(H[i], max);
                min = Math.min(H[i], min);
            }
            int mid = 0;
            while (min < max) {
                mid = min + (max-min+1)/2;
                if(check(mid)) {
                    min = mid;
                }
                else max = mid-1;
            }			

            System.out.println(min);
        }

	}

    public static boolean check(int x){
        int S[] = Arrays.copyOf(H, H.length);
        for (int i = n-1; i >= 2; i--) {
            if(S[i]<x) return false;

            int move = Math.min(S[i]-x, H[i])/3;
            if(i>=2){
                // S[i]-=move*3;
                S[i-1]+=(move);
                S[i-2]+=2*(move);
            }
        }
        return S[0]>= x && S[1] >= x;
    }

}
","import java.awt.Container;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

import java.util.*;

public class Main
{
   
    public static boolean check(int a[],int value)
    {
           int b[]= new int[a.length];
           for (int i = a.length-1; i >=2; i--) {
            if(a[i]+b[i]<value)
            {
                return false;
            }
            int d = Math.min(a[i], (a[i]+b[i]-value));
            b[i-1]+=d/3;
            b[i-2]+=(2*(d/3));
            
        }
        
        
        
        if(a[0]+b[0]<value||a[1]+b[1]<value)
        {
            return false;
        }
        return true;
        
    }
   
    public static void main(String[] args)
    {
        FastScanner input = new FastScanner();
        StringBuilder result = new StringBuilder();
        int tc = input.nextInt();
        work:
        while (tc-- > 0) {
          int n = input.nextInt();
        int a[]= new int[n];
     
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            a[i] = input.nextInt();
            min = Math.min(min, a[i]);
            max = Math.max(max, a[i]);
            
        }
        int low = min;
        int high  = max;
        int ans = 0;
        while(low<=high)
        {
            int mid = low+(high-low)/2;
            if(check(a, mid))
            {
                ans = mid;
                low = mid+1;
            }
            else
            {
                high = mid-1;
            }
            
            
        }
        result.append(ans+""\n"");
           
        }
        System.out.println(result);
        
       
    }

    

}
",0,Non-plagiarised
67996c4c,9028caf7,"import java.util.*;
import java.io.*;

public class code{

	

	

	public static void main(String[] arg) throws IOException{
		//Reader in=new Reader();
		Scanner in=new Scanner(System.in);

   int n=in.nextInt();
	 int[] arr=new int[n];
	 ArrayList<Integer> zero=new ArrayList<Integer>();
	 ArrayList<Integer> one=new ArrayList<Integer>();

	 for(int i=0;i<n;i++){
		 arr[i]=in.nextInt();
		 if(arr[i]==0) zero.add(i);
		 else one.add(i);
	 }
   if(one.size()==0) {
		 System.out.println(0);
	 }
	 else{
			 int[][] dp=new int[one.size()][zero.size()];

		   for(int i=0;i<one.size();i++){
				 for(int j=0;j<zero.size();j++){
					 if(i==0 && j==0) dp[i][j]=Math.abs(one.get(i)-zero.get(j));
					 else if(j==0) dp[i][j]=Integer.MAX_VALUE/2;
					 else if(i==0) dp[i][j]=Math.min(dp[i][j-1],Math.abs(one.get(i)-zero.get(j)));
					 else{
						 dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i)-zero.get(j)));
					 }
				 }
			 }

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

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
",0,Non-plagiarised
b7de5c19,c022c315,"import java.util.*;

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

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

class Pair {
    int vertex;
    int numberOfEdge;

    public Pair(int vertex, int numberOfEdge) {
        this.vertex = vertex;
        this.numberOfEdge = numberOfEdge;
    }
}
","import java.io.*;
import java.util.*;

public class Main {

//	static boolean[] prime = new boolean[10000000];
	final static long mod = 1000000007;

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

		int t = in.nextInt();
		while (t-- > 0) {
			int n = in.nextInt();
			int[][] a = new int[n - 1][2];
			ArrayList<ArrayList<Data>> g = new ArrayList<>();
			for (int i = 0; i < n - 1; i++) {
				g.add(new ArrayList<>());
				a[i][0] = in.nextInt() - 1;
				a[i][1] = in.nextInt() - 1;
			}
			g.add(new ArrayList<>());
			for (int i = 0; i < n - 1; i++) {
				g.get(a[i][0]).add(new Data(a[i][1], i));
				g.get(a[i][1]).add(new Data(a[i][0], i));
			}
			if (!check(g)) {
				System.out.println(-1);
				continue;
			}
			int[] ans = new int[n - 1];

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

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

		out.flush();
	}

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

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

	}

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

	

	

	

	

	

	

//	static void sieve() {
//		for (int i = 2; i * i < prime.length; i++) {
//			if (prime[i])
//				continue;	
//			for (int j = i * i; j < prime.length; j += i) {
//				prime[j] = true;
//			}
//		}
//	}

}

class Data {
	int a;
	int ind;

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




",0,Non-plagiarised
9261620f,f0881ab5,"import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int n  =sc.nextInt();
            long[] arr = new long[n];
            for(int i=0;i<n;i++){
                arr[i] =sc.nextLong();
            }
            Map<Long, Long> map = new HashMap<>();
            List<Long> list = new ArrayList<>();
            list.add((long)0);
            for(int i=0;i<n;i++){
                int s = list.size();
                for(int j=0;j<s;j++){
                    list.add(list.get(j)+arr[i]);
                }
            }
            int flag = 0;
            for(int i=0;i<list.size();i++){
                map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
                if(map.get(list.get(i))>1){
                    flag = 1;
                    break;
                }
            }
            if(flag>0)
                System.out.println(""YES"");
            else
                System.out.println(""NO"");
        }
    }
}
","import java.util.*;
    public class Main {
        public static void main(String args[]) {
            Scanner sc = new Scanner(System.in);
            int t = sc.nextInt();
            while(t-->0){
                int n  =sc.nextInt();
                long[] arr = new long[n];
                for(int i=0;i<n;i++){
                    arr[i] =sc.nextLong();
                }
                Map<Long, Long> map = new HashMap<>();
                List<Long> list = new ArrayList<>();
                list.add((long)0);
                for(int i=0;i<n;i++){
                    int s = list.size();
                    for(int j=0;j<s;j++){
                        list.add(list.get(j)+arr[i]);
                    }
                }
                int flag = 0;
                for(int i=0;i<list.size();i++){
                    map.put(list.get(i), map.getOrDefault(list.get(i), (long)0)+1);
                    if(map.get(list.get(i))>1){
                        flag = 1;
                        break;
                    }
                }
                if(flag>0)
                    System.out.println(""YES"");
                else
                    System.out.println(""NO"");
            }
        }
    }
",1,Plagiarised
29d865c3,5cfa2861,"import java.io.*;
import java.util.*;

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

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

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

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

    private static MyScanner sc = new MyScanner();

    private static int N = sc.nextInt();

    
}
","import java.util.*;
import java.io.*;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.Math.max;
public class EdB {
	static long[] mods = {1000000007, 998244353, 1000000009};
	static long mod = mods[0];
	public static MyScanner sc;
    public static PrintWriter out;
	public static void main(String[] largewang) throws Exception{
		// TODO Auto-generated method stub
 		sc = new MyScanner();
 		out = new PrintWriter(System.out);
 		int t = sc.nextInt();
 		while (t-->0) {
 			int n = sc.nextInt();
 			char[] a = sc.next().toCharArray();
 			char[] b = sc.next().toCharArray();
 			int counta = 0;
 			int countb = 0;
 			for (char j : a) {
 				if (j == '1')
 					counta++;
 			}
 			for (char j : b) {
 				if (j == '1')
 					countb++;
 			}
 			long ans = 0;
 			if (counta == countb && n-counta+1 == countb){
 				for (int j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 				long tempans = 0;
 				int j=0;
 				for(j = 0;j<n;j++){
 					if (a[j] == '1' && b[j] == '1')
 						break;
 				}
 				for(int i = 0;i<n;i++){
 					if (i == j)
 						continue;
 					if (a[i] == '1')
 						a[i] = '0';
 					else
 						a[i] = '1';
 				}
 				tempans += 1;
 				for (j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						tempans += 2;
 					}
 				}
 				ans = min(ans, tempans);
 			} else if (counta == countb) {
 				for (int j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 			} else if (n-counta+1 == countb) {
 				int j=0;
 				for(j = 0;j<n;j++){
 					if (a[j] == '1' && b[j] == '1')
 						break;
 				}
 				for(int i = 0;i<n;i++){
 					if (i == j)
 						continue;
 					if (a[i] == '1')
 						a[i] = '0';
 					else
 						a[i] = '1';
 				}
 				ans += 1;
 				for (j = 0;j<n;j++){
 					if (b[j] == '1' && a[j] == '0') {
 						ans += 2;
 					}
 				}
 			} else {
 				ans = -1;
 			}
 			out.println(ans);
  		}
 		out.close();
 		
 	}
	
	
	
	
	
	
	
	
	
	
	
	
    	
}
",0,Non-plagiarised
6f02c6d9,c2242c42,"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.io.*;
import java.util.*;



     

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


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

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

	
	
	
	
	
	
	
	  
	
	
	 
	
	
	  
	static void printYesNo(boolean condition)
	{
		if (condition) {
			out.println(""Yes"");
		}
		else {
			out.println(""No"");
		}
	}
	
	
	
	
	
	
	
	
	    // 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 long modInverse(long a, long m)
//		    {
//		        long g = gcd(a, m);
//		       
//		          return   power(a, m - 2, m);
//		        
//		    }
	
	 
	 

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

}
",1,Plagiarised
0c9d4def,f665e87b,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class C{
    private static int maxWords = 0;
    private static int[][] words;
    private static int n;
    private static int[] netwrtchar(int index){
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<n; i++){
            int sum = 0;
            for(int j=0; j<words[i].length; j++){
                if(j==index) continue;
                sum += words[i][j];
            }
            list.add(words[i][index] - sum);
            // f[i] = words[i][index] - sum;
        }
        Collections.sort(list, Collections.reverseOrder());
        int[] f = new int[list.size()];
        for(int i=0; i<list.size(); i++){
            f[i] = list.get(i);
        }
        return f;
    }
    private static int maxWindow(int[] f){
        int count = 0, sum = 0;
        int index = 0;
        while(index<f.length && sum+f[index]>0){
            sum += f[index++];
            count++;
        }
        return count;
    }
    public static void main(String[] args){
        FS sc = new FS();
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-->0){
            n = sc.nextInt();
            words = new int[n][5];
            maxWords = 0;
            for(int i=0; i<n; i++){
                String s = sc.next();
                for(int j=0; j<s.length(); j++){
                    words[i][s.charAt(j)-'a']++;
                }
            }
            int maxWindow = 0;
            for(int i=0; i<5; i++){
                int[] f = netwrtchar(i);
                int current = maxWindow(f);
                maxWindow = Math.max(maxWindow, current);
            }
            System.out.println(maxWindow);
        }
        pw.flush();
        pw.close();
    }

    
}
","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
624b8db5,eacc407e,"import java.io.*;
import java.util.*;
public class C
{
    private static ArrayDeque<Integer>[] edge;
    private static HashMap<String,Integer> map;

    private static String getHash(int u, int v)
    {
        if(u>v)
        {
            int tmp=u;
            u=v;
            v=tmp;
        }

        return u+"" ""+v;
    }
    private static void DFS(int u, int p, int[] ans, int val)
    {
        for(int v:edge[u])
        {
            if(v==p) continue;
            ans[map.get(getHash(u,v))]=val;

            DFS(v,u,ans,5-val);
            val=5-val;
        }
    }
    public static void main(String[] args) throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int i,N;

        int T=Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();

        while (T-->0)
        {
            N=Integer.parseInt(br.readLine().trim());
            edge=new ArrayDeque[N];
            for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();

            map=new HashMap<>();
            int[] ans=new int[N-1];
            int[] deg=new int[N];

            for(i=0;i<N-1;i++)
            {
                String[] s=br.readLine().trim().split("" "");
                int u=Integer.parseInt(s[0])-1;
                int v=Integer.parseInt(s[1])-1;

                edge[u].add(v); edge[v].add(u);
                deg[u]++; deg[v]++;

                map.put(getHash(u,v),i);
            }

            for(i=0;i<N;i++) if(deg[i]>2) break;
            if(i<N)
            {
                sb.append(-1).append(""\n"");
                continue;
            }

            DFS(0,0,ans,2);
            for(int x:ans) sb.append(x).append("" "");
            sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
","import java.io.*;
import java.util.*;

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

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

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

	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();
			res = new int[n - 1];
			adj = new ArrayList[n];
			for (int i = 0; i < n; i++) {
				adj[i] = new ArrayList<int[]>();
			}
			for (int i = 0; i < n - 1; i++) {
				int u = sc.nextInt() - 1;
				int v = sc.nextInt() - 1;
				adj[u].add(new int[] { v, i });
				adj[v].add(new int[] { u, i });
			}

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

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

	

}
",0,Non-plagiarised
7bcacc97,e431de28,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
	//  StringBuilder sb=new StringBuilder();
	
//	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	Scanner sc=new Scanner(System.in);
//	int t=Integer.parseInt(bf.readLine());
    int t=sc.nextInt();
	while(t-->0)
	{
	 //  ArrayList<Integer> abcd=new ArrayList<>();
	 //  HashMap<Integer,Integer> amd=new HashMap<>();
	 
	 
	 
	   //   int n=Integer.parseInt(bf.readLine());
	   //   int a[]=new int[n];
	   //   String s[]=bf.readLine().split("" "");
	   //   for(int i=0;i<n;i++)
	   //   {
	   //       a[i]=Integer.parseInt(s[i]);
	   //   }
	   
	      int n=sc.nextInt();
	      long a[]=new long[n];
	      for(int i=0;i<n;i++)
	      {
	          a[i]=sc.nextLong();
	      }
	      
	      long ans=Long.MAX_VALUE;
	      int count1=1;
	      int count2=1;
	      boolean san=true;
	      long sum1=a[0];
	      long sum2=a[1];
	      long min1=a[0];
	      long min2=a[1];
	      ans=((n*1L*sum1)+(n*1L*sum2));
	     // System.out.println(""san ""+ans);
	      for(int i=2;i<n;i++)
	      {
	          if(san)
	          {
	              count1++;
	              san=false;
	              sum1+=a[i];
	              min1=Math.min(min1,a[i]);
	              long z1=sum1+(n-count1)*min1;
	              long z2= sum2+(n-count2)*min2;
	              ans=Math.min(ans,z1+z2);
	              
	          }
	          else
	          {
	              count2++;
	              san=true;
	              sum2+=a[i];
	              min2=Math.min(min2,a[i]);
	              long z1=sum1+(n-count1)*min1;
	              long z2= sum2+(n-count2)*min2;
	              ans=Math.min(ans,z1+z2);
	              
	              
	          }
	       //   System.out.println(i+"" ""+ans);
	      }
	      System.out.println(ans);
	      
	      
	      
	      
	    
	}
	
	}
	
	
	
	
	
	
}
","import java.io.*;
import java.lang.*;
import java.util.*;
public class MinGridPath {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int t=s.nextInt();
		while(t-->0){
			
			int n = s.nextInt();
			long[] aa =new long[n];
			for(int i=0;i<n;i++)
				aa[i]=s.nextLong();
 
			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
			
		}
	}

}
",0,Non-plagiarised
2bd5c798,317baeaf,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;

/**
 *
 * @Har_Har_Mahadev
 */

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

	public static void process() throws IOException {

		int n = sc.nextInt();
		String s = sc.next(),t = sc.next();
		int zs = 0, zt = 0;
		for(int i = 0; i<n; i++) {
			if(s.charAt(i) == '0')zs++;
			if(t.charAt(i) == '0')zt++;
		}
		
		int ans = n+1;
		if(zs == zt) {
			int min = 0;
			for(int i = 0; i<n; i++)if(s.charAt(i) != t.charAt(i))min++;
			ans = min(ans, min);
		}
		if(n-zs-1 == zt) {
			int min = 0;
			for(int i = 0; i<n; i++)if(s.charAt(i) == t.charAt(i))min++;
			ans = min(ans, min);
		}
		if(ans == n+1)ans = -1;
		System.out.println(ans);

	}

	//=============================================================================
	//--------------------------The End---------------------------------
	//=============================================================================
	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
	private static int N = 0;

	

	static FastScanner sc;
	static FastWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new FastWriter(System.out);
		} else {
			sc = new FastScanner(""input.txt"");
			out = new FastWriter(""output.txt"");
		}
		long s = System.currentTimeMillis();
		int t = 1;
		t = sc.nextInt();
		int TTT = 1;
		while (t-- > 0) {
			//			google(TTT++);
			process();
		}
		out.flush();
		//		tr(System.currentTimeMillis()-s+""ms"");
	}

	private static boolean oj = System.getProperty(""ONLINE_JUDGE"") != null;

	

	

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

	

	

	

	

	

	

	

	

	

	

	

	

	//custom multiset (replace with HashMap if needed)
	

	

	// compress Big value to Time Limit
	

	// Fast Writer 

	

	// Fast Inputs
	

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

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

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

			int ans = Integer.MAX_VALUE;

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

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

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

		pw.close();
  }
}
",1,Plagiarised
b2bae06a,d4779c71,"import java.util.*;
    import java.io.*;
    public class D{
        
        
         
        static int mod = (int)(1e9+7);
        

        public static void main(String[] args) {
            InputReader in = new InputReader(System.in);
            OutputWriter out = new OutputWriter(System.out);
            int n = in.nextInt();
            int[] arr = in.nextIntArray(n);
            Stack<Integer> min = new Stack<>();
            Stack<Integer> max = new Stack<>();
            int[] dp = new int[n];
            // Arrays.fill(dp,(int)1e9);
            dp[0] = 0;
            min.push(0);
            max.push(0);
            for(int i=1;i<n;i++)
            {
                int h=dp[i-1]+1;
                while(!max.isEmpty() && arr[i]>arr[max.peek()])
                {
                    int x = arr[max.peek()];
                    h = Math.min(h,1+dp[max.pop()]);
                    while(!max.isEmpty() && arr[max.peek()]==x)
                    {
                        max.pop();
                    }
                }
                if(!max.isEmpty())
                {
                    h = Math.min(h,1+dp[max.peek()]);
                }
                while(!min.isEmpty() && arr[i]<arr[min.peek()])
                {
                    int x = arr[min.peek()];
                    h = Math.min(h,1+dp[min.pop()]);
                    while(!min.isEmpty() && arr[min.peek()]==x)
                    {
                        min.pop();
                    }
                }
                if(!min.isEmpty())
                {
                    h = Math.min(h,1+dp[min.peek()]);
                }
                dp[i] = h;
                min.push(i);
                max.push(i);
            }
            out.printLine(dp[n-1]);
            out.flush();
            out.close();
        }
    }
","import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class D {
    static Scanner sc = new Scanner(System.in);
    static int[] height;
    static int[] dp;

    public static void main(String[] args) {
        int n = sc.nextInt();
        height = new int[n];
        dp = new int[n];
        dp[0] = 0;
        for (int i = 0; i < n; i++) {
            height[i] = sc.nextInt();
        }
        Stack<Integer> rise = new Stack<Integer>();
        Stack<Integer> fail = new Stack<Integer>();
        rise.push(0);
        fail.push(0);
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i-1]+1;

            if (rise.isEmpty()) {
                rise.push(i);
            } else if (height[rise.peek()] < height[i]) {
                rise.push(i);
            } else {
                while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
                    rise.pop();
                    if (!rise.isEmpty()) {
                        dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
                    }
                }
                while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
                    rise.pop();
                }
                rise.push(i);
            }


            if (fail.isEmpty()) {
                fail.push(i);
            } else if (height[fail.peek()] > height[i]) {
                fail.push(i);
            } else {
                while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
                    fail.pop();
                    if (!fail.isEmpty()){
                        dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
                    }
                }
                while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
                    fail.pop();
                }
                fail.push(i);
            }
        }

        System.out.println(dp[n - 1]);

    }
}
",0,Non-plagiarised
1f257299,76b978c2,"import java.lang.reflect.Array;
import java.util.*;
import java.io.*;

//import static com.sun.tools.javac.jvm.ByteCodes.swap;




public class fastTemp {


    static FastScanner fs = null;

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

        int t = fs.nextInt();
        while (t-- > 0) {
            int n = fs.nextInt();
           int p[] = new int[n];
           Arrays.fill(p,-1);
           for(int i=0;i<n;i++){
               if(p[i]!=-1){
                   continue;
               }
               System.out.println(""? ""+(i+1));
               int ans = (i+1);
               int x = fs.nextInt();
               while(p[x-1]==-1){
                   System.out.println(""? ""+(i+1));
                   int last = fs.nextInt();
                   p[x-1] = last;
                   x = last;
               }

           }
            System.out.print(""! "");
           for(int i=0;i<n;i++){
               System.out.print(p[i]+"" "");
           }

            System.out.flush();

        }
    }

    
    

    

    

    

    

    

    

    

    // Returns n^(-1) mod p
    

    // Returns nCr % p using Fermat's
    // little theorem.

    


//public static int dijkstra(int src , int dist[] ){
//
//PriorityQueue<Pair> q = new PriorityQueue<>();
//q.add(new Pair(1,0));
//
//while(q.size()>0){
//
//    Pair rem = q.remove();
//    for(Pair x:graph[rem.y]){
//        if(dist[x.y]>dist[rem.y]+x.wt){
//            dist[x.y] = dist[rem.y] + x.wt;
//            q.add(new Pair(x.y,dist[x.y]));
//        }
//    }
//
//}
//
//return dist[dist.length-1];
//
//}
    // T --> O(n) && S--> O(d)




    

    



    


    
    
    // ------------------------------------------swap----------------------------------------------------------------------

    


    //-------------------------------------------seiveOfEratosthenes----------------------------------------------------


    



    //------------------------------------------- power------------------------------------------------------------------



    
    

    //---------------------------------------EXTENDED EUCLID ALGO--------------------------------------------------------
//    public static class Pair{
//        int x;
//        int y;
//        public Pair(int x,int y){
//            this.x = x;
//            this.y = y ;
//        }
//    }

//    public static Pair Euclid(int a,int b){
//
//        if(b==0){
//            return new Pair(1,0);  // answer of x and y
//        }
//
//        Pair dash = Euclid(b,a%b);
//
//        return new Pair(dash.y , dash.x - (a/b)*dash.y);
//
//
//    }
//--------------------------------GCD------------------GCD-----------GCD--------------------------------------------

    
    

// This is an extension of method 2. Instead of moving one by one, divide the array in different sets
//where number of sets is equal to GCD of n and d and move the elements within sets.
//If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
//Here is an example for n =12 and d = 3. GCD is 3 and


//     void leftRotate(int arr[], int d, int n)
//     {
//         /* To handle if d >= n */
//         d = d % n;
//         int i, j, k, temp;
//         int g_c_d = gcd(d, n);
//         for (i = 0; i < g_c_d; i++) {
//             /* move i-th values of blocks */
//             temp = arr[i];
//             j = i;
//             while (true) {
//                 k = j + d;
//                 if (k >= n)
//                     k = k - n;
//                 if (k == i)
//                     break;
//                 arr[j] = arr[k];
//                 j = k;
//             }
//             arr[j] = temp;
//         }
//     }


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

//    public static void find(int n,int arr[])
//    {
//
//    }
//    2,1,3,4
    public static void main(String[] args) throws IOException{

        Reader sc=new Reader();
//        PrintWriter out = new PrintWriter(System.out);

        int t=sc.nextInt();
        while(t-->0)
        {
            int n = sc.nextInt();
            int p[]=new int[n];
            System.out.println(""? 1"");
            System.out.flush();
            int t1 = sc.nextInt();

            Set<Integer> hs = new HashSet<>();
            int i=1;
            int prev=1;
            int cnt=1;
            while(i<n && cnt<2*n)
            { 
                if(p[prev-1]!=0)
                {
                    i++;
                    if(i>=n || cnt>=2*n) break;
                    System.out.println(""? ""+i);
                    System.out.flush();
                    cnt++;

                    int t2 = sc.nextInt();
                    prev=t2;
                    continue;
                }
                String s1 = ""? ""+i;
                System.out.println(s1);
                System.out.flush();
                int tt = sc.nextInt();
                
                cnt++;                
                p[prev-1]=tt;
                prev=tt;
            }
            long sum=0;
            int ind=-1;
            for(i=0;i<n;i++)
            {
                sum+=p[i];
                if(p[i]==0) ind=i;
            }
            long diff = n*(n+1)-sum*2;
            if(diff>0)
            {
                p[ind]=(int)(diff/2);
            }
            System.out.print(""!"");
            for(i=0;i<n;i++)
            {
                System.out.print("" ""+p[i]);
            }

//            out.println(Arrays.toString(p));
            System.out.println();
            System.out.flush();
        }
        System.out.flush();
    }

    

    //    (a*a_inverse) = 1(mod m)
//    finding a_inverse
    

    //    (x^power)mod(m)
    
    

    

    //    prime no smaller than or equal to n
    
    
    //       Arrays.sort(arr, new Comparator<pair>() {
//        //@Override
//        public int compare(pair o1, pair o2) {
//            long l1=o1.a-o2.a;
//            if(l1<0L) return -1;
//            if(l1==0) return 0;
//            return 1;
//        }
//    });
    

}
",0,Non-plagiarised
3a12e509,c9159d9c,"import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
","import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
",0,Non-plagiarised
29cb9b0e,c77654b8,"import java.util.*;
public class Main
{
  
    public static void solve (int ar[],int n)
    {
       if(n%2==1)
        {
    
           
            int c=ar[2];
            int b=ar[1];
            int a=ar[0];
            if(a+b!=0)
            {
               ar[2]=-(a+b);
               ar[1]=c;
               ar[0]=c;
            }
            else if(b+c!=0)
            {
                 ar[2]=a;
               ar[1]=a;
               ar[0]=-(b+c);
            }
            else
            {
                 ar[2]=b;
               ar[1]=-(a+c);
               ar[0]=b;
            }
            System.out.print(ar[0]+"" ""+ar[1]+"" ""+ar[2]+"" "");
           for(int i=3;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           } 
            System.out.println();
        }
          //  System.out.println(ans[n-1]+ "" x""+ans[n-2]+"" x""+ans[n-3]);
           
          else
          {
              for(int i=0;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           }  
            System.out.println();
          }
          
           
        
    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		   int ar[]=new int[n];
		   for(int i=0;i<n;i++)
		   ar[i]=sc.nextInt();
		   solve(ar,n);
		}
	}
}
","import java.io.PrintWriter;
import java.util.*;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int tc = sc.nextInt();
        while(tc-->0){
            int n = sc.nextInt();
            int[] arr = new int[n]; for(int i = 0; i<n; i++)arr[i] = sc.nextInt();
            if(n % 2 == 0){
                for(int i = 0; i<n; i+=2){
                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
                }
                pw.println();
            }else{
                if(arr[0] + arr[1] != 0) pw.print(arr[2] + "" "" + arr[2] + "" "" + (-(arr[0] + arr[1])) + "" "");
                else if(arr[0] + arr[2] != 0)pw.println(arr[1] + "" "" + (-(arr[0] + arr[2]))+"" "" + arr[1]);
                else pw.println(-(arr[1] + arr[2]) + "" "" + arr[0]+"" "" + arr[0]);
                for(int i = 3; i<n; i+=2){
                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
                }
                pw.println();
            }
        }
        pw.flush();
    }
}
",0,Non-plagiarised
24afd00e,810fd282,"import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
public class CP {
	  
	 static int mod  = 1000000007;
	 
	 
	 
	
	 

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

		static void TEST_CASE() {
		int n = sc.nextInt();
		 lr = new long[n][2];
		for(int  i =0 ; i < n ; i ++) {
			lr[i][0] = sc.nextLong();
			lr[i][1] = sc.nextLong();
		}
		 adj = new ArrayList<ArrayList<Integer>>();
		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
		
		for(int i = 0 ; i<n-1 ; i++) {
			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
			adj.get(u).add(v);
			adj.get(v).add(u);
		}
		min = new long[n];
		max = new long[n];
		dfs(0,-1);
		sb.append(Math.max(min[0], max[0])).append(""\n"");
		
		}
		static long[] min , max , lr[];
		static ArrayList<ArrayList<Integer>> adj;
		static void dfs(int u , int p  ) {
			
			for(int child:adj.get(u)) {
				if(child == p) continue;
				dfs(child , u);
			}
			long left = lr[u][0] , right = lr[u][1];
			
			long ansl = 0 , ansr = 0;
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
						max[child] +Math.abs(left - rightc)      );
			}
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
						max[child] +Math.abs(right - rightc)      );
			}
			min[u] = ansl;
			max[u] = ansr;
			
		}
		
}
","import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main
{
	static int N=(int)2e5+10;
	static long[][] dp=new long[2][N];
	static int[][] A=new int[2][N];
	static ArrayList<ArrayList<Integer>> adj=new ArrayList<>(N);
	static
	{
		for(int i=0;i<N;i++)
			adj.add(new ArrayList<>());
	}
	
	public static void dfs(int v,int p)
	{
		dp[0][v]=dp[1][v]=0;
		for(Integer u:adj.get(v))
		{
			if(u==p)
				continue;
			dfs(u, v);
			dp[0][v]+=Math.max(Math.abs(A[0][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[0][v]-A[0][u]));
			dp[1][v]+=Math.max(Math.abs(A[1][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[1][v]-A[0][u]));
		}
	}
	
	public static void main(String[] args) throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(br.readLine());
		while(t-->0)
		{
			int n=Integer.parseInt(br.readLine());
			for(int i=1;i<=n;i++)
			{
				String[] ss1=br.readLine().split("" "");
				A[0][i]=Integer.parseInt(ss1[0]);
				A[1][i]=Integer.parseInt(ss1[1]);
				adj.set(i, new ArrayList<>());
			}
			for(int i=1;i<n;i++)
			{
				String[] ss2=br.readLine().split("" "");
				int u=Integer.parseInt(ss2[0]);
				int v=Integer.parseInt(ss2[1]);
				adj.get(u).add(v);
				adj.get(v).add(u);
			}
			dfs(1, -1);
			System.out.println(Math.max(dp[0][1], dp[1][1]));
		}
    }
}
",0,Non-plagiarised
63bfa731,7974ffba,"import java.util.*;
import java.io.*;

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

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


    }
    
    
    


}
",1,Plagiarised
953ac418,ba9b94f7,"import java.io.*;
import java.lang.*;
import java.util.*;

public class E1578 {
    public static void main(String[] args) throws IOException{
        StringBuffer ans = new StringBuffer();
        StringTokenizer st;
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer(f.readLine());
        int q = Integer.parseInt(st.nextToken());
        for(; q > 0; q--){
            st = new StringTokenizer(f.readLine());
            st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());
            int[] a = new int[k];
            st = new StringTokenizer(f.readLine());
            for(int i = 0; i < k; i++){
                a[i] = Integer.parseInt(st.nextToken()) - 1;
            }
            int[] arr = new int[n];
            int[] b = new int[k];
            st = new StringTokenizer(f.readLine());
            Arrays.fill(arr, Integer.MAX_VALUE-1);
            for(int i = 0; i < k; i++){
                b[i] = Integer.parseInt(st.nextToken());
                arr[a[i]] = b[i];
            }
            int[] l = new int[n];
            int[] r = new int[n];
            for(int i = 0; i < n; i++){
                if(i == 0)
                    l[i] = arr[i];
                else
                    l[i] = Math.min(l[i-1]+1, arr[i]);
            }
            for(int i = n-1; i > -1; i--){
                if(i == n-1)
                    r[i] = arr[i];
                else
                    r[i] = Math.min(r[i+1]+1, arr[i]);
            }
            for(int i = 0; i  < n; i++)
                ans.append(Math.min(l[i], r[i])).append("" "");
            ans.append(""\n"");
        }

        f.close();



        System.out.println(ans);
    }
    

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

public class _1547_E {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int t = Integer.parseInt(in.readLine());
        while(t-- > 0) {
            in.readLine();
            StringTokenizer line1 = new StringTokenizer(in.readLine());
            int n = Integer.parseInt(line1.nextToken());
            int k = Integer.parseInt(line1.nextToken());
            int[] x = new int[n];
            line1 = new StringTokenizer(in.readLine());
            StringTokenizer line2 = new StringTokenizer(in.readLine());
            TreeSet<AC> after = new TreeSet<AC>();
            for(int i = 0; i < k; i++) {
                int ai = Integer.parseInt(line1.nextToken()) - 1;
                int ti = Integer.parseInt(line2.nextToken());
                x[ai] = ti;
                after.add(new AC(ti, ai));
            }
            TreeSet<AC> before = new TreeSet<AC>();
            int[] res = new int[n];
            for(int i = 0; i < n; i++) {
                if(x[i] > 0) {
                    after.remove(new AC(x[i], i));
                    before.add(new AC(x[i], n - i));
                }
                AC be = before.size() == 0 ? null : before.first();
                AC af = after.size() == 0 ? null : after.first();
                if(be == null) {
                    res[i] = af.d + af.t - i;
                }else if(af == null) {
                    res[i] = be.d + be.t - (n - i);
                }else {
                    res[i] = Math.min(af.d + af.t - i, be.d + be.t - (n - i));
                }
            }
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < n; i++) {
                sb.append(res[i]);
                sb.append(' ');
            }
            out.println(sb.toString());
        }
        in.close();
        out.close();
    }
    static class AC implements Comparable<AC> {
        int t, d;
        AC(int tt, int dd) {
            t = tt;
            d = dd;
        }
        
    }
}
",0,Non-plagiarised
9862c742,d9199dfd,"import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner s  = new Scanner(System.in);
		int t = s.nextInt();
		while(t-- > 0){
		    int n = s.nextInt();
		    int[] arr = new int[n];
		    for(int i=0;i<n;i++)
		        arr[i] = s.nextInt();
		    String str = s.next();
		    List<Integer> left = new ArrayList<>();
		    List<Integer> right = new ArrayList<>();
		    for(int i=0;i<arr.length;i++){
		        if(str.charAt(i) == 'B')
		            left.add(arr[i]);
		        else right.add(arr[i]);
		    }
		    Collections.sort(left);
		    Collections.sort(right);
		    boolean flag = false;
		    for(int i=0;i<left.size();i++)
		        if(left.get(i) < i+1){
		            flag = true;
		            break;
		        }
		    if(!flag){
		        for(int i=0;i<right.size();i++)
    		        if(right.get(i) > left.size()+i+1){
    		            flag = true;
    		            break;
    		        }
		    }
		    if(flag)
		        System.out.println(""NO"");
		    else System.out.println(""YES"");
		}
	}
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",0,Non-plagiarised
646b3abc,8261bd1c,"import java.util.*;
import java.io.*;

public class Main {
    static FastScanner sc = new FastScanner(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static StringBuilder sb = new StringBuilder();
    static long mod = (long) 1e9 + 7;

    public static void main(String[] args) throws Exception {
        int n = sc.nextInt();
        for(int i = 0; i < n; i++) solve();
        pw.flush();
    }

    public static void solve() {
        int n = sc.nextInt();
        char[] a = sc.next().toCharArray();
        char[] b = sc.next().toCharArray();
        boolean isFirst = false;
        boolean allOk = true;
        int a1 = 0;
        int a0 = 0;
        int b1 = 0;
        int b0 = 0;
        int[][] cnt1 = new int[2][2];
        for(int i = 0; i < n; i++){
            if(a[i] != b[i]){
                allOk = false;
            }
            if(a[i] == '1'){
                a1++;
                isFirst = true;
            }else{
                a0++;
            }
            if(b[i] == '1'){
                b1++;
            }else{
                b0++;
            }
            cnt1[a[i]-'0'][b[i]-'0']++;
        }
        if(allOk){
            pw.println(0);
            return;
        }else if(!isFirst){
            pw.println(-1);
            return;
        }else if(a1 != b1 && (a0+1) != b1){
            pw.println(-1);
            return;
        }else{
            int same = cnt1[1][1] - cnt1[0][0] == 1 ? cnt1[1][1] + cnt1[0][0] : Integer.MAX_VALUE;
            int odd = cnt1[1][0] - cnt1[0][1] == 0 ? cnt1[1][0] + cnt1[0][1] : Integer.MAX_VALUE;
            int min = Math.min(same,odd);
            pw.println(min == Integer.MAX_VALUE ? -1 : min);
        }
    }
    

    
}


","import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;



public class Cgr18A {


    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        int t = sc.nextInt();
//        int t = 1;
        while (t-- != 0) {
            solver.solve(sc, out);
        }
        out.close();

    }

    static class Solver {
        final int INF = (int) 1e9;
        public void solve(InputReader sc, PrintWriter out) {
            int n = sc.nextInt();
            char[] a = sc.next().toCharArray();
            char[] b = sc.next().toCharArray();
            boolean isAllZeroA = isAllZero(a);
            boolean isAllZeroB = isAllZero(b);
            if(isAllZeroA && isAllZeroB) {
                out.println(0);
                return;
            }
            if(isAllZeroA || isAllZeroB) {
                out.println(-1);
                return;
            }
            int eq = 0;
            for(int i = 0; i< n;i++) if(a[i]==b[i]) eq++;
            int eqHasOne = 0;
            int notEqHasOne = 0;
            int noteq = n-eq;
            for (int i = 0; i < n; i++) {
                if(a[i]==b[i] && a[i]=='1') eqHasOne++;
                if(a[i]!=b[i] && a[i]=='1') notEqHasOne++;
            }
            int l = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},0);
            int r = solveIt(new int[] {eq,noteq},new int[] {eqHasOne,notEqHasOne},1);
            if(l==INF && r==INF) {
                out.println(-1);
            } else {
                out.println(Math.min(l,r));
            }
        }

        private boolean isAllZero(char[] a) {
            for(char c : a) if(c=='1') return false;
            return true;
        }

        private int solveIt(int[] arr,int[] hasOne, int minusPointer) {
            if(arr[0]==0 && arr[1]==0) throw new RuntimeException();
            int cnt = 0;
            int max = arr[0] + arr[1];
            while(arr[1]!=0) {
                int minus = minusPointer;
                int plus = 1-minus;
                if(hasOne[minusPointer]<1) return INF;
                int eqHasOne = hasOne[0];
                int notEqHasOne = hasOne[1];
                int eqHasZero = arr[0] - eqHasOne;
                int notEqHasZero = arr[1] - notEqHasOne;
                if(minusPointer==0) {
                    int newNotEqHasOne = eqHasZero;
                    int newEqHasOne = notEqHasZero + 1;
                    hasOne[0] = newEqHasOne;
                    hasOne[1] = newNotEqHasOne;
                } else {
                    int newEqHasOne = notEqHasZero;
                    int newNotEqHasOne = eqHasZero + 1;
                    hasOne[0] = newEqHasOne;
                    hasOne[1] = newNotEqHasOne;
                }
                int minusValue = arr[minus]-1;
                int plusValue = arr[plus]+1;
                arr[minus] = plusValue;
                arr[plus] = minusValue;
                minusPointer = 1-minusPointer;
                cnt++;
                if(cnt>max+10) break;
            }
            if(arr[1]!=0) return INF;
            return cnt;
        }
    }

    

    

    

    

    


}
",0,Non-plagiarised
83b44c9c,8d9871a9,"import java.util.Scanner;

public class MinimumGridPath {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int test = scanner.nextInt();

        StringBuilder sb = new StringBuilder();
        for (int t = 0; t < test; t++) {
            int n = scanner.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextLong();
            }

            long minx = arr[0];
            long miny = arr[1];

            long min = minx * n + miny * n;
            long sumx = arr[0];
            long sumy = arr[1];

            for(int i=2; i<n; i++) {
                int xc;
                int yc;
                if(i%2 == 0) {
                    xc = i/2 + 1;
                    yc = i/2;
                    sumx += arr[i];
                    minx = Math.min(minx, arr[i]);
                } else {
                    xc = i/2 + 1;
                    yc = i/2 + 1;
                    sumy += arr[i];
                    miny = Math.min(miny, arr[i]);
                }
                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
            }


            sb.append(min).append(System.lineSeparator());
        }
        System.out.println(sb);

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

public class Main {
	static Scanner scan = new Scanner(System.in);

	static int[] readArray(int[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
		return x;
	}

	static long[] readArray(long[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
		return x;
	}


	

	public static void main(String[] args) {
		int t = scan.nextInt();
		for(int it=0; it<t; ++it) {
			int n = scan.nextInt();
			long[] aa = readArray(new long[n]);

			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
		}
	}
}
",0,Non-plagiarised
3412b353,528a6162,"import java.io.*;
import java.util.*;

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

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

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

            long max[]=new long[n+1];
            for(i=1;i<=n;i++)
            {
                int j;
                long here=h[i];
                for(j=i-1;j>=0;j--)
                {
                    long diff=here-(k[i]-k[j]);
                    if(diff<=0) {max[i]=max[j]+here*(here+1)/2; break;}
                    if(diff<h[j]) here+=h[j]-diff;
                }
            }
            sb.append(max[n]+""\n"");
        }
        System.out.print(sb);
    }
}
",1,Plagiarised
0d11fb94,f9e08a46,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;


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

    static List<Integer> zeros = new ArrayList<>();
    static List<Integer> ones = new ArrayList<>();
    static int oneCount = 0;
    static int[][] dp = new int[5005][5005];

    public static void main(String[] args) {
        t = 1;

        while (t-- > 0) {

            n = fs.nextInt();

            for(int i = 0;i<n;i++){
                x = fs.nextInt();
                if(x==1){
                    ones.add(i);
                    oneCount++;
                }
                else
                    zeros.add(i);
            }

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

            out.println(minCost(0,0));
        }

        out.close();
    }

    static int minCost(int zIndex, int oIndex){

        if(oIndex == ones.size())
            return 0;
        if(zIndex == zeros.size())
            return 1000000007;

        if(dp[zIndex][oIndex]==-1)
            dp[zIndex][oIndex]= Math.min(Math.abs(zeros.get(zIndex) - ones.get(oIndex))+minCost(zIndex+1, oIndex+1) , minCost(zIndex+1, oIndex));

        return dp[zIndex][oIndex];
    }


    

    

    

    

    


}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;


public class Armchair {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int arr[]=new int[n];
        ArrayList<Integer> list1=new ArrayList<Integer>();
         ArrayList<Integer> list2=new ArrayList<Integer>();
        for(int i=0;i<n;i++)
        {
            int a=in.nextInt();
            if(a==0)
                list2.add(i);
            else
                list1.add(i);
        }
        long dp[][]=new long[list1.size()+1][list2.size()+1];
        
        solve(list1,list2,dp);
        System.out.println(dp[list1.size()][list2.size()]);
    }

public static void solve( ArrayList<Integer> list1,ArrayList<Integer> list2,long dp[][]){
       for(int i=1;i<=list1.size();i++)
		dp[i][0]=Integer.MAX_VALUE;

	for(int i=1;i<=list1.size();i++){
		for(int j=1;j<=list2.size();j++){
			dp[i][j]=Math.min(Math.abs(list1.get(i-1)-list2.get(j-1))+dp[i-1][j-1],dp[i][j-1]);
		}
	}
}
}
",0,Non-plagiarised
548ffb07,e7dce35b,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	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 Main {
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int n = nextInt();
        int k = nextInt();

        f = new int[n + 42];
        rf = new int[n + 42];
        f[0] = 1;
        rf[0] = 1;
        for (int i = 1; i < f.length; i++) {
            f[i] = mul(f[i - 1], i);
            rf[i] = mul(rf[i - 1], inv(i));
        }

        int[] a = new int[n * 2];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt() * 2;
            a[i + n] = nextInt() * 2 + 1;
        }
        Arrays.sort(a);

        int ans = 0;
        int curOpen = 0;
        for (int r = 0; r < 2 * n;) {
            int l = r;
            while (r < 2 * n && a[l] == a[r]) r++;
            int intersections = r - l;
            if (a[l] % 2 == 0) {
                ans += C(curOpen + intersections, k);
                if (ans >= mod) ans -= mod;
                ans += mod - C(curOpen, k);
                if (ans >= mod) ans -= mod;
                curOpen += intersections;
            } else {
                curOpen -= intersections;
            }
        }

        pw.println(ans);
        pw.close();
    }

    static int mod = 998244353;

    static int mul(int a, int b) {
        return (int) ((long) a * (long) b % mod);
    }

    static int[] f;
    static int[] rf;

    static int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
    }

    static int pow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1) {
                res = mul(res, a);
            }
            a = mul(a, a);
            n >>= 1;
        }
        return res;
    }

    static int inv(int a) {
        return pow(a, mod - 2);
    }

    static StringTokenizer st = new StringTokenizer("""");
    static BufferedReader br;

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

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

    

    
}




",1,Plagiarised
1013b392,5a340556,"import java.io.*;
import java.util.*;

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

        ADMIN_MODE();

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


    }

    static boolean[] neg;

    static void solve() throws IOException {
        int n = sc.ni();
        neg = new boolean[n];
        pr[] arr = new pr[n];
        for(int i = 0; i < n; i++) {
            long curr = sc.nl();
            if(curr < 0) neg[i] = true;
            arr[i] = new pr(Math.abs(curr), i);
        }
        Arrays.sort(arr);
        long[] res = new long[n];
        for(int i = 0; i < n-1; i+=2) {
            long lcm = lcm(arr[i].val, arr[i+1].val);
            res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
            res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
        }

        if(n%2==1) {
            long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
            long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
            long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);

            if (aa == -1*bb) {
                if(aa == cc) {
                    pr temp = arr[n-1];
                    arr[n-1] = arr[n-2];
                    arr[n-2] = temp;
                } else {
                    pr temp = arr[n-3];
                    arr[n-3] = arr[n-1];
                    arr[n-1] = temp;
                }
            }
        }

        if(n%2==1) {
            long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
                    arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
            boolean f = (a < 0);
            a = Math.abs(a);
            long b = arr[n-1].val;
            long lcm = lcm(a, b);
            if(f) {
                res[arr[n-2].idx] = lcm/a * -1;
                res[arr[n-3].idx] = lcm/a * -1;
            } else {
                res[arr[n - 2].idx] = lcm / a;
                res[arr[n - 3].idx] = lcm / a;
            }
            res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
        }

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

    static class pr implements Comparable<pr>{
        long val;int idx;

        public pr(long val, int idx) {
            this.val = val;
            this.idx = idx;
        }

        
    }

    //--------------------------INPUT READER--------------------------------//

    //-----------------------------------------------------------------------//

    //---------------------------PRINTER-------------------------------------//
    //------------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-------------------------------UTILS------------------------------------//
    static long gcd(long a, long b) {
        return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
    }

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

    // region pow(a, b, mod) -> a^b
    
    // endregion
}
","import java.io.*;
import java.util.*;

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

        ADMIN_MODE();

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


        w.close();
    }

    static boolean[] neg;

    static void solve() throws IOException {
        int n = sc.ni();
        neg = new boolean[n];
        pr[] arr = new pr[n];
        for(int i = 0; i < n; i++) {
            long curr = sc.nl();
            if(curr < 0) neg[i] = true;
            arr[i] = new pr(Math.abs(curr), i);
        }
        Arrays.sort(arr);
        long[] res = new long[n];
        for(int i = 0; i < n-1; i+=2) {
            long lcm = lcm(arr[i].val, arr[i+1].val);
            res[arr[i].idx] = lcm/arr[i].val * (neg[arr[i].idx] ? -1 :1) * -1;
            res[arr[i+1].idx] = lcm/arr[i+1].val * (neg[arr[i+1].idx] ? -1 :1);
        }

        if(n%2==1) {
            long aa = arr[n-3].val * (neg[arr[n-3].idx] ? -1 : 1);
            long bb = arr[n-2].val * (neg[arr[n-2].idx] ? -1 : 1);
            long cc = arr[n-1].val * (neg[arr[n-1].idx] ? -1 : 1);

            if (aa == -1*bb) {
                if(aa == cc) {
                    pr temp = arr[n-1];
                    arr[n-1] = arr[n-2];
                    arr[n-2] = temp;
                } else {
                    pr temp = arr[n-3];
                    arr[n-3] = arr[n-1];
                    arr[n-1] = temp;
                }
            }
        }

        if(n%2==1) {
            long a = arr[n-2].val * (neg[arr[n-2].idx] ? -1 :1) +
                    arr[n-3].val * (neg[arr[n-3].idx] ? -1 :1);
            boolean f = (a < 0);
            a = Math.abs(a);
            long b = arr[n-1].val;
            long lcm = lcm(a, b);
            if(f) {
                res[arr[n-2].idx] = lcm/a * -1;
                res[arr[n-3].idx] = lcm/a * -1;
            } else {
                res[arr[n - 2].idx] = lcm / a;
                res[arr[n - 3].idx] = lcm / a;
            }
            res[arr[n-1].idx] = lcm/b * (neg[arr[n-1].idx] ? -1 :1) * - 1;
        }

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

    static class pr implements Comparable<pr>{
        long val;int idx;

        public pr(long val, int idx) {
            this.val = val;
            this.idx = idx;
        }

        
    }

    //--------------------------INPUT READER--------------------------------//
    //-----------------------------------------------------------------------//

    //---------------------------PRINTER-------------------------------------//
    //------------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-------------------------------UTILS------------------------------------//
    static long gcd(long a, long b) {
        return b == 0 ? (a < 0L ? -a: a) : gcd(b, a%b);
    }

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

    // region pow(a, b, mod) -> a^b
    
    // endregion
}
",1,Plagiarised
83b44c9c,ed610dc9,"import java.util.Scanner;

public class MinimumGridPath {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int test = scanner.nextInt();

        StringBuilder sb = new StringBuilder();
        for (int t = 0; t < test; t++) {
            int n = scanner.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextLong();
            }

            long minx = arr[0];
            long miny = arr[1];

            long min = minx * n + miny * n;
            long sumx = arr[0];
            long sumy = arr[1];

            for(int i=2; i<n; i++) {
                int xc;
                int yc;
                if(i%2 == 0) {
                    xc = i/2 + 1;
                    yc = i/2;
                    sumx += arr[i];
                    minx = Math.min(minx, arr[i]);
                } else {
                    xc = i/2 + 1;
                    yc = i/2 + 1;
                    sumy += arr[i];
                    miny = Math.min(miny, arr[i]);
                }
                min = Math.min(min, sumx + (n-xc) * minx + sumy + (n-yc) * miny);
            }


            sb.append(min).append(System.lineSeparator());
        }
        System.out.println(sb);

    }
}
","import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.Random;
import java.util.Arrays;
import java.util.StringTokenizer; 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Collections;
import java.util.*;
public class C 
{ 
    public static void main(String[] args) 
	{ 
		FastReader sc=new FastReader(); 
		StringBuffer ans=new StringBuffer();
		int test=sc.nextInt();
		while(test-->0)
		{
			int n=sc.nextInt();
			long arr[]=new long[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextLong();
			}
			long nn=n;
			long ep=1;
			long op=1;
			
			long se=arr[0];
			long so=arr[1];
			
			long sume=se;long sumo=so;
			long minm = (se*nn) +(so*nn);
			
			for(int i=2;i<n;i++) {
				if(i%2 == 0) {
					++ep;
					sume+=arr[i];
					se=Math.min(se, arr[i]);
				}
				else {
					++op;
					sumo+=arr[i];
					so=Math.min(so, arr[i]);
				}
				
				long cost = (sume)+(se*(nn-ep));
				cost+=((sumo)+(so*(nn-op)));
				minm=Math.min(cost, minm);
			}
			ans.append(minm+""\n"");
		
		}
		
	    System.out.print(ans);
	} 
        
    static final Random random=new Random();
    
	
	
	
	
	 


}
",0,Non-plagiarised
baa8e497,cc9230d3,"import java.util.*;
import java.io.*;

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

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

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

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

public class C {


    static int[][] lr = new int[2][(int)2e5+10];
    static long[][] dp = new long[2][(int)2e5+10];
    static ArrayList<ArrayList<Integer>> g;
    public static void main(String[] args) {
        
        FastReader fr = new FastReader();
        PrintWriter out = new PrintWriter(System.out, true);
        int cases = fr.nextInt();
        for(int c = 0; c < cases; c++) {
            int nodes = fr.nextInt();
            g = new ArrayList<ArrayList<Integer>>();
            
            for(int i = 1; i <= nodes; i++) {
                lr[0][i] = fr.nextInt();
                lr[1][i] = fr.nextInt();
            }
            for(int i = 0; i <= nodes; i++) {
                g.add(new ArrayList<Integer>());
            }

            for(int i = 0; i < nodes-1; i++) {
                int f = fr.nextInt();
                int t = fr.nextInt();
                g.get(f).add(t);
                g.get(t).add(f);
            }
            DFS(1, -1);
            out.write(Math.max(dp[0][1], dp[1][1]) + ""\n"");

        }
        out.close();
    }

    static void DFS(int v, int p) {
        dp[0][v] = dp[1][v] = 0;
        for(Integer u : g.get(v)) {
            if (u == p) continue;
            DFS(u, v);
            dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
            dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
        }
    }

    
}
",0,Non-plagiarised
778c91af,9399204d,"import java.io.*;
import java.util.*;
import java.text.DecimalFormat;

public class C {
    static long mod=(long)1e9+7;
    static long mod1=998244353;
    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);

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

        int t= in.nextInt();
        while(t-->0) {

            int n = in.nextInt();
            ArrayList<Pair>[] adj = new ArrayList[5];
            for(int i = 0;i<5;i++) adj[i] = new ArrayList<>();
            for(int i = 0;i<n;i++){
                char[] arr = in.next().toCharArray();
                int[] count = new int[5];
                for(char c:arr)
                    count[c-'a']++;
                for(int j = 0;j<5;j++){
                    adj[j].add(new Pair(count[j],arr.length-count[j]));
                }
            }
            int max = 0;
            for(int i = 0;i<5;i++){
                Collections.sort(adj[i]);
                int count = 0;
                int sum1 = 0;
                int sum2 = 0;
                for(Pair p:adj[i]){
                    if(sum1+p.a>sum2+p.b){
                        count++;
                        sum1+=p.a;
                        sum2+=p.b;
                    }
                }
                max = Math.max(max,count);
            }

            out.println(max);

        }
        out.close();
    }

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

        
    }


    static final Random random=new Random();

    
    
    
    

    

    
    
    

    
}
","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<5; i++)q[i]=new PriorityQueue<node1>();
			for(int i=0; i<N; i++)
			{
				char X[]=in.next().toCharArray();
				int s=X.length;
				size[i]=s;
				int f[]=new int[5];
				for(char x:X)f[x-'a']++;
				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
			}
			
			int max=0;
			for(int i=0; i<5; i++)
			{
				PriorityQueue<node1> q_new=new PriorityQueue<>();
				q_new=q[i];
				int c=0;
				long f=0;
				while(q_new.size()>0)
				{
					node1 x=q_new.remove();
//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
					f+=x.a;
					if(f>0)
					{
						c++;
						max=Math.max(max, c);
					}
					else break;
				}
			}
			out.println(max);
		}
		out.close();

	}
	
	
	

	
	
	
	


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

public class C {
	
	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		for (int tt=1; tt<=T; tt++) {
			int n=fs.nextInt();
			int m=fs.nextInt();
			int x=fs.nextInt();
			int arr[]=fs.readArray(n);
			if(m>n) {
				System.out.println(""NO"");
				continue;
			}
			int copy[]=new int [n];
			for(int i=0;i<n;i++) {
				copy[i]=arr[i];
			}
			Arrays.sort(copy);
			ArrayList<Integer> container[]= new ArrayList[x+1];
			for(int i=1;i<=x;i++) {
				container[i]=new ArrayList<Integer>();
			}
			for(int i=0;i<m;i++) {
				for(int j=i;j<n;j+=m) {
					container[copy[j]].add(i+1);
				}
			}
			int counter[]=new int [n];
			for(int i=0;i<n;i++) {
				counter[i]=container[arr[i]].get(0);
				container[arr[i]].remove(0);
			}
			System.out.println(""YES"");
			for(int i=0;i<n;i++) {
				System.out.print(counter[i]+"" "");
			}
			System.out.println();
		}
	}

	

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



public class Test{

    static class Pair implements Comparable<Pair>{
    int wt;
    int idx;
    Pair(int x,int y){
        this.wt=x;
        this.idx=y;
    }
    

    
}   



    public static void main (String[] args) throws java.lang.Exception{
        FastReader scan=new FastReader();
        int t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int m=scan.nextInt();
            int x=scan.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            Queue<Pair>q=new PriorityQueue<>();
            for(int i=1;i<=m;i++){
                q.add(new Pair(0,i));
            }
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                Pair temp=q.poll();
                int wt=temp.wt;
                int idx=temp.idx;
                System.out.print(idx+"" "");
                //System.out.println(temp);
                q.add(new Pair(wt+arr[i],idx));
            }
            System.out.println();


        }
    }

        
}
",0,Non-plagiarised
ad4c7a20,f8e7b886,"import java.io.*;
import java.util.*;


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
//	static Scanner sc=new Scanner(System.in);
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException, CloneNotSupportedException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		for(int i=1;i<=t;i++)
			solve(i);
		out.close();
		out.flush();
//		System.out.flush();
//		System.exit(0);
	}
	
	static void solve(int CASENO) throws IOException, CloneNotSupportedException
	{
		int n=sc.nextInt();
		int k[]=new int[n];
		int h[]=new int[n];
		for(int i=0;i<n;i++)
			k[i]=sc.nextInt();
		for(int i=0;i<n;i++)
			h[i]=sc.nextInt();
		ArrayList<Pair> interval=new ArrayList<Pair>();
		ArrayList<Pair> act=new ArrayList<Pair>();
		for(int i=0;i<n;i++)
			interval.add(new Pair(k[i]-h[i]+1,k[i]));
		Collections.sort(interval);
//		out.println(interval);
		act.add(interval.get(0).clone());
		for(int i=1;i<n;i++)
		{
			Pair p=act.get(act.size()-1);
			if(p.y<interval.get(i).x)
				act.add(interval.get(i).clone());
			else
				p.y=Math.max(p.y, interval.get(i).y);
		}
//		out.println(act);
		long mana=0;
		for(Pair p: act)
		{
			long x=p.y-p.x+1;
			mana+=(x*(x+1))/2;
		}
		out.println(mana);
	}
	static class Pair implements Cloneable, Comparable<Pair>
	{
		int x,y;
		Pair(int a,int b)
		{
			this.x=a;
			this.y=b;
		}
		
		
		
		@Override
		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
	
	
	
	
	
	
	
	
	
	
	
}
","import java.util.*;
import java.io.*;
import java.time.*;
import static java.lang.Math.*;

@SuppressWarnings(""unused"")
public class C {
	static boolean DEBUG = false;

	static Reader fs;
	static PrintWriter pw;

	static void solve() {
		int n = fs.nextInt(), k[] = fs.readArray(n), h[] = fs.readArray(n);
		int prev_h = h[0], prev_k = k[0];
//		int ans = 0;
		ArrayList<pair> intervals = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			int start = k[i] - h[i] + 1;
			int end = k[i];
			intervals.add(new pair(start, end));
		}
//		pw.println(intervals);
		Collections.sort(intervals);
		ArrayList<pair> merged = new ArrayList<>();
		merge(intervals, merged);
		long ans = 0;
		for(int i = 0 ; i < merged.size() ; i++) {
			ans += sum(merged.get(i).len());
		}
		pw.println(ans);
	}
	
	static void merge(ArrayList<pair>a1, ArrayList<pair>a2) {
		int n = a1.size();
		int index = 0;
		for(int i =1 ; i < n ; i++) {
			if(a1.get(index).s >= a1.get(i).f) {
				a1.get(index).s = max(a1.get(index).s, a1.get(i).s);
			}
			else {
				index++;
				a1.set(index, a1.get(i));
			}
		}
		for(int i = 0 ; i <= index ; i++) {
			a2.add(a1.get(i));
		}
//		pw.println(a1);
	}
	
//	int index = 0; // Stores index of last element 
//    // in output array (modified arr[]) 
//
//    // Traverse all input Intervals 
//    for (int i=1; i<arr.length; i++) 
//    { 
//        // If this is not first Interval and overlaps 
//        // with the previous one 
//        if (arr[index].end >=  arr[i].start) 
//        { 
//               // Merge previous and current Intervals 
//            arr[index].end = Math.max(arr[index].end, arr[i].end); 
//        } 
//        else {
//            index++;
//            arr[index] = arr[i]; 
//        }    
//    }
	
	
	
	static pair merge(pair p1, pair p2) {
		return new pair(min(p1.f, p2.f), max(p1.s, p2.s));
	}

	static long sum(long n) {
		return (n * (n + 1) / 2);
	}

	static class pair implements Comparable<pair>{
		int f, s;

		pair(int f, int s) {
			this.f = f;
			this.s = s;
		}

		
		
		
		
		public int len() {
			return s - f + 1;
		}
	}

	public static void main(String[] args) throws IOException {
		Instant start = Instant.now();
		if (args.length == 2) {
			System.setIn(new FileInputStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\input.txt"")));
			// System.setOut(new PrintStream(new File(""output.txt"")));
			System.setErr(new PrintStream(new File(""D:\\program\\javaCPEclipse\\CodeForces\\src\\error.txt"")));
			DEBUG = true;
		}
		fs = new Reader();
		pw = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-- > 0) {
			solve();
		}
		Instant end = Instant.now();
		if (DEBUG) {
			pw.println(Duration.between(start, end));
		}
		pw.close();
	}

	static void sort(int a[]) {
		ArrayList<Integer> l = new ArrayList<Integer>();
		for (int x : a)
			l.add(x);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++) {
			a[i] = l.get(i);
		}
	}

	

	
}
",0,Non-plagiarised
55ab9b5d,c6113c06,"import java.io.*;
import java.util.*;

public class Main {

    static int solve(char ch, char[][] str, int N) {
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            int c1 = 0, c2 = 0;
            for (char x : str[i]) {
                if (x == ch) c1++;
                else c2++;
            }
            a[i] = c1 - c2;
        }

        int sum = 0, count = N;
        for (int x : a) sum += x;

        Arrays.sort(a);
        for (int i = 0; i < N; i++) {
            if (sum > 0) break;
            count--;
            sum -= a[i];
        }
        return count;
    }

    public static void main(String[] args) throws IOException {
        // System.out.println(""===== input ====="");
        // BufferedReader br = new BufferedReader(new FileReader(""input/input1.txt""));
        // BufferedReader br2 = new BufferedReader(new FileReader(""input/input1.txt""));
        // String s;
        // while ((s = br2.readLine()) != null) {
        //     System.out.println(s);
        // }
        // System.out.println(""===== output ====="");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder out = new StringBuilder();
        int T = Integer.parseInt(st.nextToken());
        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine().trim());
            char[][] str = new char[n][];
            for (int i = 0; i < n; i++) {
                str[i] = br.readLine().trim().toCharArray();
            }

            int ans = 0;
            for (char ch = 'a'; ch <= 'e'; ch++) {
                ans = Math.max(ans, solve(ch, str, n));
            }
            out.append(ans).append(""\n"");
        }
        System.out.println(out);
    }
}
","import java.io.*;
import java.util.*;
public class D
{
    private static int solve(char ch, char[][] str, int N)
    {
        int[] a=new int[N];
        for(int i=0;i<N;i++)
        {
            int c1=0, c2=0;
            for(char x:str[i])
            {
                if(x==ch) c1++;
                else c2++;
            }
            a[i]=c1-c2;
        }

        int sum=0, count=N;
        for(int x:a) sum+=x;

        Arrays.sort(a);
        for(int i=0;i<N;i++)
        {
            if(sum>0) break;
            count--; sum-=a[i];
        }

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

        int i,N;

        int T=Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();

        while (T-->0)
        {
            N=Integer.parseInt(br.readLine().trim());
            char[][] str=new char[N][];

            for(i=0;i<N;i++) str[i]=br.readLine().trim().toCharArray();

            int ans=0;
            for(char ch='a';ch<='e';ch++)
            {
                int tmp=solve(ch,str,N);
                ans=Math.max(ans,tmp);
            }
            sb.append(ans).append(""\n"");
        }
        System.out.println(sb);
    }
}
",1,Plagiarised
3ff25f43,c287ea9d,"import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class EDU121C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        while(t-->0){
            int n = scan.nextInt();
            long[] k = new long[n];
            long[] h = new long[n];
            for(int i =0;i<n;i++){
                k[i] = scan.nextInt();
            }
            for(int i = 0;i<n;i++){
                h[i] = scan.nextInt();
            }
            long ans = 0;
            long lastD = 0;
            long lastHP = 0;
            for(int i = 0;i<n;i++){
                long dist = k[i]-lastD;
                long lo = h[i];
                long hi = lastHP+dist;
                long hpComingOut = 0;
                while(lo<=hi){
                    long mid = (lo+hi)/2;
                    boolean check = false;
                    for(int j = i+1;j<n;j++){
                        if(k[j]-k[i]<h[j]-mid){
                            check = true;
                            break;
                        }
                    }
                    if(check){
                        //we're in trouble
                        lo = mid+1;
                    }else{
                        hi = mid-1;
                        hpComingOut = mid;
                    }
                }
                if(hpComingOut>dist){
                    ans+=summ(dist+lastHP)-summ(lastHP);
                    lastHP+=dist;
                }else{
                    long diff = dist-hpComingOut;
                    ans+=summ(hpComingOut);
                    lastHP = hpComingOut;
                }
                lastD = k[i];
            }
            System.out.println(ans);
        }
    }
    static long summ(long a){
        return (a*(a+1))/2;
    }
    
}
","import java.util.*;
import java.io.*;

public class monstersandspells {
	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		/*
1
5
1 5 8 9 10
1 2 6 1 2
		 */
		int t = in.nextInt();
		
		for ( ; t > 0; t--) {
			
			int n = in.nextInt();
			
			long[] times = new long[n];
			long[] health = new long[n];
			for (int i = 0; i < n; i++)
				times[i] = in.nextLong();
			for (int i = 0; i < n; i++)
				health[i] = in.nextLong();
			
			long small = 0;
			long prev = 0;
			long lastDamage = 0;
			
			for (int i = 0; i < n; i++) {
				long diff = times[i] - prev;
				boolean use = true;
				long delta = 0;
				//System.out.println(i + "" "" + times[i] + "" "" + diff);
				if (diff >= health[i]) {
					delta += health[i];
					long curr = health[i];
					long lastTime = times[i];
					for (int j = i + 1; j < n; j++) {
						long increase = times[j] - lastTime;
						//long power = damageOverTime(increase + curr, curr + 1);
						if (curr + increase >= health[j]) {
							curr += increase;
							lastTime = times[j];
						}
						else {
							delta += (health[j] - (curr + increase));
							curr = health[j];
							lastTime = times[j];
						}
					}
					if (delta <= diff) {
						use = true;
					}
					else
						use = false;
				}
				else
					use = false;
				
				if (use) {
					//System.out.println(damageOverTime(health[i], 1));
					small += damageOverTime(delta, 1);
					lastDamage = delta;
				}
				else {
					small += damageOverTime((times[i] - prev) + lastDamage, lastDamage + 1);
					lastDamage+=(times[i] - prev);
				}
				// System.out.println(use + "" "" + delta + "" "" + lastDamage + "" "" + small);
				prev = times[i];
			}
			
			out.println(small);
		}
		
		out.close();
	}
	
	public static long damageOverTime(long endPower, long startPower) {
		return triangleSum(endPower) - triangleSum(startPower - 1);
	}
	
	public static long triangleSum(long a) {
		return a * (a + 1) / 2;
	}
	
	
}
",0,Non-plagiarised
a3ebea91,f80f6d8d,"import java.io.*;
import java.util.*;

public class DiscreteCentrifugalJumps {
  public static void solve(int n, int[] arr) {
    int[] dp = new int[n]; // dp array
    for (int i=1; i<n; i++) dp[i] = Integer.MAX_VALUE;
    int[] lg = new int[n]; // first greater element from the left
    int[] ll = new int[n]; // first smaller element from the left
    int[] rg = new int[n]; // first greater element from the right
    int[] rl = new int[n]; // first smaller element from the right

    List<List<Integer>> jumps = new ArrayList<>(); // for each index i, use a list to record which places it can jump to
    for (int i=0; i<n; i++) {
      jumps.add(new ArrayList<Integer>());
    }
    // preprocessing
    Stack<Pair<Integer, Integer>> stack = new Stack<>(); // each pair, first is height of skycraper, second is index in original array

    for (int i=0; i<n; i++) {
      while (!stack.isEmpty() && stack.peek().first < arr[i]) {
        stack.pop();
      }
      if (stack.isEmpty()) lg[i] = -1;
      else lg[i] = stack.peek().second; // ith building is first that is greater than s[-1].second building
      stack.add(new Pair<Integer, Integer>(arr[i], i));
    }
    stack.clear();

    for (int i=0; i<n; i++) {
      while (!stack.isEmpty() && stack.peek().first > arr[i]) {
        stack.pop();
      }
      if (stack.isEmpty()) ll[i] = -1;
      else ll[i] = stack.peek().second; 
      stack.add(new Pair<Integer, Integer>(arr[i], i));
    }
    stack.clear();

    for (int i=n-1; i>=0; i--) {
      while (!stack.isEmpty() && stack.peek().first > arr[i]) {
        stack.pop();
      }
      if (stack.isEmpty()) rg[i] = -1;
      else rg[i] = stack.peek().second; 
      stack.add(new Pair<Integer, Integer>(arr[i], i));
    }
    stack.clear();

    for (int i=n-1; i>=0; i--) {
      while (!stack.isEmpty() && stack.peek().first < arr[i]) {
        stack.pop();
      }
      if (stack.isEmpty()) rl[i] = -1;
      else rl[i] = stack.peek().second;
      stack.add(new Pair<Integer, Integer>(arr[i], i));
    }
    stack.clear();
    
    // we construct the jumps list
    for (int i = 0; i<n; i++) {
      if (lg[i] != -1) jumps.get(lg[i]).add(i);
      if (ll[i] != -1) jumps.get(ll[i]).add(i);
      if (rg[i] != -1) jumps.get(i).add(rg[i]);
      if (rl[i] != -1) jumps.get(i).add(rl[i]);
    }

    // dp
    for (int i=0; i<n; i++) {
      for (int j: jumps.get(i)) {
        dp[j] = Math.min(dp[j], dp[i] + 1);
      }
    }
    System.out.println(dp[n-1]);
  }
  public static void main(String[] args) throws IOException {
    try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))){
      int n = Integer.parseInt(br.readLine());
      String[] s = br.readLine().split("" "");
      int[] arr = new int[n];
      for (int i=0; i<n; i++) {
        arr[i] = Integer.parseInt(s[i]);
      }
      solve(n, arr);
    }
  }
}

class Pair<T1, T2> {
  public T1 first;
  public T2 second;
  public Pair(T1 first, T2 second) {
    this.first = first;
    this.second = second;
  }
}
","import static java.lang.Math.min;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class D_2 {
	public static void main(String[] args) throws Exception {
		new D_2().go();
	}

	int USE_FILE = 0;
	String INPUT = ""5\r\n"" +
			""1 3 1 4 5\r\n"" +
			"""";

	void solve(int caseNr) {
		int n = in.nextInt();
		int[] h = na(n);
		int[] dp = new int[n];

		for (int i = 0; i < n; i++) {
			dp[i] = inf;
		}
		dp[0] = 0;


		// vector<pair<int, int>> st;
		LinkedList<int[]> st = new LinkedList<>();

		// lge[maxn], lle[maxn], rge[maxn], rle[maxn];
		int[] lge = new int[n];
		int[] lle = new int[n];
		int[] rge = new int[n];
		int[] rle = new int[n];


		for (int i = 0; i < n; i++) { // the nearest greater from the left
			while (!st.isEmpty() && st.getLast()[0] < h[i]) {
				st.removeLast();
			}
			if (st.isEmpty()) {
				lge[i] = -1;
			} else {
				lge[i] = st.getLast()[1];
			}
			st.add(new int[]{h[i], i});
		}

		st.clear();
		for (int i = 0; i < n; i++) { // the nearest less from the left
			while (!st.isEmpty() && st.getLast()[0] > h[i]) {
				st.removeLast();
			}
			if (st.isEmpty()) {
				lle[i] = -1;
			} else {
				lle[i] = st.getLast()[1];
			}
			st.add(new int[]{h[i], i});
		}

		st.clear();
		for (int i = n - 1; i >= 0; i--) { // the nearest greater from the right
			while (!st.isEmpty() && st.getLast()[0] < h[i]) {
				st.removeLast();
			}
			if (st.isEmpty()) {
				rge[i] = -1;
			} else {
				rge[i] = st.getLast()[1];
			}
			st.add(new int[]{h[i], i});
		}

		st.clear();
		for (int i = n - 1; i >= 0; i--) { // the nearest less from the right
			while (!st.isEmpty() && st.getLast()[0] > h[i]) {
				st.removeLast();
			}
			if (st.isEmpty()) {
				rle[i] = -1;
			} else {
				rle[i] = st.getLast()[1];
			}
			st.add(new int[]{h[i], i});
		}


		List<List<Integer>> jumps = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			jumps.add(new ArrayList<>());
		}

		for (int i = 0; i < n; i++) {
			if (rle[i] != -1) jumps.get(i).add(rle[i]);
			if (rge[i] != -1) jumps.get(i).add(rge[i]);
			if (lle[i] != -1) jumps.get(lle[i]).add(i);
			if (lge[i] != -1) jumps.get(lge[i]).add(i);
		}
		for (int i = 0; i < n; i++) {
			for (int to : jumps.get(i)) {
				dp[to] = min(dp[to], dp[i] + 1);
			}
		}


		// System.out.println(jumps);


		System.out.println(dp[n - 1]);


		return;
	} // end of solve2





	// ---------------------------------------------------------------------------------------------- //

	void testCases() {
		int t = 1;
		for (int i=1; i<=t; i++) {
			solve(i);
		}
		output_writer.flush();
	}




	// ---------------------------------------------------------------------------------------------- //

	private int[] na(int n) {
		int[] a = new int[n];
		for (int i=0; i<n; i++) {
			a[i] = in.nextInt();
		}
		return a;
	}

	private int inf = Integer.MAX_VALUE;




	// ---------------------------------------------------------------------------------------------- //
	// ---------------------------------------------------------------------------------------------- //

	static boolean LOCAL = java.lang.System.getProperty(""ONLINE_JUDGE"") == null;
	Scanner in;
	PrintWriter output_writer = new PrintWriter(java.lang.System.out);

	// the output musn't flush automatic or we time out
	static class System {
		static PrintWriter out = null;
	}

	void go() throws Exception {
		System.out = output_writer;

		if (LOCAL && USE_FILE == 0) {
			//  if not set expects input from terminal
			java.lang.System.setIn(new ByteArrayInputStream(INPUT.getBytes()));
			in = new Scanner(java.lang.System.in);
		}
		if (LOCAL && USE_FILE > 0) {
			String filename = String.format(""in/cf%d.txt"", USE_FILE);
			File inputFile = new File(filename);
			in = new Scanner(inputFile);
			output_writer.printf(""[%s]\n"", filename);
			output_writer.flush();
		}
		if (!LOCAL) {
			in = new Scanner(java.lang.System.in);
		}


		long startTime = java.lang.System.currentTimeMillis();
		testCases();
		if (LOCAL) {
			java.lang.System.out.printf(""[%dms]\n"", java.lang.System.currentTimeMillis()-startTime);
		}
		in.close();
	}
}
",1,Plagiarised
8f6421f3,bdfe8110,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
public class Main{  
    public static void main (String[] args){
        FastReader s = new FastReader();
        int t=1;t=s.ni();
        for(int test=1;test<=t;test++){
        int n=s.ni(),k=s.ni();
        int position[]=s.readArray(k),temp[]=s.readArray(k);
        int ans[]=new int[n];
        Arrays.fill(ans,Integer.MAX_VALUE/2);
        for(int i=0;i<k;i++){
            ans[position[i]-1]=temp[i];
        }
        for(int i=1;i<n;i++){
            ans[i]=Math.min(ans[i-1]+1,ans[i]);
        }
        for(int i=n-2;i>=0;i--){
            ans[i]=Math.min(ans[i],ans[i+1]+1);
        }
        for(int i=0;i<n;i++)
        System.out.print(ans[i]+"" "");
        System.out.println();
        }
    }
    
    
    
}
","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();
	}

	
	
	

	
}
",1,Plagiarised
42fe7dd0,9291ca83,"import java.util.*;
 public class Solution {
    static Scanner sc=new Scanner(System.in);
    public static void main(String args[]) {
      int t=sc.nextInt();
      outer:while(t-->0){
        int n=sc.nextInt();
        int[][] ct=new int[n][5];
        int[] len=new int[n];
        for (int i=0;i<n;i++) {
            String s=sc.next();
            len[i]=s.length();
            for(char c:s.toCharArray()){
                ct[i][c-'a']++;
            }
        }
        int mx=0;
        for (int i=0;i<5;i++) {
            int[] diff=new int[n];
            for (int j=0;j<n;j++) {
                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
            }
            Arrays.sort(diff);
            int sum=0,inc=0;
            for(int j=n-1;j>=0;j--){
                sum+=diff[j];
                if (sum>0) {
                    inc++;
                }else {
                    break;
                }
            }
            mx=Math.max(mx,inc);
        }
        System.out.println(mx);
        }
        
      }

    }
","import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Practice {
    static HashMap<String, Integer> map = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            int[][] occurances = new int[5][n];
            for(int i=0;i<n;i++){
                String s = sc.next();
                int[] count = new int[5];
                int len = s.length();
                for(int j=0;j<s.length();j++){
                    count[s.charAt(j)-'a']++;
                }
                for(int j=0;j<5;j++){
                    occurances[j][i] = count[j] - (len-count[j]);
                }
            }
            int ans = 0;
            for(int i=0;i<5;i++){
                Arrays.sort(occurances[i]);
                int tmpAns = 0; int tmpSum=0;
                for(int j=n-1;j>=0;j--){
                    tmpSum+=occurances[i][j];
                    if(tmpSum>0) tmpAns++;
                    else break;
                }
                ans = Math.max(ans, tmpAns);
            }
            System.out.println(ans);
        }
    }
}
",1,Plagiarised
ba468e1f,ff34fab2,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
","import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.*;
 
public class Div2 {
	
	

	 public static String solution(int [] arr, int n, String st) 
	 {
        ArrayList<Integer> red = new ArrayList<>();
        ArrayList<Integer> blue = new ArrayList<>();
        
        for(int i = 0; i<n; i++)
        {
        	if(st.charAt(i)=='R')
        		red.add(arr[i]);
        	else
        		blue.add(arr[i]);
        }
	    	
        Collections.sort(red);
        Collections.sort(blue);
        int cb = 1;
        
        for(int j = 0; j<blue.size(); j++)
        {
            if(blue.get(j)<cb)
            	return ""NO"";
            cb++;
        }
        
        int cr = n;
        for(int j = red.size()-1; j>=0; j--)
        {
            if(red.get(j)>cr)
            	return ""NO"";
            cr--;
        }
        
        return ""YES"";

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

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
	  
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	String st = s.next();
   
    	out.println(solution(arr,n, st));
    }
    
		     
    out.flush();
    out.close();
    
}
}
",0,Non-plagiarised
1480a727,a7d1ce58,"import java.util.*;
import java.io.*; 
  
public class Main {
	 
	static long mod = (long)(1e9+7); 
//	 static long mod = 998244353; 
//	 static Scanner sc = new Scanner(System.in); 
	static FastReader sc = new FastReader(); 
	static PrintWriter out = new PrintWriter(System.out);
	public static void main (String[] args) {
		int ttt = 1;
		ttt = sc.nextInt();
		z :for(int tc=1;tc<=ttt;tc++){
			int n = sc.nextInt();
			long d[] = new long[n];
			for(int i=0;i<n;i++) {
				d[i] = sc.nextLong();
			}
			long h[] = new long[n];
			for(int i=0;i<n;i++) {
				h[i] = sc.nextLong();
			}
			
			long req[] = new long[n];
			
			for(int i=n-1;i>0;i--) {
				long dif = d[i] - d[i-1];
				long nxt = 0;
				if(i+1<n) nxt = req[i+1];
				long cur = Math.max(nxt, h[i]);
				if(dif >= cur) {
					req[i] = 0;
				}
				else {
					req[i] = cur-dif;
				}
//				System.out.println(i+"" ""+req[i]);
			}
			
			long ans = 0, prev = 0;
			
			for(int i=0;i<n;i++) {
				if(i == 0) {
					ans = ans + sumFrom(0, h[i]);
					prev = h[i];
				}
				else {
					if(req[i] == 0) {
						ans = ans + sumFrom(0, h[i]);
						prev = h[i];
					}
					else {
						if(req[i]>prev) {
							ans = ans + sumFrom(prev, req[i]);
							ans = ans + sumFrom(req[i], req[i] + (d[i]-d[i-1]));
							prev = req[i] + d[i] - d[i-1];
						}
						else {
							ans = ans + sumFrom(prev, prev + (d[i]-d[i-1]));
							prev = prev + d[i] - d[i-1];
						}
					}
				}
			}
			
			out.write(ans+""\n"");
		}
		out.close();
	}
	private static long sumFrom(long l, long cur) {
		long is1 = (cur*(cur+1))/2;
		long is2 = (l*(l+1))/2;
		
		return is1 - is2;
	}
	
	 
	 
	 
	 
	 
}
","import java.util.*;
import java.io.*;
 
public class AiseHi {
	static Scanner sc = new Scanner(System.in);
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		z : while(t-->0) {
			int n = sc.nextInt();
			long dsasds[] = new long[n];
			for(int i=0;i<n;i++) {
				dsasds[i] = sc.nextLong();
			}
			long dsasdsuyuiyu[] = new long[n];
			for(int i=0;i<n;i++) {
				dsasdsuyuiyu[i] = sc.nextLong();
			}
			
			long dsasdsuyuiyubtrtr[] = new long[n];
			
			for(int i=n-1;i>0;i--) {
				long dif = dsasds[i] - dsasds[i-1];
				long nxt = 0;
				if(i+1<n) nxt = dsasdsuyuiyubtrtr[i+1];
				long cur = Math.max(nxt, dsasdsuyuiyu[i]);
				if(dif >= cur) {
					dsasdsuyuiyubtrtr[i] = 0;
				}
				else {
					dsasdsuyuiyubtrtr[i] = cur-dif;
				}
//				System.out.println(i+"" ""+dsasdsuyuiyubtrtr[i]);
			}
			
			long dsasdscsacsauyuiyubtrtr = 0, kokopmom = 0;
			
			for(int i=0;i<n;i++) {
				if(i == 0) {
					dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
					kokopmom = dsasdsuyuiyu[i];
				}
				else {
					if(dsasdsuyuiyubtrtr[i] == 0) {
						dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(0, dsasdsuyuiyu[i]);
						kokopmom = dsasdsuyuiyu[i];
					}
					else {
						if(dsasdsuyuiyubtrtr[i]>kokopmom) {
							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, dsasdsuyuiyubtrtr[i]);
							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(dsasdsuyuiyubtrtr[i], dsasdsuyuiyubtrtr[i] + (dsasds[i]-dsasds[i-1]));
							kokopmom = dsasdsuyuiyubtrtr[i] + dsasds[i] - dsasds[i-1];
						}
						else {
							dsasdscsacsauyuiyubtrtr = dsasdscsacsauyuiyubtrtr + sumFrom(kokopmom, kokopmom + (dsasds[i]-dsasds[i-1]));
							kokopmom = kokopmom + dsasds[i] - dsasds[i-1];
						}
					}
				}
			}
			
			System.out.println(dsasdscsacsauyuiyubtrtr);
		}
	}

	private static long sumFrom(long l, long cur) {
		long is1 = (cur*(cur+1))/2;
		long is2 = (l*(l+1))/2;
		
		return is1 - is2;
	}

	
	
	
	
	
	
	
	
	 
	
	
	
	
  
    
//	private static boolean check(long n,long val) {
//		if(n == 0) return true;
//		
//		while(val<=n) {
////			if(check(n-val,))
//		}
//	}
	
	
	
	
//	static int ceil(int a,int b) {
//		return a/b + (a%b==0?0:1);
//	}
//	static int fac[] = new int[2000009];
	
	
//	static long gcd(long a,long b) { if(b==0) return a; return gcd(b,a%b); }
}
 



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

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

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

			Pair[] p= new Pair[n];

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

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

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

				}
				
			}




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

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

}

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

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

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

    // @Override
    // public int hashCode(){
    // 	return Objects.hash(x , y);
    // }
  	
    
}
","import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;


public class MonstersAndSpells {

    

    public static void main(String[] args) throws IOException {
        FastReader input = new FastReader();
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        int t = input.nextInt();
        while (t-- > 0) {
            int n = input.nextInt();
            long k[] = new long[n];
            long h[] = new long[n];
            long ans = 0;
            for (int i = 0; i < n; i++) {
                k[i] = input.nextInt();
            }
            for (int i = 0; i < n; i++) {
                h[i] = input.nextInt();
            }
            for (int i = n-1; i >0; i--) {
                long d = k[i]-k[i-1];
                if(h[i-1]+d<h[i]){
                    h[i-1]+=(h[i]-(h[i-1]+d));
                }
            }
            ans += (h[0]) * (h[0] + 1) / 2;
            long last = h[0];
            for (int i = 1; i < n; i++) {
                if (k[i] - k[i - 1] >= h[i]) {
                    ans += (h[i]) * (h[i] + 1) / 2;
                    last = h[i];
                } else {
                    long x = (k[i] - k[i - 1]);
                    long y = last + x;
                    long sum1 = (last) * (last + 1) / 2;
                    long sum2 = (y) * (y + 1) / 2;
                    ans += (sum2 - sum1);
                    last = y;
                }
            }
            log.write(ans + ""\n"");
        }
        log.flush();
    }

}
",0,Non-plagiarised
565f77b7,856a8eda,"import java.util.*;
import java.io.*;

public class Solution {

	static Scanner scn = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static StringBuilder sb = new StringBuilder();

	public static void main(String[] HastaLaVistaLa) {
		int t = scn.nextInt();
		while(t-- > 0) solve();
		out.println(sb);
		out.close();
	}

	public static void solve() {
		// Road To Specialist Day 3
		int n = scn.nextInt(), m = scn.nextInt(), x = scn.nextInt();
		int[] a = new int[n], ans = new int[n];
		for(int i = 0; i < n; i++) a[i] = scn.nextInt();
		PriorityQueue<Pair> pq = new PriorityQueue<>();
		for(int i = 0; i < m; i++) pq.add(new Pair(0L, i));
		for(int i = 0; i < n; i++) {
			int e = a[i];
			Pair p = pq.poll();
			p.value += e;
			pq.add(p);
			ans[i] = p.id + 1;
		}
		boolean check = false;
		long prev = pq.poll().value;
		while(!pq.isEmpty()) {
			long cur = pq.poll().value;
			if(Math.abs(cur - prev) > x) check = true;
			prev = cur;
		}
		if(check) sb.append(""NO"");
		else {
			sb.append(""YES\n"");
			for(int i : ans) sb.append(i + "" "");
		}
		sb.append(""\n"");
	}
	static class Pair implements Comparable<Pair> {
		int id;
		long value;
		public Pair(long value, int id) {
			this.id = id;
			this.value = value;
		}
		
	}
}
","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 + ""]"";
    //     }
    // }
    //--------------------------------------------------------
}
",0,Non-plagiarised
a0b406e6,c9b4bb51,"import java.io.*;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();
		int tcCnt = in.nextInt();
		for (int tc = 1; tc <= tcCnt; tc++)
			solver.solve(tc, in, out);
		out.close();
	}

	static class Task {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i = 0; i < n; i++) {
				a[i] = in.nextInt();
			}
			for (int mask = 1; mask < (int)(Math.pow(3, n)); mask++) {
				int copy = mask;
				int sum = 0;
				for (int idx = 0; idx < n; idx++) {
					int digit = copy % 3;
					sum += digit == 0 ? 0 : digit == 1 ? a[idx] : -a[idx];
					copy = copy / 3;
				}
				if (sum == 0) {
					out.println(""YES"");
					return;
				}
			}
			out.println(""NO"");
		}

	}

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

public class Main {
    static void deal(int n,int[] arr) {
        HashSet<Integer> hs = new HashSet<>();
        int max = (int)Math.pow(3,n);
        int[] sum = new int[max];
        hs.add(0);
        for(int i=1;i<max;i++) {
            int s = 0;
            int num = i;
            int index = 0;
            while(num>0) {
                int d = num % 3;
                num = num /3;
                if(d==1) {
                    s+=arr[index];
                } else if(d==2) {
                    s-=arr[index];
                }
                index++;
            }
            sum[i] = s;
            if(s==0) {
                out.println(""YES"");
                return;
            }
            hs.add(sum[i]);
        }
        out.println(""NO"");
    }

    

	public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        for(int i=0;i<t;i++) {
            int n = sc.nextInt();
            int[] arr = new int[n];
            for(int j=0;j<n;j++) {
                arr[j] = sc.nextInt();
            }
            deal(n,arr);
        }
        out.close();
    }
    
    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;
    
    //-----------MyScanner class for faster input----------
    
}
",0,Non-plagiarised
317a209c,3e6def38,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
",1,Plagiarised
aa8091b0,ac180326,"import java.util.*;
 
import java.io.*;
 
public class AiseHi {
	static Scanner sc = new Scanner(System.in);
	static int mod = (int)(1e9+7);
	public static void main (String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		int t = 1;
    	t = sc.nextInt();
    	z : while(t-->0) {
    		int n = sc.nextInt();
    		int m = sc.nextInt();
    		int x = sc.nextInt();
    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
    		for(int i=1;i<=m;i++) {
    			myQueue.add(new twoval(0,i));
    		}
    		List<twoval> arrayList = new ArrayList<>();
    		int myArray[] = new int[n];
    		for(int i=0;i<n;i++) {
    			int aasjd = sc.nextInt();
    			arrayList.add(new twoval(aasjd,i));
    			myArray[i] = aasjd;
    		}
    		Collections.sort(arrayList);
    		int ans[] = new int[n];
    		for(int i=n-1;i>=0;i--) {
    			twoval p = myQueue.poll();
    			long aasjd = p.myArray;
    			int idx = p.b;
    			aasjd += arrayList.get(i).myArray;
    			ans[arrayList.get(i).b] = idx;
    			myQueue.add(new twoval(aasjd,idx));
    		}
    		long dasdaknw[] = new long[m];
    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
    		for(int i=0;i<n;i++) {
    			dasdaknw[ans[i]-1] += myArray[i];
    		}
    		for(int i=0;i<m;i++) {
    			min = Math.min(min, dasdaknw[ans[i]-1]);
    			max = Math.max(max, dasdaknw[ans[i]-1]);
    		}
    		if(max-min>x) {
    			out.write(""NO\n"");
    			continue;
    		}
    		out.write(""YES\n"");
    		for(int aasjd : ans) out.write(aasjd+"" "");
    		out.write(""\n"");
    	}
		out.close();
	}
	
	static boolean prime[] = new boolean[2000009];
	static int fac[] = new int[2000009];
	
	
	
}
 
class twoval implements Comparable<twoval>{
	long myArray;
	int b;
	twoval(long aasjd,int r){
		this.myArray = aasjd;
		this.b = r;
	}
	
}
","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
0c1143f7,960a4c0f,"import java.io.*;
import java.util.*;

public class E {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			FastScanner sc = new FastScanner();
			
			int t = sc.nextInt();
			
			while(t-- > 0) {
				
				int n = sc.nextInt();
				int[] a = new int[n];
				
				for(int i = 0 ; i< n ; i++) {
					a[i] = sc.nextInt();
				}
				long oddMin = a[1];
				long evenMin = a[0];
				long res = (n * oddMin) + (n * evenMin);
				long oddSum = a[1];
				long evenSum = a[0];
				
				for(int i = 2 ;i < n ; i++) {
					
					if(i % 2 == 1) {
						oddSum += a[i];
						oddMin = Math.min(oddMin, a[i]);
					}
					else {
						evenSum += a[i];
						evenMin = Math.min(evenMin, a[i]);
					}
					
					int odd = (i + 1) / 2;
					int even = (i / 2) + 1;
					
					long minCostOdd = oddSum + oddMin*(n - odd);
					long minCostEven = evenSum + evenMin*(n - even);
					
					res = Math.min(res, minCostOdd + minCostEven);
				}
				
				System.out.println(res);
			}
			
			
			
			

	}
	
	
	
	// Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
		// worst case since it uses a version of quicksort. Although this would never
		// actually show up in the real world, in codeforces, people can hack, so
		// this is needed.
		

}
","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
10bbe9de,489930000000,"import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        SolveQue solveQue = new SolveQue();
        solveQue.ques();
    }
}

class SolveQue {
    
    private static final FastScanner fs = new FastScanner();
    private static final Scanner sc = new Scanner(System.in);
    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static final long MOD = (long) (1e9 + 7);
    private static PrintWriter out = new PrintWriter(System.out);
    private static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
    private static final int iInf = Integer.MAX_VALUE - (int) (1e6);
    private static final long lInf = (long)(1e17);
    private static int[] phi;

    /** Optimal(Maximum,Minimum) Answers
     * 1. Binary search
     * 2. Prefix Suffix
     * 3. Greedy (sorting searching)
     * 4. DP
     **/
    long[] getP(long[] arr,int n) {
        long mn = lInf;
        long[] P = new long[n];
        Arrays.fill(P,lInf);
        long cnt = 0;
        for(int i = 0 ; i < n; i++){
            long curr = arr[i];
            if(mn + cnt < curr){
                P[i] = mn + cnt;
            } else {
                mn = arr[i];
                P[i] = arr[i];
                cnt  = 0;
            }
            cnt++;
        }
        return  P;
    }
    long[] getS(long[] arr,int n) {
        long mn = lInf;
        long[] S = new long[n];
        Arrays.fill(S,lInf);
        long cnt = 0;
        for(int i = n - 1; i >= 0; i--){
            long curr = arr[i];
            if(mn + cnt < curr){
                S[i] = mn + cnt;
            }else{
                mn = arr[i];
                S[i] = arr[i];
                cnt  = 0;
            }
            cnt++;
        }
        return  S;
    }
    void solve(int T) throws IOException {
        int n = fs.nextInt();
        int k = fs.nextInt();
        int[] a = new int[k];
        long[] t = new long[k];
        long[] arr = new long[n];
        Arrays.fill(arr,lInf);
        for (int i = 0; i < k; i++) {
            a[i] = fs.nextInt();
            a[i]--;
        }
        for (int i = 0; i < k; i++) {
            t[i] = fs.nextLong();
            arr[a[i]] = t[i];
        }
//        Arrays.fill(arr,lInf);
        long[] P = getP(arr, n);
//        Arrays.fill(arr,lInf);
        long[] S = getS(arr, n);
        for(int i = 0 ; i < n ; i++){
            System.out.print(Math.min(P[i],S[i]) + "" "");
        }
        System.out.println();
    }
    void ques() throws IOException {
        int t = 1;
//        t = sc.nextInt();
        t = fs.nextInt();
//        t = Integer.parseInt(br.readLine());
        int tt = 1;
        while (t-- > 0) {
            solve(tt);
            tt++;
        }
        System.gc();
    }
}
","import java.io.*;
import java.util.*;

public class Codeforce {

    

    static 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);
    }
}
",0,Non-plagiarised
161b4a40,da5cf40b,"import java.util.*;
import java.io.*;

public class Main{
    static final Random random=new Random();
    static long mod=1000000007L;
    static HashMap<String,Integer>map=new HashMap<>();

    
    
    public static void main(String[] args) {
        try {
            FastReader in=new FastReader();
            FastWriter out = new FastWriter();
            int testCases=in.nextInt();
            //int testCases=1;
            while(testCases-- > 0){
                solve(in);
            }
            out.close();
        } catch (Exception e) {
            return;
        }
    }
    public static void solve( FastReader in){
        int n=in.nextInt();
        String s=in.next();
        String t=in.next();
        //int k=in.nextInt();
        //long y=in.nextInt();
        //long n=in.nextLong();
        //int k=in.nextInt();
        //long k=in.nextLong();
        StringBuilder res=new StringBuilder();
        char[] s1=s.toCharArray();
        char[] t1=t.toCharArray();
        int ans=n+2;
        int[] cnt={0,0};
        for(int i=0;i<n;i++){
            if(s1[i]=='0' && t1[i]=='1'){
                cnt[0]++;
            }
            if(s1[i]=='1' && t1[i]=='0'){
                cnt[1]++;
            }
        }
        if(cnt[0]==cnt[1])ans=Math.min(ans,cnt[0]+cnt[1]);
        cnt[0]=cnt[1]=0;
        for(int i=0;i<n;i++){
            if(s1[i]=='0' && t1[i]=='0'){
                cnt[0]++;
            }
            if(s1[i]=='1' && t1[i]=='1'){
                cnt[1]++;
            }
        }
        if(cnt[1]==cnt[0]+1){
            ans=Math.min(ans,cnt[0]+cnt[1]);
        }
        if(ans>n){
            res.append(""-1"");
        }
        else{
            res.append(""""+ans);
        }
        //int ans=x.size()+y.size();
        //res.append(""""+""Yes"");
        //res.append(""""+"""");
        System.out.println(res.toString());
    }
    
    

    
    

    

    
    static < E > void print(E res)
    {
        System.out.println(res);
    }
    
}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    /* start */
   
       public static void main(String [] args)
    {
        // int testcases = 1;
        int testcases = i();
        while(testcases-->0)
        {
            
            solve();
        }
        out.flush();
        out.close();
    }
    static void solve()
    { 
        int n = i();
        char c[] = inputC();
        char d[] = inputC();
        int x01=0,x10=0,x00=0,x11=0;
        for(int i=0;i<n;i++)
        {
            if(c[i]=='0'&&d[i]=='0')x00++;
            if(c[i]=='0'&&d[i]=='1')x01++;
            if(c[i]=='1'&&d[i]=='0')x10++;
            if(c[i]=='1'&&d[i]=='1')x11++;
        }

        int ans = Integer.MAX_VALUE;
        if(x01==0 && x10==0)
        {
            System.out.println(0);
            return ;
        }
        if(x11==x00+1)
        {
            ans = Math.min(x11+x00,ans);
        }
      if(x01==x10)
        {
            ans = Math.min(x01+x10,ans);
        }
        if(ans == Integer.MAX_VALUE){
            ans = -1;
        }
        System.out.println(ans);
    }
    
    /* end */
     

    static int i() {
        return sc.nextInt();
    }


    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    

    

    

    
      
     

      

     
    
     

    
    

    

    

    

    

    

    

     

      

        
    
        
        //pair class
        
}
",0,Non-plagiarised
0b27be88,3f4a5b64,"import java.util.*;
import java.io.*;
public class C {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int integer=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n))
            {
                if(n>='0'&&n<='9')
                {
                    integer*=10;
                    integer+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        
        
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    
    
    
    
    
    
    
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        StringBuilder ans=new StringBuilder("""");
        int test=input.scanInt();
        for(int tt=1;tt<=test;tt++) {
            int n=input.scanInt();
            int m=input.scanInt();
            int x=input.scanInt();
            ans.append(""YES\n"");
            TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
            for(int i=1;i<=m;i++) {
                ans.append(i+"" "");
                int tmp=input.scanInt();
                if(!tm.containsKey(tmp)) {
                    Stack<Integer> stck=new Stack<>();
                    stck.add(i);
                    tm.put(tmp, stck);
                }
                else {
                    Stack<Integer> stck=tm.get(tmp);
                    stck.add(i);
                }
            }
            for(int i=m;i<n;i++) {
                int tmp=input.scanInt();
                int min=tm.firstKey();
                Stack<Integer> stck=tm.get(min);
                int indx=stck.pop();
                ans.append(indx+"" "");
                if(stck.isEmpty()) {
                    tm.remove(min);
                }
                tmp+=min;
                
                if(!tm.containsKey(tmp)) {
                    stck=new Stack<>();
                    stck.add(indx);
                    tm.put(tmp, stck);
                }
                else {
                    stck=tm.get(tmp);
                    stck.add(indx);
                }
            }
            ans.append(""\n"");
        }
        System.out.println(ans);
    }
}
","import java.util.*;
import java.io.*;
public class C {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int integer=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n))
            {
                if(n>='0'&&n<='9')
                {
                    integer*=10;
                    integer+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        
        
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    
    
    
    
    
    
    
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        StringBuilder ans=new StringBuilder("""");
        int test=input.scanInt();
        for(int tt=1;tt<=test;tt++) {
            int n=input.scanInt();
            int m=input.scanInt();
            int x=input.scanInt();
            ans.append(""YES\n"");
            TreeMap<Integer,Stack<Integer>> tm=new TreeMap<>();
            for(int i=1;i<=m;i++) {
                ans.append(i+"" "");
                int tmp=input.scanInt();
                if(!tm.containsKey(tmp)) {
                    Stack<Integer> stck=new Stack<>();
                    stck.add(i);
                    tm.put(tmp, stck);
                }
                else {
                    Stack<Integer> stck=tm.get(tmp);
                    stck.add(i);
                }
            }
            for(int i=m;i<n;i++) {
                int tmp=input.scanInt();
                int min=tm.firstKey();
                Stack<Integer> stck=tm.get(min);
                int indx=stck.pop();
                ans.append(indx+"" "");
                if(stck.isEmpty()) {
                    tm.remove(min);
                }
                tmp+=min;
                
                if(!tm.containsKey(tmp)) {
                    stck=new Stack<>();
                    stck.add(indx);
                    tm.put(tmp, stck);
                }
                else {
                    stck=tm.get(tmp);
                    stck.add(indx);
                }
            }
            ans.append(""\n"");
        }
        System.out.println(ans);
    }
}
",1,Plagiarised
a4e39423,ba8800f5,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class _109D {
    static BufferedReader br;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        int n = readInt();
        int arr[] = readIntarray();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i = 0; i < n; i++){
            if(arr[i] == 1){
                a.add(i);
            }else{
                b.add(i);
            }
        }
        if(a.size() == 0){
            System.out.println(""0"");
            return;
        }
        int [][] dp = new int[a.size()][b.size()];
        for(int i = 0; i < a.size(); i++){
            for(int j = i; j < b.size(); j++) {
                if (j == 0) {
                    dp[i][j] = Math.abs(a.get(i) - b.get(j));
                } else if (i == 0) {
                    dp[i][j] = Math.min(dp[i][j - 1], Math.abs(a.get(i) - b.get(j)));
                } else if (i == j) {
                    dp[i][j] = dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j));
                } else {
                    dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(a.get(i) - b.get(j)));
                }
            }
        }
        System.out.println(dp[a.size() - 1][b.size() - 1]);
    }


    static int readInt() throws IOException {
        return Integer.parseInt(br.readLine());
    }

    

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

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

public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        int ar[] = new int[n];
        for(int i = 0; i < n; i++){
            ar[i] = Integer.parseInt(st.nextToken());
        }
        ArrayList<Integer> ones = new ArrayList<Integer>();
        ArrayList<Integer> zeroes = new ArrayList<Integer>();
        for(int i = 0; i < n; i++){
            if(ar[i] == 1)
                ones.add(i);
            else
                zeroes.add(i);
        }
        int r = ones.size();
        int c = zeroes.size();
        int time[][] = new int[r][c];
        System.out.println(calculateTime(time, r, c, 0, 0, ones, zeroes));
    }
    public static int calculateTime(int time[][], int r, int c, int currR, int currC, ArrayList<Integer> ones, ArrayList<Integer> zeroes){
        // System.out.println(currR + "" "" + currC);
        if(currR == r)
            return 0;
        if(currC == c)
            return (int)1e9;
        if(time[currR][currC] != 0)
            return time[currR][currC];
        return time[currR][currC] = Math.min((calculateTime(time, r, c, currR + 1, currC + 1, ones, zeroes) + Math.abs(ones.get(currR) - zeroes.get(currC))), calculateTime(time, r, c, currR, currC + 1, ones, zeroes));
    }
}
",0,Non-plagiarised
3e6def38,548ffb07,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	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
53551ea0,6be98ece,"import java.util.*;
public class MyClass {
    public static void main(String args[]) {
      Scanner sc=new Scanner(System.in);
      int tc=sc.nextInt();
      while(tc>0)
      {
          int n=sc.nextInt();
          int arr[]=new int[n];
          int i,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE;
          for(i=0;i<n;i++)
          {
              arr[i]=sc.nextInt();
              if(arr[i]>max)
              max=arr[i];
              if(arr[i]<min)
              min=arr[i];
          }
          int low=min,high=max,mid,ans=min;
          while(low<=high)
          {
              mid=(low+high)/2;
              int temp[]=new int[n];
              for(i=0;i<n;i++)
              temp[i]=arr[i];
              boolean flag=true;
              for(i=n-1;i>=2;--i)
              {
                  if(temp[i]<mid)
                  {
                  flag=false;
                  break;
                  }
                  int deli=Math.min(temp[i]-mid,arr[i]);
                  int ex=deli/3;
                  temp[i]=temp[i]-(3*ex);
                  temp[i-1]=temp[i-1]+(ex);
                   temp[i-2]=temp[i-2]+(2*ex);
                   
              }
              
              if(temp[0]<mid || temp[1]<mid)
              flag=false;
              
              if(flag==true)
              {
              ans=mid;
              low=mid+1;
              }
              else
              high=mid-1;
          }
          System.out.println(ans);
          --tc;
      }}}
","import java.util.*;

public class CF763C {
	private static final int MAX = 1000000001;
	private static final int MIN = 0;

	public static final void main(String ...args) {
		Scanner sc = new Scanner(System.in);

		int t = sc.nextInt();

		while (t-- > 0) {
			int n = sc.nextInt();
			int[] h = new int[n];
			int i, b = MAX, e = MIN;
			for (i = 0; i < n; i++) {
				h[i] = sc.nextInt();
				if (b > h[i])
					b = h[i];
				if (e < h[i])
					e = h[i];
			}

			int[] s = new int[n];
			int c, d, ans = b;

			// System.out.println(b + "" "" + e);

			while (b <= e) {
				c = (b + e) / 2;
				// System.out.println(c);
				// sc.next();
				for (i = 0; i < n; i++) {
					s[i] = 0;
				}

				for (i = n - 1; i >= 2; i--) {
					if (h[i] + s[i] < c) {
						e = c - 1;
						break;
					} else {
						d = Math.min(h[i], h[i] + s[i] - c) / 3;
						s[i - 1] += d;
						s[i - 2] += 2 * d;
					}
				}
				// System.out.println(i);
				if (i == 1) {
					if (h[i] + s[i] < c || h[i - 1] + s[i - 1] < c) {
						e = c - 1;
					} else {
						ans = c;
						b = c + 1;	
					}
				}
			}
			System.out.println(ans);
		}
	}
}
",0,Non-plagiarised
8639f6c6,e18ae6a1,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

/**
 * Created by dhruvthakker on 01/10/21 at 9:42 am
 */
public class Season2 {
    static InputReader in = new InputReader();
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String args[]) {
        int t = in.nextInt();
        while (t-- > 0) {
            int n = in.nextInt();
            int air = in.nextInt();
            Map<Integer, Integer> tempByIndex = new HashMap<>();
            int inx[] = new int[air];
            for (int i = 0; i < air; i++) {
                int x = in.nextInt() - 1;
                tempByIndex.put(x, 0);
                inx[i] = x;
            }
            for (int i = 0; i < air; i++) {
                tempByIndex.put(inx[i], in.nextInt());
            }

            long leftMax[] = new long[n];
            long rightMax[] = new long[n];

            leftMax[0] = tempByIndex.getOrDefault(0, Integer.MAX_VALUE);
            rightMax[n - 1] = tempByIndex.getOrDefault(n - 1, Integer.MAX_VALUE);
            for (int i = 1; i < n; i++) {
                leftMax[i] = Math.min(leftMax[i - 1] + 1, tempByIndex.getOrDefault(i, Integer.MAX_VALUE));
                rightMax[n - 1 - i] = Math.min(rightMax[n - i] + 1, tempByIndex.getOrDefault(n - 1 - i, Integer.MAX_VALUE));
            }
            for (int i = 0; i < n; i++) {
                long ans = Math.min(leftMax[i], rightMax[i]);
                out.print(ans + "" "");
            }
            out.println();
        }
        out.flush();
    }

    

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

public class Main
{
 
    public static void main(String[] args)
    {
      FastScanner input = new FastScanner();
        int tc = input.nextInt();
        while (tc-- > 0) {
         int n = input.nextInt();
      int k = input.nextInt();
      int a[] = new int[n+1];
      int b[] = new int[k+1];
        for (int i = 1; i <=k; i++) {
            b[i] = input.nextInt();
            
        }
        Arrays.fill(a, Integer.MAX_VALUE);
        for (int i = 1; i <=k; i++) {
           int value = input.nextInt();
           a[b[i]] = value;
            
        }
//        System.out.println(Arrays.toString(a));
        long L[] = new long[n+1];
        long R[] = new long[n+1];
        Arrays.fill(L, Integer.MAX_VALUE);
        Arrays.fill(R, Integer.MAX_VALUE);
        long p = Integer.MAX_VALUE;
        for (int i = 1; i <=n; i++) {
             p = Math.min(p+1, a[i]);
             L[i] = p;
        }
        p = Integer.MAX_VALUE;
        for (int i = n; i >=1; i--) {
            p = Math.min(p+1,a[i] );
            R[i] = p;
        }
//        System.out.println(Arrays.toString(L));
//        System.out.println(Arrays.toString(R));
        long ans[] = new long[n+1];
        for (int i = 1; i <=n; i++) {
            ans[i] = Math.min(L[i], R[i]);
        }
        StringBuilder result = new StringBuilder();
        for (int i = 1; i <=n; i++) {
         result.append(ans[i]+"" "");
        }
        System.out.println(result);   
        }
      
    }

    

    

}
",0,Non-plagiarised
2722ef48,e9144440,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class CNotAssigning {
        int N = 100010;
        int M = N * 2;
        int[] h;
        int[] e = new int[M];
        int[] ne = new int[M];
        int idx;
        int n;
        int[] dep;
        int[] res;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            n = in.nextInt();
            h = new int[n + 1];
            dep = new int[n + 1];
            res = new int[n - 1];
            Arrays.fill(h, -1);
            idx = 0;
            for (int i = 0; i < n - 1; i++) {
                int a = in.nextInt();
                int b = in.nextInt();
                add(a, b);
                add(b, a);
                dep[a]++;
                dep[b]++;
            }
            int start = 0;
            for (int i = 1; i <= n; i++) {
                if (dep[i] > 2) {
                    out.println(-1);
                    return;
                }
                if (dep[i] == 1) {
                    start = i;
                }
            }
            dfs(start, start, 2);
            out.println(res);
        }

        private void dfs(int u, int p, int num) {
            for (int i = h[u]; i != -1; i = ne[i]) {
                int j = e[i];
                if (j == p) {
                    continue;
                }
                res[i / 2] = num;
                dfs(j, u, 7 - num);
            }
        }

        void add(int a, int b) {
            e[idx] = b;
            ne[idx] = h[a];
            h[a] = idx++;
        }

    }

    

    
}
","import java.util.Scanner;

public class C
{
	static int N = 100010;
	static int[] cot = new int[N];
	static boolean[] vis = new boolean[N];

	static int[] h = new int[N];
	static int[] des = new int[2 * N], next = new int[2 * N];
	static int idx = 0;

	static int[] ans = new int[N];

	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		int round = in.nextInt();
		for (int z = 0; z < round; z++)
		{
			int n = in.nextInt();
			for (int i = 1; i <= n; i++)
			{
				h[i] = -1;
				vis[i] = false;
				cot[i] = 0;
			}
			idx = 0;

			boolean flag = true;
			for (int i = 1; i < n; i++)
			{
				int a = in.nextInt();
				int b = in.nextInt();

				des[idx] = b;
				next[idx] = h[a];
				h[a] = idx++;

				des[idx] = a;
				next[idx] = h[b];
				h[b] = idx++;

				if (++cot[a] >= 3 | ++cot[b] >= 3)
					flag = false;
			}

			if (!flag)
				System.out.println(-1);
			else
			{
				int startPoint = -1;
				for (int i = 1; i <= n; i++)
					if (cot[i] == 1)
					{
						startPoint = i;
						break;
					}
				dfs(startPoint, 3);
				for (int i = 1; i < n; i++)
					System.out.print(ans[i] + "" "");
				System.out.println();
			}
		}
	}

	private static void dfs(int point, int preLen)
	{
		vis[point] = true;
		for (int i = h[point]; i != -1; i = next[i])
			if (!vis[des[i]])
			{
				ans[i / 2 + 1] = 5 - preLen;
				// System.out.println(point + "">"" + des[i] + "" "" + ans[i / 2 + 1] + "" "" + (i / 2
				// + 1));
				dfs(des[i], ans[i / 2 + 1]);
			}
	}
}
",0,Non-plagiarised
5e3089fa,aea245ba,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

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

                    }
                }
                System.out.println(minSteps);
            }
            t--;
        }
    }
}
","import java.awt.image.AreaAveragingScaleFilter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class CF1 {
    public static void main(String[] args) {
        FastScanner sc=new FastScanner();
        int T=sc.nextInt();
//        int T=1;
        for (int tt=0; tt<T; tt++){
            int n = sc.nextInt();
            long k = sc.nextLong();
            int arr[]= sc.readArray(n);
            sort(arr);
            long sum=0L;
            long ans=Integer.MAX_VALUE;
            long min= (long)arr[0];


            for (int i=0; i<n; i++){
                sum+=arr[i];
            }
            if (sum<=k) System.out.println(0);
            else {
                long temp=sum;
                long x=0L;
                long y=0L;
                for (int i=n-1; i>=1; i--){
                    temp=sum;
                    //2x +arr[i]-min
                    y++;
                    x+=arr[i];
                    temp-=x-y*min;
                    if (temp<=k) {
                        ans=Math.min(ans,y);
                        break;
                    }
                    else {
                        long b=(temp-k);
                        if (b%(y+1)==0){
                            b/=(y+1);
                        }
                        else {
                            b/=(y+1);
                            b++;
                        }
                        ans=Math.min(ans, y+b);
                    }



                }
                if (n==1){
                    ans=arr[0]-k;
                }
                ans= Math.min(ans, sum-k);
                System.out.println(ans);
            }




        }
    }
    static long mod =998244353L;
    

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

    
    
}
",0,Non-plagiarised
0017d438,ac180326,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

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

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

    

    

    

    

    

    

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

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
","import java.util.*;



import java.io.*;

public class code  {
	// remember long, to reformat ctrl + shift +f
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
 
	  
 
	public static void main(String[] args) throws Exception {

		int t=sc.nextInt();
		while(t-->0) {
            int n=sc.nextInt();
            int []vals=new int[n];
            boolean numLine[]=new boolean[n+1];

            for(int i=0;i<n;i++)vals[i]=sc.nextInt();
            String s=sc.nextLine();
            ArrayList<Integer>b=new ArrayList<Integer>();
            ArrayList<Integer>r=new ArrayList<Integer>();
            for(int i=0;i<n;i++) {
            	if(s.charAt(i)=='B' && vals[i]>0 )b.add(vals[i]);
            	else if( s.charAt(i)=='R' && vals[i]<=n)r.add(vals[i]);
            }
          Collections.sort(b);
          Collections.sort(r);
          int small=1;
          for(int i=0;i<b.size();i++) {
        	  
        	  int y=b.get(i);
        	  if(y<small)continue;
        	  numLine[small]=true;
        	  small++;
          }
         // pw.println(Arrays.toString(numLine));
          int large=n;
          for(int i=r.size()-1;i>=0;i--) {
        	  
        	  int y=r.get(i);
        	  if(y>large)continue;
        	 // y=Math.max(large, y);
        	  numLine[large]=true;
        	  large--;
          }
          //pw.print(Arrays.toString(numLine));
          boolean can=true;
          for(int i=1;i<=n;i++) {
        	  if(numLine[i]==false) {
        		  pw.println(""no"");
        		  can=false;
        		  break;
        	  }
        	  
          }
          if(can)pw.println(""yes"");
          
           
            	
            	
            

			
		}
		
	 pw.close();

	}

	// --------------------stuff ----------------------
	

	

}
",0,Non-plagiarised
45561f1f,cc9230d3,"import java.util.*;
import java.io.*;
import java.math.*;

public class C1529 {
    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(System.out);
        Reader s = new Reader();
        int t = s.i();
        while (t-- > 0) {
            int n = s.i();
            pairLong [] arr = new pairLong[n];
            for (int i=0;i<n;i++) {
                long x = s.l() , y = s.l();
                arr[i] = new pairLong(x,y);
            }
            ArrayList<Integer>[] tree = new ArrayList[n+1];
            for (int i=0;i<=n;i++) tree[i] = new ArrayList<>();
            for (int i=0;i<n-1;i++) {
                int x = s.i() , y = s.i();
                tree[x].add(y);
                tree[y].add(x);
            }
            pairLong[] dp = new pairLong[n+1];
            boolean [] vis = new boolean[n+1];
            pairLong x = value(tree,arr,dp,1,vis);
            out.println(Math.max(x.first,x.second));
        }
        out.flush();
    }
    private static pairLong value(ArrayList<Integer>[] tree , pairLong [] arr , pairLong [] dp , int in , boolean [] vis) {
        if (dp[in] != null) return dp[in];
        vis[in] = true;
        long a = 0L , b = 0L;
        for (int x : tree[in]) {
            if (!vis[x]) {
                pairLong y = value(tree,arr,dp,x,vis);
                a += Math.max(Math.abs(arr[in-1].first-arr[x-1].first) + y.first,Math.abs(arr[in-1].first-arr[x-1].second) + y.second);
                b += Math.max(Math.abs(arr[in-1].second-arr[x-1].first) + y.first,Math.abs(arr[in-1].second-arr[x-1].second) + y.second);
            }
        }
        dp[in] = new pairLong(a,b);
        return dp[in];
    }
    
    

    

    

    

    

    

    

    

    

    
    static class pairLong implements Comparator<pairLong> {
        long first, second;

        pairLong() {
        }

        pairLong(long first, long second) {
            this.first = first;
            this.second = second;
        }

        
    }
//    static class pair implements Comparator<pair> {
//        int first, second;
//
//        pair() {
//        }
//
//        pair(int first, int second) {
//            this.first = first;
//            this.second = second;
//        }
//
//        @Override
//        public int compare(pair p1, pair p2) {
//            if (p1.first == p2.first) return p1.second - p2.second;
//            return p1.first - p2.first;
//        }
//    }
}
","import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

public class C {


    static int[][] lr = new int[2][(int)2e5+10];
    static long[][] dp = new long[2][(int)2e5+10];
    static ArrayList<ArrayList<Integer>> g;
    public static void main(String[] args) {
        
        FastReader fr = new FastReader();
        PrintWriter out = new PrintWriter(System.out, true);
        int cases = fr.nextInt();
        for(int c = 0; c < cases; c++) {
            int nodes = fr.nextInt();
            g = new ArrayList<ArrayList<Integer>>();
            
            for(int i = 1; i <= nodes; i++) {
                lr[0][i] = fr.nextInt();
                lr[1][i] = fr.nextInt();
            }
            for(int i = 0; i <= nodes; i++) {
                g.add(new ArrayList<Integer>());
            }

            for(int i = 0; i < nodes-1; i++) {
                int f = fr.nextInt();
                int t = fr.nextInt();
                g.get(f).add(t);
                g.get(t).add(f);
            }
            DFS(1, -1);
            out.write(Math.max(dp[0][1], dp[1][1]) + ""\n"");

        }
        out.close();
    }

    static void DFS(int v, int p) {
        dp[0][v] = dp[1][v] = 0;
        for(Integer u : g.get(v)) {
            if (u == p) continue;
            DFS(u, v);
            dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
            dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
        }
    }

    
}
",0,Non-plagiarised
169e34bf,c9159d9c,"import java.util.*;
public class D{
  static Scanner sc;
  public static void solve(){
    int n=sc.nextInt();
    Integer a[]=new Integer[n];
    int flag;
    for(int i=0;i<n;i++) a[i]=sc.nextInt();
    String s=sc.next();
    ArrayList<Integer> x=new ArrayList<>();
    ArrayList<Integer> y=new ArrayList<>();
    for(int i=0;i<n;i++){
      if(s.charAt(i)=='B') x.add(a[i]);
      else y.add(a[i]);
    }
    Collections.sort(x);
    Collections.sort(y);
    int p=n;
    int q=1;
    for(int i=y.size()-1;i>=0;i--){
      if(y.get(i)>p){System.out.println(""NO""); return;}
      p-=1;
    }
    for(int i=0;i<x.size();i++){
      if(x.get(i)<q){System.out.println(""NO""); return;}
      q+=1;
    }
    System.out.println(""YES"");
  }
  public static void main(String args[]){
      sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0) solve();
  }
}
","import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
",0,Non-plagiarised
43855bfe,ddcadc64,"import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class O4 {
    private static String solve(int n, int[] a) {

        if (n == 2) {
            return a[1] + "" "" + (-a[0]);
        }
        int res[] = new int[n];
        if (n % 2 == 0) {
            diagonalAlignment(a, res, n);
        } else {

            diagonalAlignment(a, res, n - 3);
            if ( a[n - 3] + a[n - 2] != 0)
            {
                res[n - 1] = a[n - 3] + a[n - 2];
                res[n - 2] = -a[n - 1];
                res[n - 3] = -a[n - 1];
            }

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

            }
        }


        return formattedArray(res);

    }

    private static void diagonalAlignment(int[] a, int[] res, int n) {


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


    }


    public static void main(String[] args)
            throws IOException {
        Scanner s = new Scanner();
        int t = 1;
        t = s.nextInt();
        StringBuilder ans = new StringBuilder();
        int count = 0;
        while (t-- > 0) {
            int n = s.nextInt();

            int a[] = new int[n];
            getInputs(s, a, n);


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

    

    

    

    

    

    

    public static String formattedArray(int a[]) {
        StringBuilder res = new StringBuilder("""");
        for (int e : a)
            res.append(e).append("" "");
        return res.toString().trim();

    }

    private static void getInputs(Scanner s, int[] a, int n) throws IOException {
        for (int i = 0; i < n; i++) {
            a[i] = s.nextInt();
        }
    }
}
","import java.util.Scanner;

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;

public class B {

    static void solve() throws Exception {
        int t=scanInt();
        while (t-->0){
            int n=scanInt();
            int []arr=new int[n];
            int low=Integer.MAX_VALUE;
            int high=0;
            for (int i=0;i<n;i++){
                arr[i]=scanInt();
                low=Math.min(low,arr[i]);
                high=Math.max(high,arr[i]);
            }
            int ans=low;
            while (low<=high){
                int mid=low+(high-low)/2;
                boolean flag=true;
                int []temp=new int[n];
                for (int i=0;i<n;i++){
                    temp[i]=arr[i];
                }

                for (int i=n-1;i>=2;i--){
                    if(temp[i]<mid){
                        flag=false;
                        break;
                    }

                    int rem=Math.min(temp[i]-mid,arr[i]);
                    int taken=rem/3;
                    temp[i]-=3*taken;
                    temp[i-1]+=taken;
                    temp[i-2]+=2*taken;

                }

                if(temp[0]<mid || temp[1]<mid){
                    flag=false;
                }
                if(flag){
                    low=mid+1;
                    ans=mid;
                }else {
                    high=mid-1;
                }
            }

            System.out.println(ans);
        }

    }

    static int scanInt() throws IOException {
        return parseInt(scanString());
    }

    

    static String scanString() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer tok;

    public static void main(String[] args) {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
            in.close();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            exit(1);
        }
    }
}
","import java.io.*;
import java.util.*;

import javax.sound.midi.MidiChannel;

public class Main {
    static PrintWriter out;
    static 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
38129877,7493a104,"import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while (t-- > 0) {
            int n = scanner.nextInt();
            int[] h = new int[n];
            for (int i = 0; i < n; i++) {
                h[i] = scanner.nextInt();
            }
            System.out.println(binSearchSolution(h));
        }
    }

    private static int binSearchSolution(int[] a) {
        int l = 0;
        int r = (int)1e9 + 1;
        while (l < r - 1) {
            int m = l + (r - l) / 2;
            if (canAchieve(a, m)) {
                l = m;
            } else {
                r = m;
            }
        }
        return l;
    }

    private static boolean canAchieve(int[] a, int min) {
        int back1 = a[a.length - 2];
        int current = a[a.length - 1];
        int nextIndex = a.length - 3;
        while (nextIndex >= 0) {
            int back2 = a[nextIndex];
            if (current < min) {
                return false;
            }
            int canMove = Math.min(current - min, a[nextIndex + 2]);
            int d = canMove / 3;
            current = back1 + d;
            back1 = back2 + 2 * d;
            nextIndex--;
        }
        if (current < min || back1 < min) {
            return false;
        }
        return true;
    }
}
","import java.util.Scanner;
 
public class C {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        while (t-- > 0) {
            int n = scanner.nextInt();
            int[] h = new int[n];
            for (int i = 0; i < n; i++) {
                h[i] = scanner.nextInt();
            }
            System.out.println(binSearchSolution(h));
        }
    }
 
    private static int binSearchSolution(int[] a) {
        int l = 0;
        int r = (int)1e9 + 1;
        while (l < r - 1) {
            int m = l + (r - l) / 2;
            if (canAchieve(a, m)) {
                l = m;
            } else {
                r = m;
            }
        }
        return l;
    }
 
    private static boolean canAchieve(int[] a, int min) {
        int back1 = a[a.length - 2];
        int current = a[a.length - 1];
        int nextIndex = a.length - 3;
        while (nextIndex >= 0) {
            int back2 = a[nextIndex];
            if (current < min) {
                return false;
            }
            int canMove = Math.min(current - min, a[nextIndex + 2]);
            int d = canMove / 3;
            current = back1 + d;
            back1 = back2 + 2 * d;
            nextIndex--;
        }
        if (current < min || back1 < min) {
            return false;
        }
        return true;
    }
}
",1,Plagiarised
4138b081,f729338f,"import java.io.*;
import java.util.*;
 
public class Contest1627C
{
    
    static InputReader r = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static long mod = 1000000007; static ArrayList<Integer>[] adj; static ArrayList<Integer>[] num; static int[] ans;
    public static void main(String[] args)
    {
    	int t = r.nextInt();
    	while (t > 0)
    	{
    		t--;
    		int n = r.nextInt();
    		adj = new ArrayList[n];
    		num = new ArrayList[n];
    		for (int i = 0; i < n; i ++)
    		{
    			adj[i] = new ArrayList<Integer>();
    			num[i] = new ArrayList<Integer>();
    		}
    		int[] deg = new int[n];
    		boolean flag = false;
    		for (int i = 0; i < n - 1; i ++)
    		{
    			int a = r.nextInt()-1;
    			int b = r.nextInt()-1;
    			adj[a].add(b);
    			adj[b].add(a);
    			num[a].add(i);
    			num[b].add(i);
    			deg[a] ++;
    			deg[b] ++;
    			if (deg[a] > 2 || deg[b] > 2)
    			{
    				flag = true;
    			}
    		}
    		if (flag)
    		{
    			pw.println(-1);
    			continue;
    		}
    		ans = new int[n];
    		for (int i = 0; i < n; i ++)
    		{
    			if (deg[i] == 1)
    			{
    				dfs(i,3,-1);
    			}
    		}
    		for (int i = 0; i < n - 1; i ++)
    		{
    			pw.println(ans[i]);
    		}
    	}
        pw.close();
    }
    static void dfs(int node, int x, int p)
    {
    	for (int j = 0; j < adj[node].size(); j ++)
    	{
    		int i = adj[node].get(j);
    		if (i == p)
    		{
    			continue;
    		}
    		ans[num[node].get(j)] = x;
    		dfs(i,5-x,node);
    	}
    }
}
","import java.io.*;
import java.util.*;

public class Solution{
    
    public static class Edge
    {
        int index; int u, v;
        Edge(int u, int v, int index)
        {
            this.index=index;
            this.u = u;
            this.v = v;
        }
        
    }
	public static void main (String[] args) throws Exception 
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb=new StringBuilder();
		int t=Integer.parseInt(br.readLine());
		
		while(t-->0)
		{
		    int n=Integer.parseInt(br.readLine());
		    ArrayList<Edge> graph[] = new ArrayList[n];
		    for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
		    
		    for(int i=0; i<n-1; i++)
		    {
		        StringTokenizer st=new StringTokenizer(br.readLine());
		        int u = Integer.parseInt(st.nextToken());
		        int v = Integer.parseInt(st.nextToken());
		        
		        u--; v--;
		        graph[u].add(new Edge(u,v,i));
		        graph[v].add(new Edge(v,u,i));
		    }
		    
		    int start_i = 0;
		    boolean poss = true;
		    for(int i =0; i<n; i++)
		    {
		        if(graph[i].size()>2) 
		        {
		            poss = false;
		        }
		        else if(graph[i].size() == 1) start_i = i;
		    }
		    
		    if(!poss) 
		    {
		        sb.append(""-1\n"");
		        continue;
		    }
		    
		    int wts[] = new int[n-1];
		    
		    ArrayList<Edge> edges = new ArrayList<>();
		    
		    Edge first = graph[start_i].get(0);
		    wts[first.index] = 2;
		    
		    edges = graph[first.v];
		    
		    while(edges.size()>1)
		    {
		        
		        Edge firste = edges.get(0);
		        Edge sece = edges.get(1);
		        if(wts[firste.index] != 0 ) //second not visited
		        {
		            wts[sece.index] = 5 - wts[firste.index];
		            edges = graph[sece.v];
		        }
		        else //first not visited
		        {
		            wts[firste.index] = 5 - wts[sece.index];
		            edges = graph[firste.v];
		        }
		    }
		    
		    for(int i=0; i<n-1; i++)
		        sb.append(wts[i]+"" "");
	        sb.append(""\n"");
		    
		    
		}
		System.out.println(sb);
	}
}
",0,Non-plagiarised
5e8d1aaa,c4d04ce7,"import java.io.*;
import java.util.*;

/*

*/


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

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

/*

*/


public class E {
	static FastReader sc=null;
	static long nax=(long)1e15+7;
	
	public static void main(String[] args) {
		sc=new FastReader();
		PrintWriter out=new PrintWriter(System.out);
		int test=sc.nextInt();
		while(test-->0) {
			int n=sc.nextInt(),k=sc.nextInt();
			int a[]=sc.readArray(k),t[]=sc.readArray(k);
			int present[]=new int[n];
			Arrays.fill(present, -1);
			for(int i=0;i<k;i++) {
				a[i]--;
				present[a[i]]=t[i];
			}
			long min=nax;
			long temps[]=new long[n];
			Arrays.fill(temps, nax);
			for(int i=n-1;i>=0;i--) {
				if(present[i]!=-1) {
					min=Math.min(min, present[i]+i);
				}
				temps[i]=Math.min(temps[i], min-i);
			}
			min=nax;
			for(int i=0;i<n;i++) {
				if(present[i]!=-1) {
					min=Math.min(min, present[i]-i);
				}
				temps[i]=Math.min(temps[i], min+i);
			}
			for(long e:temps)out.print(e+"" "");
			out.println();
			
		}
		out.close();
		
	
	}
	
	
	static void print(int a[]) {
		for(int e:a) {
			System.out.print(e+"" "");
		}
		System.out.println();
	}
	
	
}
",1,Plagiarised
2bbc6c80,4e58558c,"import java.io.*;
import java.util.*;

public class Main {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
	
	
	
	static String readLine() throws IOException {
		return br.readLine();
	}
	
	static List<Integer> adj[];
	static int n, a[][];
	static long dp[][];
	static void DFS(int v, int p) {
		for (int u : adj[v]) {
			if (u != p) {
				DFS(u, v);
				for (int i = 0; i <= 1; ++i) {
					long add = 0;
					for (int j = 0; j <= 1; ++j)
						add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
					dp[v][i] += add;
				}
			}
		}
	}
	public static void main(String[] args) throws IOException {
		for (int t = readInt(); t > 0; --t) {
			n = readInt();
			adj = new List[n + 1];
			for (int i = 1; i <= n; ++i)
				adj[i] = new ArrayList();
			a = new int[n + 1][2];
			for (int i = 1; i <= n; ++i) {
				a[i][0] = readInt();
				a[i][1] = readInt();
			}
			for (int i = 1; i < n; ++i) {
				int u = readInt(), v = readInt();
				adj[u].add(v);
				adj[v].add(u);
			}
			dp = new long[n + 1][2];
			DFS(1, 0);
			System.out.println(Math.max(dp[1][0], dp[1][1]));
		}
	}
}
","import java.io.*;
import java.util.*;
 
public class Main {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
	
	
	
	static String readLine() throws IOException {
		return br.readLine();
	}
	
	static List<Integer> adj[];
	static int n, a[][];
	static long dp[][];
	static void DFS(int v, int p) {
		for (int u : adj[v]) {
			if (u != p) {
				DFS(u, v);
				for (int i = 0; i <= 1; ++i) {
					long add = 0;
					for (int j = 0; j <= 1; ++j)
						add = Math.max(add, dp[u][j] + Math.abs(a[v][i] - a[u][j]));
					dp[v][i] += add;
				}
			}
		}
	}
	public static void main(String[] args) throws IOException {
		for (int t = readInt(); t > 0; --t) {
			n = readInt();
			adj = new List[n + 1];
			for (int i = 1; i <= n; ++i)
				adj[i] = new ArrayList();
			a = new int[n + 1][2];
			for (int i = 1; i <= n; ++i) {
				a[i][0] = readInt();
				a[i][1] = readInt();
			}
			for (int i = 1; i < n; ++i) {
				int u = readInt(), v = readInt();
				adj[u].add(v);
				adj[v].add(u);
			}
			dp = new long[n + 1][2];
			DFS(1, 0);
			System.out.println(Math.max(dp[1][0], dp[1][1]));
		}
	}
}
",1,Plagiarised
22b41936,2.921E+060,"import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {

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

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

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

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

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

     }



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

//        try {


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


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

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


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

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








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

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

    }

    

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


    

    

    

    


    

    

    

    

    


    


    


    


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

	

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


	

	

	

	

	


	

	

	


	

	

	

	

	

	

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

	

	

	
}
",0,Non-plagiarised
ac121776,eb6cfca7,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;


public class Solution {
    
    
    
    
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        int t = sc.nextInt();
        while (t-- != 0) {
            int n = sc.nextInt();
            long a[] = new long[n];
            for(int i=0;i<n;i++){
                a[i] = sc.nextLong();
            }
            long mineA = a[0];
            long mineB = a[1];
            long accA =0 ;
            long accB = 0;
            long remA = n;
            long remB = n;
            long ans = (mineA * n) + (mineB *n);
            boolean check = true;
            for(int i =2;i<n;i++){
                if(check){
                    check = false;
                    long x = Math.min(a[i],mineA);
                    long y = Math.max(a[i],mineA);
                    mineA = x;
                    accA += y;
                    remA --;
                    long sug = (accA +  remA * mineA) + (accB + remB * mineB);
                    ans = Math.min(sug , ans);
                }else{
                    check = true;
                    long x = Math.min(a[i],mineB);
                    long y = Math.max(a[i],mineB);
                    mineB = x;
                    accB += y;
                    remB --;
                    long sug = (accA +  remA * mineA) + (accB + remB * mineB);
                    ans = Math.min(sug,ans);
                }
            }
            System.out.println(ans);
        }
    }
}
","import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Main {

	public Main() throws FileNotFoundException {

//		File file = Paths.get(""input.txt"").toFile();
//		if (file.exists()) {
//			System.setIn(new FileInputStream(file));
//		}
		long t = System.currentTimeMillis();

		InputReader reader = new InputReader();

		int ttt = reader.nextInt();

		for (int tt = 0; tt < ttt; tt++) {
			int n=reader.nextInt();
			
			long[] s=new long[n];
			for(int i=0;i<n;i++) {
				s[i]=reader.nextLong();
			}
			
			long smallest1=s[0];
			long smallest2=s[1];
			long val=n*s[0]+n*s[1];
			
			int left1=n-1;
			int left2=n-1;
			long base=s[0]+s[1];
			for(int i=2;i<n;i++) {
				if(i%2==0) {
					//left1
					val=Math.min(val, base+left2*smallest2+left1*s[i]);
					base+=s[i];
					smallest1=Math.min(smallest1, s[i]);
					left1--;
				}else {
					val=Math.min(val, base+left1*smallest1+left2*s[i]);
					base+=s[i];
					smallest2=Math.min(smallest2, s[i]);
					left2--;
					//left2
				}
			}
			

			System.out.println(val);
		}

	}

	

	public static void main(String[] args) throws FileNotFoundException {
		new Main();
	}

}
",0,Non-plagiarised
49b94994,558df7d4,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main1582D {
    public static void main(String[] args) {
        final FastScanner in = new FastScanner(System.in);
        final PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int j = 0; j < n; j++) {
                a[j] = in.nextInt();
            }
            int[] b = solution(a, n);
            for (int j = 0; j < n; j++) {
                out.print(b[j]);
                out.print("" "");
            }
            out.println();
        }

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

    private static int[] solution(int[] a, int n) {
        int[] b = new int[n];
        int start = 0;

        if (n % 2 == 1) {
            if (a[0] + a[1] != 0) {
                b[0] = -a[2];
                b[1] = -a[2];
                b[2] = a[0] + a[1];
            } else if (a[0] + a[2] != 0) {
                b[0] = -a[1];
                b[1] = a[0] + a[2];
                b[2] = -a[1];
            } else {
                b[0] = a[1] + a[2];
                b[1] = -a[0];
                b[2] = -a[0];
            }
            start = 3;
        } else {
            b[0] = -a[1];
            b[1] = a[0];
            int gcd = gcd(b[0], b[1]);
            b[0] /= gcd;
            b[1] /= gcd;
            start = 2;
        }
        for (int i = start; i < n; i += 2) {
            b[i] = -a[i + 1];
            b[i + 1] = a[i];
        }
        return b;
    }

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

    
}
","import java.io.*;
import java.util.*;
public class Pupsen {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i=0; i<n; i++) {
				a[i] = in.nextInt();
			}
			int[] b = new int[n];
			if (n%2==0) {
				for (int i=0; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			else {
				if (a[0]+a[1]!=0) {
					b[0] = -a[2];
					b[1] = -a[2];
					b[2] = a[0]+a[1];
				}
				else if (a[0]+a[2]!=0) {
					b[0] = -a[1];
					b[2] = -a[1];
					b[1] = a[0]+a[2];
				}
				else {
					b[1] = -a[0];
					b[2] = -a[0];
					b[0] = a[1]+a[2];
				}
				for (int i=3; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			System.out.println();
		}
	}
	
}
",0,Non-plagiarised
04df7bb8,aaccc000,"import java.math.BigInteger;
										import java.sql.Array;
									    import java.util.ArrayList;
										import java.util.Arrays;
										import java.util.Collection;
										import java.util.Collections;
										import java.util.Comparator;
										import java.util.Deque;
										import java.util.HashMap;
										import java.util.HashSet;
										import java.util.InputMismatchException;
										import java.util.LinkedList;
										import java.util.PriorityQueue;
										import java.util.Queue;
										import java.util.Scanner;
										import java.util.Set;
										import java.util.Stack;
										import java.io.BufferedReader;
										import java.io.IOException;
										import java.io.InputStream;
										import java.io.InputStreamReader;
										import java.util.Scanner;
										import java.util.StringTokenizer;
										import java.util.TreeMap;
										import java.util.TreeSet;
										
											
											
											
											
											
											public class Main {
							
												
												static HashMap<Integer,Boolean>map;
												
											static long dp[][];
											static 	boolean flag;
										static	HashSet<Long>hs;
											static long mod=(long)(1e9+7);
												public static void main(String[] args) {
												StringBuilder ans=new StringBuilder();
												FastReader sc=new FastReader();
													
												
												int t=sc.nextInt();
												
												
												while(t-->0) {
													
													int n=sc.nextInt();
													
													
													//int n=sb.length();
													
													
													
													int k=sc.nextInt();
													
													
													long L[]=new long[n];
													long R[]=new long[n];
													int a[]=new int[k];
													int temp[]=new int[k];
													
													for(int i=0;i<k;i++)
														a[i]=sc.nextInt();
													
													for(int i=0;i<k;i++)
														temp[i]=sc.nextInt();
													
													int c[]=new int [n];
													Arrays.fill(c, Integer.MAX_VALUE);
													for(int i=0;i<k;i++)
														c[a[i]-1]=temp[i];
												
													long p=Integer.MAX_VALUE;
													
													for(int i=0;i<n;i++)
													{
														p=Math.min(p+1, c[i]);
														
														L[i]=p;
														
														
													}
													p=Integer.MAX_VALUE;
													for(int i=n-1;i>=0;i--)
													{
														p=Math.min(p+1, c[i]);
														
														R[i]=p;
														
														
													}
													
													for(int i=0;i<n;i++)
													{
														ans.append(Math.min(L[i], R[i])+"" "");
													}
											ans.append(""\n"");
													
												}
												System.out.println(ans);
												
												}
													
											
													


												
												
							
												
												
												
												
												
												
												
												
											
												
												
												
												
												
												
												
												
												
												
												
												
												
													
													
												
												
												
												
												
												
												
												
												
												
												
												
												
												
												
									
												
												
											
												
										
												
												
												
												
												
											 
												
											 
												
												
												
											
												
											
												
												
												
												
												
												 
												  
												
												   
												
									
												//System.out.println(count);
												
											
												
												
												
												
												
												
										
										
												
										
												
												
												
												
												//	System.out.println(max);
										
												
											
												
											
									
				//System.out.println(ans.toString());
				//main(						
											
							
					
				
						
												
												
												
								
												
								
												
												
								
												
												
												
												
												
												
												
									
									
												
												
												
												
								
								
								
							
								
									
												
												
												
								
												
												
												
									
							
												
									
									
												
												
												
												
												
												
												
												
												
												
												
									
										
										
										
										
				
				
					
				
				
										
											
																					
											
									    
									 
										
											}
","import java.io.*;
import java.util.*;

public class GFG {
	public static void main (String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int t = sc.nextInt();
	    while(t-- > 0){
	        int n = sc.nextInt();
	        int k = sc.nextInt();
	        int[] a = new int[k];
	        int[] temp = new int[k];
	        for(int i=0;i<k;i++){
	            a[i] = sc.nextInt();
	        }
	        for(int i=0;i<k;i++){
	            temp[i] = sc.nextInt();
	        }
	        long[] c = new long[n];
	        Arrays.fill(c,Integer.MAX_VALUE);
	        for(int i=0;i<k;i++){
	            c[a[i]-1] = temp[i];
	        }
	        long p = Integer.MAX_VALUE;
	        long[] left = new long[n];
	        for(int i=0;i<n;i++){
	            p = (p+1<c[i])?p+1:c[i];
	            left[i] = p;
	        }
	        p = Integer.MAX_VALUE;
	        long[] right = new long[n];
	        for(int i=n-1;i>=0;i--){
	            p = (p+1<c[i])?p+1:c[i];
	            right[i] = p;
	        }
	        for(int i=0;i<n;i++){
	            long kl = (left[i]>right[i])?right[i]:left[i];
	            System.out.print(kl+"" "");
	        }
	        System.out.println();
	    }
	}
}
",1,Plagiarised
af2b138c,e45446bc,"import java.util.*;
import java.lang.*;
import java.io.*;



public class ecf106 {

//HashMap<Integer,Integer> hm=new HashMap<>();
//ArrayList<Integer> list=new ArrayList<>();
//HashSet<Integer> hs=new HashSet<>();
//Stack<Integer> st=new Stack<>();
//Queue<Integer> q=new LinkedList<>();
//PriorityQueue<Integer> pq=new PriorityQueue<>();
// static ArrayList<ArrayList<Integer>> gp=new ArrayList<>();
//int[] arr=new int[n];
//System.out.println(""YES"");
//1 hr- atleast 2 qs d-2
//Mt_do 3 qs d-2  
//Mt_do 4 qs d-3
//StringBuilder sb=new StringBuilder();

public static void main(String[] args) throws Exception{
    InputStreamReader ip=new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(ip);
    int t= Integer.parseInt(br.readLine());
    
    while(t-->0){
       int n=Integer.parseInt(br.readLine());//Integer.parseInt(strs[0]);
        String[] strs=(br.readLine()).trim().split("" "");
        // int n=Integer.parseInt(strs[0]),k=Integer.parseInt(strs[1]);//,k=Integer.parseInt(strs[2]);

        // strs=(br.readLine()).trim().split("" "");
         long[] arr=new long [n];

        for(int i=0;i<n;i++){
            arr[i]=Integer.parseInt(strs[i]);
        }

        long min1=0,min2=0;
        long x=0,y=0;
        long hor=arr[0],vert=arr[1];
        long ans=(n*hor)+(n*vert);
        
        for(int i=2;i<n;i++){
            if(i%2==0){
                x++;
                if(arr[i]>=hor){   //v.v.imp  donot update horizontal
                    min1+=arr[i];  
                }else{
                    min1+=hor;  hor=arr[i];
                }
            }else{
                y++;
                if(arr[i]>=vert){   //v.v.imp  donot update vertical
                    min2+=arr[i];    
                }else{
                    min2+=vert;  vert=arr[i];
                }
            }

            long rem=(n-x)*hor+(n-y)*vert;

            ans=Math.min(ans, min1+min2+rem);
        }

        System.out.println(ans);
    }

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

	}

	

	

	

}
",1,Plagiarised
1dab88fb,b7de5c19,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.util.*;

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

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

class Pair {
    int vertex;
    int numberOfEdge;

    public Pair(int vertex, int numberOfEdge) {
        this.vertex = vertex;
        this.numberOfEdge = numberOfEdge;
    }
}
",0,Non-plagiarised
18e2441c,43b10dec,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map;
import java.util.HashMap;

public class cf1515 {

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

	static class Task {
		public void solve(InputReader in, PrintWriter out) {
			int t = in.nextInt();
			while (t-- != 0) {
				int n = in.nextInt();
				int m = in.nextInt();
				int x = in.nextInt();
				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
				for (int i = 0; i < n; i++) {
					int j = in.nextInt();
					if (!map.containsKey(j)) {
						map.put(j, new ArrayList<Integer>());
					}
					map.get(j).add(i);
				}
				out.println(""YES"");
				int[] ans = new int[n];
				int sta = 0;
				for (int s : map.keySet()) {
					for (int i = 0; i < map.get(s).size(); i++) {
						ans[map.get(s).get(i)] = (sta++) % m + 1;
					}
				}
				for(int i=0;i<n;i++) {
					out.print(ans[i]+"" "");
				}
				out.println();
			}

		}
	}

	
}
","import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.StringTokenizer;
import java.util.concurrent.TimeUnit;

public class C101 {

    static HritikScanner sc = new HritikScanner();
    static PrintWriter pw = new PrintWriter(System.out, true);

    public static void main(String[] args) {

        int t = ni();
        while (t-- > 0) {
            solve();
        }
    }

     static void solve() {
         int n = ni();
         int m = ni(), x = ni();
         Map<Integer, ArrayList<Integer>> map = new TreeMap<>();
         System.out.println(""YES"");
         for(int i = 0; i < n; i++)
         {
             int num = ni();
             if(!map.containsKey(num))
             {
                 map.put(num, new ArrayList<Integer>());
             }
             map.get(num).add(i);
         }
         int[] ans = new int[n];
         int q = 0;
         for(int block : map.keySet())
         {
             for(int i = 0; i < map.get(block).size(); i++)
             {
                 ans[map.get(block).get(i)] = (q++)%m+1;
             }
         }
         for(int ele : ans)
         {
             System.out.print(ele + "" "");
         }
     }
    
    
    /////////////////////////////////////////////////////////////////////////////////
    

    

    

    /////////////////////////////////////////////////////////////////////////////////
    static int ni() {
        return sc.nextInt();
    }

    

    

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

    

    

    

    

    

    

    

    

    

    

    

    

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

    /////////////////////////////////////////////////////////////////////////////////
    //-----------HritikScanner class for faster input----------//
    

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

    //////////////////////////////////////////////////////////////////
    // Function to return gcd of a and b time complexity O(log(a+b))
    

    // method to return LCM of two numbers 
    

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

    

    

    

    

    //////////////////////////////////////////////////////////////////
    // method returns Nth power of A 
    

}
",1,Plagiarised
6653a758,f6ca6fc8,"import java.util.*;
public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.util.*;
import java.io.*;

public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		ArrayList<Integer>  o=new ArrayList<Integer>();
		ArrayList<Integer>  e=new ArrayList<Integer>();
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		int dp[][]=new int[o.size()+1][e.size()+1];
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++){
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",1,Plagiarised
c4ca2ff3,d6fb3b9e,"import java.util.*;
import java.lang.*;
import java.io.*;

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

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.util.*;
import java.io.*;

public class Main {
	

	public static FastReader obj = new FastReader();
	public static PrintWriter out = new PrintWriter(System.out);

	

	

	//Cover the small test cases like for n=1 .
	public static class pair {
		int a;
		int b;

		pair(int  x, int y) {
			a = x;
			b = y;
		}
	}

	

	public static int i() {
		return obj.nextInt();
	}

	

	

	public static int[] i(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = i();
		return arr;
	}

	

	

	

	

	

	public static void sortpair(ArrayList<pair> arr) {
		//ascending just change return 1 to return -1 and vice versa to get descending.
		//compare based on value of pair.a
		arr.sort(new Comparator<pair>() {
			
		});
	}

	// Take of the small test cases such as when n=1,2 etc.
	// remember in case of fenwick tree ft is 1 based but our array should be 0 based.
	// in fenwick tree when we update some index it doesn't change the value to val but it
	// adds the val value in it so remember to add val-a[i] instead of just adding val.
	//in case of finding the inverse mod do it (biexpo(a,mod-2)%mod + mod )%mod
    public static ArrayList<ArrayList<pair>> adj;
    public static int[] ans;
	public static void main(String[] args) {

		int len = i();
		while (len-- != 0) {
			int n = i();
			adj=new ArrayList<>(n+1);
			ans=new int[n];
			int ok=0;
			for(int i=0;i<=n;i++)adj.add(new ArrayList<>());
			for(int i=0;i<n-1;i++)
			{
				int a=obj.nextInt();
				int b=obj.nextInt();
				adj.get(a).add(new pair(b,i));
				adj.get(b).add(new pair(a,i));
				if(adj.get(a).size()>2)ok=1;
				if(adj.get(b).size()>2)ok=1;
			}
			if(ok==1)out.println(-1);
			else
			{
				int[] vis=new int[n+1];
				if(adj.get(1).size()==2)
				{
					vis[adj.get(1).get(1).a]=1;
					dfs(1,vis,11);
					vis[adj.get(1).get(1).a]=0;
					vis[1]=0;
					dfs(1,vis,2);
				}
				else
				{
					dfs(1,vis,11);
				}
				for(int i=0;i<n-1;i++)out.print(ans[i]+"" "");
				out.println();
			}
		}
		out.flush();
	}
	public static void dfs(int cur,int[] vis,int c)
	{
		vis[cur]=1;
		for(pair nd:adj.get(cur))
		{
			if(vis[nd.a]==1)continue;
			if(c==2)ans[nd.b]=11;
			else ans[nd.b]=2;
			dfs(nd.a,vis,ans[nd.b]);
		}
	}
}
",0,Non-plagiarised
3afcc566,d8a171a3,"import java.io.*;
import java.util.*;

import static java.lang.Math.*;

//Think through the entire logic before jump into coding!
//If you are out of ideas, take a guess! It is better than doing nothing!
//Read both C and D, it is possible that D is easier than C for you!

//Be aware of integer overflow!
//If you find an answer and want to return immediately, don't forget to flush before return!

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

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

    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            int n = in.nextInt();
            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
            for(int i = 0; i < n; i++) {
                if(a[i] == b[i]) {
                    if(a[i] == '0') match0++;
                    else match1++;
                }
                else {
                    if(a[i] == '0') mismatch01++;
                    else mismatch10++;
                }
            }
            if(mismatch01 + mismatch10 == 0) out.println(0);
            else {
                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
                    out.println(min(match0 + match1, mismatch01 + mismatch10));
                }
                else if(match1 - match0 == 1) {
                    out.println(match0 + match1);
                }
                else if(mismatch01 == mismatch10) {
                    out.println(mismatch01 + mismatch10);
                }
                else out.println(-1);
            }
        }
        out.close();
    }

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

    
}
","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
5289e80a,d82fa7e3,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

//6 4 1 1 4 1

//-3 4 -2 0 -4 6 1
// 4    6 1
//-4 -3 -2 0 1 4 6
public class C1 {
    private static void solve(List<Integer>[] g, int[][] a) {
        long[] dfs = dfs(g, a, 0, -1);
        System.out.println(Math.max(dfs[0], dfs[1]));
    }

    private static long[] dfs(List<Integer>[] g, int[][] a, int v, int p) {
        long lans = 0;
        long rans = 0;
        for (Integer i : g[v]) {
            if (i != p) {
                long[] dfs = dfs(g, a, i, v);
                lans += Math.max(Math.abs(a[v][0] - a[i][1]) + dfs[1], Math.abs(a[v][0] - a[i][0]) + dfs[0]);
                rans += Math.max(Math.abs(a[v][1] - a[i][1]) + dfs[1], Math.abs(a[v][1] - a[i][0]) + dfs[0]);

            }
        }
        return new long[]{lans, rans};
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int t = sc.nextInt();
        for (int i = 0; i < t; i++) {
            int n = sc.nextInt();
            int[][] a = new int[n][2];
            for (int j = 0; j < n; j++) {
                a[j] = new int[]{sc.nextInt(), sc.nextInt()};
            }
            List<Integer>[] g = new ArrayList[n];
            for (int j = 0; j < n; j++) {
                g[j] = new ArrayList<>();
            }
            for (int j = 0; j < n - 1; j++) {
                int u = sc.nextInt() - 1;
                int v = sc.nextInt() - 1;
                g[u].add(v);
                g[v].add(u);
            }
            solve(g, a);
        }
    }


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

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

    static class CParsasHumongousTree {
        int n;
        long[][] dp;
        int[] l;
        int[] r;
        ArrayList<Integer>[] a;

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            n = in.nextInt();
            l = new int[n];
            r = new int[n];
            dp = new long[n][2];
            a = new ArrayList[n];
            for (int i = 0; i < n; ++i) {
                a[i] = new ArrayList<>();
            }

            for (int i = 0; i < n; ++i) {
                l[i] = in.nextInt();
                r[i] = in.nextInt();
            }

            for (int i = 0; i < n - 1; ++i) {
                int u = in.nextInt() - 1, v = in.nextInt() - 1;
                a[u].add(v);
                a[v].add(u);
            }

            dfs(0, -1);

            out.println(Math.max(dp[0][0], dp[0][1]));
        }

        void dfs(int u, int p) {
            dp[u][0] = dp[u][1] = 0;
            for (int v : a[u]) {
                if (v != p) {
                    dfs(v, u);
                    dp[u][0] += Math.max(dp[v][0] + Math.abs(l[u] - l[v]), dp[v][1] + Math.abs(l[u] - r[v]));
                    dp[u][1] += Math.max(dp[v][0] + Math.abs(r[u] - l[v]), dp[v][1] + Math.abs(r[u] - r[v]));
                }
            }
        }

    }

    
}
",0,Non-plagiarised
17e67976,656b62de,"import java.util.*;
public class code
{
    int hell(String arr[],int a,int n)
    {
        int sum=0;
        int s=0;
        int arr1[]=new int[n];
        int x=0;
        int y=0;
        for(int i=0;i<n;i++)
        {
            int l=arr[i].length();
            for(int j=0;j<l;j++)
            {
                if(arr[i].charAt(j)==a)
                    x++;
                else
                    y++;
            }
            arr1[i]=y-x;
            y=0;
            x=0;
        }
        Arrays.sort(arr1);
        for(int i=0;i<n;i++)
        {
            s+=arr1[i];
            if(s<0)
                sum++;
            else    
                break;
        }
        return sum;
    }
    public static void main(String args[])
    {
        code ob=new code();
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t-->0)
        {
            int sum1=0;
            int sum2=0;
            int n=sc.nextInt();
            String arr[]=new String[n];
            for(int i=0;i<n;i++)
            {
                arr[i]=sc.next();
            }
            for(int i=97;i<=102;i++)
            {
                sum2=ob.hell(arr,i,n);
                sum1=Math.max(sum2,sum1);
            }
            System.out.println(sum1);
        }
    }
}
","import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintWriter;
    import java.util.InputMismatchException;
    import java.util.PriorityQueue;

    public class InterestingStory {
        static InputReader inputReader=new InputReader(System.in);
        static void solve()
        {
            int n=inputReader.nextInt();
            String arr[]=new String[n];
            for (int i=0;i<n;i++)
            {
                arr[i]=inputReader.readString();
            }
            int larr[]=new int[n];
            for (int i=0;i<n;i++) {
                larr[i] = arr[i].length();
            }
            int freqarr[][]=new int[n][5];
            for (int i=0;i<n;i++)
            {
                freqarr[i]=freq(arr[i],larr[i]);
            }
            int max=Integer.MIN_VALUE;
            for (char c='a';c<='e';c++)
            {
                max=Math.max(max,helper(freqarr,larr,n,c));
            }
            out.println(max);
        }
        static  int helper(int freqarr[][],int larr[],int n,char c)
        {
            int sum=0;
            PriorityQueue<Integer>priorityQueue=new PriorityQueue<>();
            for (int i=0;i<n;i++)
            {
                int score=freqarr[i][c-'a']-(larr[i]-freqarr[i][c-'a']);
                priorityQueue.add(score);
                sum+=score;
            }
            while (!priorityQueue.isEmpty()&&sum<=0) {
                sum -= priorityQueue.poll();
            }
            return priorityQueue.size();
        }
       static int []freq(String str,int len)
        {
            int arr[]=new int[5];
            for (int i=0;i<len;i++)
            {
                arr[str.charAt(i)-'a']++;
            }
            return arr;
        }
        static PrintWriter out=new PrintWriter((System.out));
        public static void main(String args[])throws IOException
        {
            int t=inputReader.nextInt();
            while(t-->0)
            {
                solve();
            }
            out.close();
        }
        
    }
",0,Non-plagiarised
40cc90ae,9399204d,"import javax.swing.text.html.parser.Entity;
import java.io.*;
import java.util.*;
import java.math.BigInteger;



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

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

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

        static boolean[] prime;

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

        

        // 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.*;



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<5; i++)q[i]=new PriorityQueue<node1>();
			for(int i=0; i<N; i++)
			{
				char X[]=in.next().toCharArray();
				int s=X.length;
				size[i]=s;
				int f[]=new int[5];
				for(char x:X)f[x-'a']++;
				for(int j=0; j<5; j++)q[j].add(new node1(f[j],i,s));
			}
			
			int max=0;
			for(int i=0; i<5; i++)
			{
				PriorityQueue<node1> q_new=new PriorityQueue<>();
				q_new=q[i];
				int c=0;
				long f=0;
				while(q_new.size()>0)
				{
					node1 x=q_new.remove();
//					System.out.println(x.f+"" ""+x.size+"" ""+x.a);
					f+=x.a;
					if(f>0)
					{
						c++;
						max=Math.max(max, c);
					}
					else break;
				}
			}
			out.println(max);
		}
		out.close();

	}
	
	
	

	
	
	
	


	
	
	//	static 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
1162c08f,f6ca6fc8,"import java.util.*;

public class CodeForces1525C{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.util.*;
import java.io.*;

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

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		for(int q=0;q<t;q++){
		    //  int n = Integer.parseInt(br.readLine());
		      String s = br.readLine();
                  String s1[] = br.readLine().split("" "");
                  int n = Integer.parseInt(s1[0]);
                  int k = Integer.parseInt(s1[1]);
                  String s2[] = br.readLine().split("" "");
                  int a[] = new int[k];
                  for(int i=0;i<k;i++){
                        a[i] = Integer.parseInt(s2[i]);
                  }
                  String s3[] = br.readLine().split("" "");
                  int b[] = new int[k];
                  for(int i=0;i<k;i++){
                        b[i] = Integer.parseInt(s3[i]);
                  }
                  long ans[] = new long[n];
                  for(int i=0;i<n;i++){
                        ans[i] = Integer.MAX_VALUE;
                  }
                  for(int i=0;i<k;i++){
                        ans[a[i]-1] = b[i];
                  }
                  for(int i=1;i<n;i++){
                        ans[i] = Math.min(ans[i],ans[i-1]+1);
                  }
                  for(int i=n-2;i>=0;i--){
                        ans[i] = Math.min(ans[i],ans[i+1]+1);
                  }
                  
                  for(int i=0;i<n;i++){
                        System.out.print(ans[i]+"" "");
                  }
                  System.out.println();
		}
	}
}
",0,Non-plagiarised
2063ba3e,2ba7edb6,"import java.io.*;
import java.util.*;

public class c {
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int numCases = Integer.parseInt(in.readLine());
        for (int casenum = 0; casenum < numCases; casenum++) {
            int n = Integer.parseInt(in.readLine());
            long[] arr = new long[n];
            StringTokenizer tokenizer = new StringTokenizer(in.readLine());
            for (int i = 0; i < n; i++) {
                arr[i] = Long.parseLong(tokenizer.nextToken());
            }
            long low = 0;
            long high = 1000000000;
            low--;
            while (low < high) {
                long mid = low + (high - low + 1) / 2;
                boolean works = test(arr, mid);
                if (works) {
                    low = mid;
                } else {
                    high = mid - 1;
                }
                //System.out.println(mid + "" "" + works);
            }
            System.out.println(low);
        }
        in.close();
        out.close();
    }

    public static boolean test(long[] arr, long k) {
        long[] h = new long[arr.length];
        for (int i = 0; i < arr.length; i++) {
            h[i] = arr[i];
        }
        for (int i = h.length - 1; i - 2 >= 0; i--) {
            if (h[i] < k)
                break;
            long d = Math.min((h[i]-k) / 3, arr[i]/3);
            h[i] -= 3 * d;
            h[i - 1] += d;
            h[i-+ 2] += 2 * d;
        }
        for (int i = 0; i < h.length; i++) {
            if (h[i] < k)
                return false;
        }
        //System.out.println(Arrays.toString(h));
        return true;
    }
}
","import java.util.*;
import java.io.*;

public class BalancedStones {

	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(f.readLine());
		while (t > 0) {
			t--;
			int n = Integer.parseInt(f.readLine());
			int[] arr = new int[n];
			StringTokenizer st = new StringTokenizer(f.readLine());
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(st.nextToken());
			}
			int low = 0;
			int high = 1000000000;
			int answer = -1;
			while (low <= high) {
				int mid = low + (high - low) / 2;
				if (check(mid, arr)) {
					answer = mid;
					low = mid + 1;
				} else {
					high = mid - 1;
				}
			}
			System.out.println(answer);
		}
	}

	public static boolean check(int value, int[] old) {
		int[] newarr = new int[old.length];
		for (int i = 0; i < old.length; i++) {
			newarr[i] = old[i];
		}
		for (int i = old.length - 1; i >= 0; i--) {
			if (newarr[i] < value)
				return false;
			if (i > 1) {
				int d = Math.min(newarr[i] - value, old[i]) / 3;
				newarr[i] -= 3 * d;
				newarr[i - 1] += d;
				newarr[i - 2] += 2 * d;
			}
		}
		return true;
	}
}
",0,Non-plagiarised
29cb9b0e,d3da65ff,"import java.util.*;
public class Main
{
  
    public static void solve (int ar[],int n)
    {
       if(n%2==1)
        {
    
           
            int c=ar[2];
            int b=ar[1];
            int a=ar[0];
            if(a+b!=0)
            {
               ar[2]=-(a+b);
               ar[1]=c;
               ar[0]=c;
            }
            else if(b+c!=0)
            {
                 ar[2]=a;
               ar[1]=a;
               ar[0]=-(b+c);
            }
            else
            {
                 ar[2]=b;
               ar[1]=-(a+c);
               ar[0]=b;
            }
            System.out.print(ar[0]+"" ""+ar[1]+"" ""+ar[2]+"" "");
           for(int i=3;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           } 
            System.out.println();
        }
          //  System.out.println(ans[n-1]+ "" x""+ans[n-2]+"" x""+ans[n-3]);
           
          else
          {
              for(int i=0;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           }  
            System.out.println();
          }
          
           
        
    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		   int ar[]=new int[n];
		   for(int i=0;i<n;i++)
		   ar[i]=sc.nextInt();
		   solve(ar,n);
		}
	}
}
","import java.util.*;
public class Main
{
  
    public static void solve (int ar[],int n)
    {
       if(n%2==1)
        {
    
           
            int c=ar[2];
            int b=ar[1];
            int a=ar[0];
            if(a+b!=0)
            {
               ar[2]=-(a+b);
               ar[1]=c;
               ar[0]=c;
            }
            else if(b+c!=0)
            {
                 ar[2]=a;
               ar[1]=a;
               ar[0]=-(b+c);
            }
            else
            {
                 ar[2]=b;
               ar[1]=-(a+c);
               ar[0]=b;
            }
            System.out.print(ar[0]+"" ""+ar[1]+"" ""+ar[2]+"" "");
           for(int i=3;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           } 
            System.out.println();
        }
          //  System.out.println(ans[n-1]+ "" x""+ans[n-2]+"" x""+ans[n-3]);
           
          else
          {
              for(int i=0;i<(n);i=i+2)
           {
               System.out.print((-ar[i+1])+"" ""+ar[i]+"" "");
           }  
            System.out.println();
          }
          
           
        
    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		   int ar[]=new int[n];
		   for(int i=0;i<n;i++)
		   ar[i]=sc.nextInt();
		   solve(ar,n);
		}
	}
}
",1,Plagiarised
764484c3,9028caf7,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Armchairs
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		
		int n = sc.nextInt();
		Vector<Integer> a = new Vector();
		Vector<Integer> b = new Vector();
		    
		for (int i=0; i<n; ++i){
		    int input = sc.nextInt();
		    if(input==1) a.add(i);
		    else b.add(i);
		}
		
		n = a.size();
		int m = b.size();
		
		if(n==0) out.print(0);
		else{
		    int [][]dp = new int [n][m];
    		for (int i=0; i<n; ++i) for (int j=0; j<m; ++j) dp[i][j] = 25000000;
    		dp[0][0] = Math.abs(a.get(0) - b.get(0));
    		for (int i=0; i<n; ++i) for (int j=1; j<m; ++j){
    		    if(i==0) dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)),dp[i][j-1]);
    		    else dp[i][j] = Math.min(Math.abs(a.get(i) - b.get(j)) + dp[i-1][j-1],dp[i][j-1]);
    		}
    		out.print(dp[n-1][m-1]);
		}
		
		out.close();
	}
	
	/*Methods*/
    
    
    
    
    
}
","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();
    }
    
}
",0,Non-plagiarised
14b0fb8e,d221162a,"import java.io.*;

import java.util.*;
 public class Solution {
	 
	static long res;
	public static void main(String[] args) throws Exception
    {
		FastReader fr=new FastReader();
        int n=fr.nextInt();
        ArrayList<Integer> oc=new ArrayList<>();
        ArrayList<Integer> em=new ArrayList<>();
        res=Long.MAX_VALUE;
        for(int i=0;i<n;i++) {
        	int v=fr.nextInt();
        	if(v==1)
        		oc.add(i);
        	else
        		em.add(i);
        }
        Collections.sort(oc);
        Collections.sort(em);
        long dp[][]=new long[5001][5001];
        for(int i=0;i<dp.length;i++) {
        	for(int j=0;j<dp[i].length;j++) {
        		dp[i][j]=-1;
        	}
        }
        System.out.println(getMin(oc,em,0,0,dp));
        
        
		
    }
	public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
	   if(idx==oc.size())
		   return 0;
		long available=em.size()-j;
		long req=oc.size()-idx;
		if(available<req)
			return Integer.MAX_VALUE;
		if(dp[idx][j]!=-1)
			return dp[idx][j];
		
		long ch1=getMin(oc,em,idx,j+1,dp);
		long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
		
		return dp[idx][j]=Math.min(ch1,ch2);
		
	}
	
		
	
	 

	
	 
	 
	 
	 
	 
	 
	 
	
		
	 
	 
	 
	 
	 
	
	 
	 
	
	 
	 
            	  
             
             
    }


	
	 
	
	

	 
 
  


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

public class Main2 {
	
	static long mod = 998244353;
//	static Scanner sc = new Scanner(System.in);
	static FastReader sc = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);
	public static void main (String[] args) {
		int t = 1;
//    	t = sc.nextInt();
	    z : while(t-->0) {
	    	int n = sc.nextInt();
	    	int a[] = new int[n];
	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
	    	List<Integer> a1 = new ArrayList<>();
	    	ArrayList<Integer> a2 = new ArrayList<>();
	    	for (int i = 0; i < n; i++) {
	    		if(a[i] == 0) a1.add(i);
	    		else a2.add(i);
			}
	    	long dp[][] = new long[n+1][n+1];
	    	for (int i = 0; i <= n; i++) {
	    		Arrays.fill(dp[i],-1);
			}
	    	out.write(find(0,0,a1,a2,dp)+""\n"");
	    }
		out.close();
	}
	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
		if(j == a2.size()) return 0;
		
		int req = a2.size()-j;
		int ava = a1.size()-i;
		
		if(ava<req) return Integer.MAX_VALUE/2;
		
		if(dp[i][j] != -1) return dp[i][j];
		
		long ans1 = find(i+1,j,a1,a2,dp);
		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
		
		return dp[i][j] = Math.min(ans1, ans2);
	}
}
",1,Plagiarised
10584086,f229aa7f,"import java.util.*;
import java.io.*;

public class _1615_C {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int t = Integer.parseInt(in.readLine());
        while(t-- > 0) {
            int n = Integer.parseInt(in.readLine());
            String a = in.readLine();
            String b = in.readLine();
            int x = 0;
            int y = 0;
            int match = 0;
            for(int i = 0; i < n; i++) {
                if(a.charAt(i) == '1') {
                    x++;
                }
                if(b.charAt(i) == '1') {
                    y++;
                }
                if(a.charAt(i) == b.charAt(i)) {
                    match++;
                }
            }
            if(x != y && n - x + 1 != y) {
                out.println(-1);
            }else {
                int moves = Integer.MAX_VALUE;
                if(x == y) {
                    int mismatch = n - match;
                    moves = Math.min(moves, mismatch);
                }
                if(n - x + 1 == y) {
                    moves = Math.min(moves, match);
                }
                out.println(moves);
            }
        }
        in.close();
        out.close();
    }
}
","import java.util.*;
import java.io.*;
import java.math.*;

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

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

	

	

	

}
",0,Non-plagiarised
cc9230d3,ec558d69,"import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

public class C {


    static int[][] lr = new int[2][(int)2e5+10];
    static long[][] dp = new long[2][(int)2e5+10];
    static ArrayList<ArrayList<Integer>> g;
    public static void main(String[] args) {
        
        FastReader fr = new FastReader();
        PrintWriter out = new PrintWriter(System.out, true);
        int cases = fr.nextInt();
        for(int c = 0; c < cases; c++) {
            int nodes = fr.nextInt();
            g = new ArrayList<ArrayList<Integer>>();
            
            for(int i = 1; i <= nodes; i++) {
                lr[0][i] = fr.nextInt();
                lr[1][i] = fr.nextInt();
            }
            for(int i = 0; i <= nodes; i++) {
                g.add(new ArrayList<Integer>());
            }

            for(int i = 0; i < nodes-1; i++) {
                int f = fr.nextInt();
                int t = fr.nextInt();
                g.get(f).add(t);
                g.get(t).add(f);
            }
            DFS(1, -1);
            out.write(Math.max(dp[0][1], dp[1][1]) + ""\n"");

        }
        out.close();
    }

    static void DFS(int v, int p) {
        dp[0][v] = dp[1][v] = 0;
        for(Integer u : g.get(v)) {
            if (u == p) continue;
            DFS(u, v);
            dp[0][v] += Math.max(Math.abs(lr[0][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[0][v] - lr[0][u]));
            dp[1][v] += Math.max(Math.abs(lr[1][v] - lr[1][u]) + dp[1][u], dp[0][u] + Math.abs(lr[1][v] - lr[0][u]));
        }
    }

    
}
","import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Main 
{
    static int N=(int)2e5+10;
    static int[][] A=new int[2][N];
    static long[][] dp=new long[2][N];
    static ArrayList<ArrayList<Integer>> links=new ArrayList<>(N);
    static {
        for (int i=0;i<N;i++)
            links.add(new ArrayList<>());
    }
    static void dfs(int v,int p) 
    {
        dp[0][v]=dp[1][v]=0;
        for (Integer link :links.get(v))
        {
            if (link==p) continue;
            dfs(link,v);
            dp[0][v]+=Math.max(Math.abs(A[0][v]-A[0][link])+dp[0][link],Math.abs(A[0][v]-A[1][link])+dp[1][link]);
            dp[1][v]+=Math.max(Math.abs(A[1][v]-A[0][link])+dp[0][link],Math.abs(A[1][v]-A[1][link])+dp[1][link]);
        }
    }

	public static void main (String[] args) throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(br.readLine()),n,i;
		while (t-->0)
		{
		    n=Integer.parseInt(br.readLine());
		    for (i=1;i<=n;i++)
		    {
		        String[] in=br.readLine().split("" "");
		        A[0][i]=Integer.parseInt(in[0]);
		        A[1][i]=Integer.parseInt(in[1]);
		        links.set(i,new ArrayList<>());
		    }
		    for (i=1;i<n;i++)
		    {
		        String[] in=br.readLine().split("" "");
		        int a=Integer.parseInt(in[0]);
		        int b=Integer.parseInt(in[1]);
		        links.get(a).add(b);
		        links.get(b).add(a);
		    }
		    dfs(1,-1);
		    System.out.println(Math.max(dp[0][1],dp[1][1]));
		}
	}
}
",1,Plagiarised
3368f340,402aff07,"import java.io.*;
import java.util.*;

public class Menorah {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();
        StringBuilder sb = new StringBuilder();
        while (t-->0){
            int n = sc.nextInt();
            char[] a = sc.next().toCharArray();
            char[] b = sc.next().toCharArray();

            int a1=0, b1=0;
            for(int i=0;i<n;i++){
                if(a[i]=='1')
                    a1++;
                if(b[i]=='1')
                    b1++;
            }

            int min = 100000000;

            if(a1==b1){
                int c = 0;
                for(int i=0;i<n;i++){
                    if(a[i]!=b[i])
                        c++;
                }

                min = Math.min(min, c);
            }

            if(b1==(n-a1+1)){
                int ind = -1;
                for(int i=0;i<n;i++){
                    if(a[i]==b[i] && a[i]=='1'){
                        ind = i;
                        break;
                    }
                }

                int c = 0;
                for(int i=0;i<n;i++){
                    if(i==ind)
                        continue;

                    if(a[i]==b[i])
                        c++;
                }

                min = Math.min(min, c + 1);
            }

            if(min == 100000000)
                sb.append(""-1\n"");
            else sb.append(min).append(""\n"");
        }

        System.out.println(sb);

        sc.close();
    }
}
","import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t-- > 0){
            int n = s.nextInt();
            String a = s.next();
            String b = s.next();
            int a1 = 0, b1 = 0;
            for (char c: a.toCharArray()){
                if (c == '1') a1++;
            }
            for (char c: b.toCharArray()){
                if (c == '1') b1++;
            }
            int ans = Integer.MAX_VALUE;
            int res = 0;
            for (int i = 0; i < n; i++) {
                if (a.charAt(i) != b.charAt(i)) res++;
            }
            if (a1 == b1) ans = Math.min(ans, res);
            if (b1 == n-a1+1) ans = Math.min(ans, n-res);
            if (ans == Integer.MAX_VALUE){
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
    }
}
",0,Non-plagiarised
b8b08542,d783d815,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.HashSet;

import static java.lang.System.out;
import static java.util.stream.Collectors.joining;


public class C {
  static FastScanner sc = new FastScanner(System.in);

  public static void main(String[] args) {
    try (PrintWriter out = new PrintWriter(System.out)) {
      int T = sc.nextInt();
      for (int tt = 1; tt <= T; tt++) {
        int n = sc.nextInt();
        String[] strings = new String[n];
        PriorityQueue<Pair>[] frequencies = new PriorityQueue[5];
        for (int i = 0; i < 5; i++)
          frequencies[i] = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
          strings[i] = sc.next();
          int[] freq = new int[5];
          for (char c : strings[i].toCharArray())
            freq[c - 'a']++;
          for (int j = 0; j < 5; j++) {
            frequencies[j].add(new Pair(freq[j], strings[i].length()));
          }
        }
        int ans = 0;
        for (PriorityQueue<Pair> pq : frequencies) {
          long curlen = 0;
          long curfreq = 0;
          int cnt = 0;
          while (!pq.isEmpty()) {
            Pair pair = pq.remove();
            curfreq += pair.freq;
            curlen += pair.len;
            if (curfreq >= curlen / 2 + 1) {
              cnt++;
            } else {
              break;
            }
          }
          ans = Math.max(ans, cnt);
        }
        System.out.println(ans);
      }
    }

  }

  static class Pair implements Comparable<Pair> {
    int freq, len;

    public Pair(int freq, int len) {
      this.freq = freq;
      this.len = len;
    }

    

    
  }
  /*
1  
5
cbdca
d
a
d
eb
   */

  
}
","import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.HashSet;

import static java.lang.System.out;
import static java.util.stream.Collectors.joining;


public class C {
  static FastScanner sc = new FastScanner(System.in);

  public static void main(String[] args) {
    try (PrintWriter out = new PrintWriter(System.out)) {
      int T = sc.nextInt();
      for (int tt = 1; tt <= T; tt++) {
        int n = sc.nextInt();
        String[] strings = new String[n];
        PriorityQueue<Pair>[] frequencies = new PriorityQueue[5];
        for (int i = 0; i < 5; i++)
          frequencies[i] = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
          strings[i] = sc.next();
          int[] freq = new int[5];
          for (char c : strings[i].toCharArray())
            freq[c - 'a']++;
          for (int j = 0; j < 5; j++) {
            //if (freq[j] > 0)
            frequencies[j].add(new Pair(freq[j], strings[i].length()));
          }
        }
      /*  for (int i = 0; i < 5; i++) {
          while (!frequencies[i].isEmpty())
            System.out.print(frequencies[i].remove() + "", "");
          System.out.println();
        }*/

        int ans = 0;
        for (PriorityQueue<Pair> pq : frequencies) {
          long curlen = 0;
          long curfreq = 0;
          int cnt = 0;
          while (!pq.isEmpty()) {
            Pair pair = pq.remove();
            curfreq += pair.freq;
            curlen += pair.len;
            if (curfreq >= curlen / 2 + 1) {
              cnt++;
            } else {
              break;
            }
          }
          ans = Math.max(ans, cnt);
        }
        System.out.println(ans);
      }
    }

  }

  static class Pair implements Comparable<Pair> {
    int freq, len;

    public Pair(int freq, int len) {
      this.freq = freq;
      this.len = len;
    }

    

    
  }
  /*
1  
5
cbdca
d
a
d
eb
   */

  
}
",1,Plagiarised
98950986,b9595381,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class ReverseString {




    static class pair implements Comparable<pair>{

        String s;
        int contribution;
        pair(String s , int contribution){
            this.s = s;
            this.contribution = contribution;
        }



        


        

        




    }


    static int factorOfLetter(String s , char c){

        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i)==c)sum++;
        }
        int rem = Math.abs(sum-s.length());

        return sum-rem;
    }



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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

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


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

            int max = Integer.MIN_VALUE;

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



            for (int i = 0; i < 5; i++) {
                int word = 0;
                ArrayList<pair> tmp = new ArrayList<>();
                for (int j = 0; j < arr.length; j++) {

                    tmp.add(new pair(arr[j] , factorOfLetter(arr[j] , (char)(i+97))));

                }

                Collections.sort(tmp);
                //System.out.println(tmp);
                int acc = 0;
                for (int j = tmp.size()-1; j >=0 ; j--) {

                    acc += tmp.get(j).contribution;
                    if (acc<=0)break;
                    else word++;

                }

                max = Math.max(max , word);
            }


            System.out.println(max);









        }


    }



}
","import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
    
static int dest1;
static int dest2;
public static void main(String args[]){
       	FastScanner in = new FastScanner();
		int test=in.nextInt();
                while(test-->0){
                    int n=in.nextInt();
                    int count[][]=new int[n][5];
                    int total[]=new int[n];
                    String words[]=new String[n];
                    for(int i=0;i<n;i++){
                        words[i]=in.next();
                        for(int j=0;j<words[i].length();j++)
                            count[i][words[i].charAt(j)-'a']++;
                        
                        total[i]=words[i].length();
                    }
                    int max=Integer.MIN_VALUE;
                   for(int i=0;i<5;i++){
                       
                      Integer ans[]=new Integer[n];
                      for(int j=0;j<n;j++){
                          ans[j]=count[j][i]-(total[j]-count[j][i]);
                      }
                      Arrays.sort(ans,Collections.reverseOrder());
                      int j=0;
                      int r=0;
                      while(j<n && r+ans[j]>0){
                          r+=ans[j];
                          j++;
                      }
                      max=Math.max(j,max);
                      
                   }
                   System.out.println(max);
                   
                    
                }
}

       



}


",0,Non-plagiarised
ac180326,b728ba1d,"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;
		}

		

		

	}

	

	
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;


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

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

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

        

        

        

    }

    
}
",0,Non-plagiarised
51d857bc,c392efe7,"import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Round659 {

	static int rec = 0;
	static int X[] = { -1, 0, 0, 1 };
	static int Y[] = { 0, -1, 1, 0 };
	static long mod = 1000000007;
	static int last=0;
	static int maxDepth=0;
	

	

	

	

	

	public static List<Integer>[] initAdjacency(int n, int e, Reader scan, boolean type) throws IOException {

		List<Integer> adj[] = new ArrayList[n + 1];

		for (int i = 0; i < e; i++) {
			int u = scan.nextInt();
			int v = scan.nextInt();

			if (adj[u] == null)
				adj[u] = new ArrayList<>();
			if (type && adj[v] == null)
				adj[v] = new ArrayList<>();

			adj[u].add(v);

			if (type)
				adj[v].add(u);

		}

		return adj;
	}

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

		Reader scan = new Reader();
//		Scanner scan = new Scanner(System.in);

		int t = scan.nextInt();
		while (t-- > 0) {
			
			D(scan);
		}

	}
	
	
	public static void D(Reader scan) throws IOException {
		
		int n=scan.nextInt();
		int a=scan.nextInt();
		int b=scan.nextInt();
		int da=scan.nextInt();
		int db=scan.nextInt();
		
		List<Integer> adj[]=initAdjacency(n, n-1, scan, true);
		
		int d= dist(a, 0, adj, b);
		
		if(d<=da) {
			System.out.println(""Alice"");
			return;
		}
		
		if(db<=2*da) {
			System.out.println(""Alice"");
			return;
		}
		
		MyPair far1= farthest(1, 0, adj);
		MyPair far2=farthest(far1.weight, 0, adj);
		
		int diameter= far2.value-1;
		
		
		if(diameter<=2*da) {
			System.out.println(""Alice"");
		}else {
			System.out.println(""Bob"");
		}
		
		
//		int val=d-2*a;
//		
//		if(val>0) {
//			System.out.println(""Bob"");
//			return;
//		}
//		
//		int dep=0;
//		for(Integer x: adj[a]) {
//			if(x==last) continue;
//			
//			dep=Math.max(getDepth(x, a, adj), dep);
//		}
//		
//		if(dep>=val) {
//			System.out.println(""Bob"");
//		}else {
//			System.out.println(""Alice"");
//		}
		
		
		
	}
	
	public static MyPair farthest(int i, int parent, List<Integer> adj[]) {
		
		int dist=0;
		int node= i;
		
		for(Integer x: adj[i]) {
			if(x==parent) continue;
			
			MyPair recAns= farthest(x, i, adj);
			if(recAns.value>dist) {
				dist= recAns.value;
				node= recAns.weight;
			}
		}
		
		return new MyPair(dist+1, node);
		
	}
	
	
	
	public static int dist(int i, int parent, List<Integer> adj[], int target) {
		
		if(i==target) return 0;
		
		for(Integer x: adj[i]) {
			if(x==parent) continue;
			
			int recAns= dist(x, i, adj, target);
			if(recAns!=-1) {
				last=x;
				return recAns+1;
			}
		}
		
		return -1;
		
		
	}
	
	
	
	
	
	
	

}

class MyPair {

	int value;
	int weight;

	public MyPair(int value, int w) {
		this.value = value;
		weight = w;
	}

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

/**
 *
 * @Har_Har_Mahadev
 */

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

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

	public static void process() throws IOException {

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

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

	

	static FastScanner sc;
	static PrintWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = true;
		if (oj) {
			sc = new FastScanner();
			out = new PrintWriter(System.out);
		} else {
			sc = new FastScanner(100);
			out = new PrintWriter(""output.txt"");
		}
		int t = 1;
		t = sc.nextInt();
		int TTT = 1;
		while (t-- > 0) {
			//			google(TTT++);
			process();
		}
		out.flush();
		out.close();
	}

	static class Pair implements Comparable<Pair> {
		int x, y;

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

		

		//		 @Override
		//		    public boolean equals(Object o) {
		//		        if (this == o) return true;
		//		        if (!(o instanceof Pair)) return false;
		//		        Pair key = (Pair) o;
		//		        return x == key.x && y == key.y;
		//		    }
		//		 
		//		    @Override
		//		    public int hashCode() {
		//		        int result = x;
		//		        result = 31 * result + y;
		//		        return result;
		//		    }
	}

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

	

	

	

	

	

	

	

	

	

	

	

	

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

	

	

	

	

	

}
",0,Non-plagiarised
5aebbb1b,e647bef7,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Learning {
    static LinkedList<Integer>[] adj;

    public static void main(String[] args) throws Exception {
        FastInput in = new FastInput();
        StringBuilder sb = new StringBuilder();
        int t = in.nextInt();
        while (t-- > 0) {
            int n = in.nextInt();
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            int da = in.nextInt();
            int db = in.nextInt();
            adj = new LinkedList[n];
            for (int i = 0; i < n; i++) {
                adj[i] = new LinkedList<>();
            }
            for (int i = 0; i < n - 1; i++) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            boolean f = solve(n, a, b, da, db);
            if (f) {
                sb.append(""Bob"");
            } else {
                sb.append(""Alice"");

            }
            sb.append(""\n"");
        }
        System.out.println(sb.toString());
    }

    private static boolean solve(int n, int a, int b, int da, int db) {
        if (db <= da * 2) {
            return false;
        }
        Queue<Integer> que = new LinkedList<>();
        que.add(a);
        int[] dist = new int[n];
        Arrays.fill(dist, -1);
        dist[a] = 0;
        while (!que.isEmpty()) {
            int t = que.poll();
            for (int i : adj[t]) {
                if (dist[i] == -1) {
                    que.add(i);
                    dist[i] = dist[t] + 1;
                }
            }
        }
        if (dist[b] <= da) {
            return false;
        }
        int maxPath = 0;
        for (int i = 0; i < n; i++) {
            maxPath = Math.max(maxPath, dfs(i, new boolean[n]));
        }
        if (2 * da >= maxPath-1) {
            return false;
        }
        return true;
    }

    private static int dfs(int i, boolean[] vis) {
        vis[i] = true;
        int max = 0;
        for (int v : adj[i]) {
            if (!vis[v]) {
                max = Math.max(dfs(v, vis), max);
            }
        }
        return max + 1;
    }

    
}



","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
927384f2,b2bae06a,"import java.util.*;
import java.io.*;

public class Main{
	      
	
	public static void main(String[] args) throws IOException{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int n = pint(in);
		Stack<Integer> min = new Stack<Integer>();
		Stack<Integer> max = new Stack<Integer>();
		
		int[] a = new int[n];
		int[] dp = new int[n];
		StringTokenizer st = new StringTokenizer(in.readLine());
		a[0] = pint(st);
		min.add(0);
		max.add(0);
		for(int i = 1; i < n; i++) {
			a[i] = pint(st);
			int h = dp[i - 1] + 1;
			while(!max.isEmpty() && a[i] > a[max.peek()]) {
				int k = a[max.peek()];
				h = Math.min(h, dp[max.pop()] + 1);
				while(!max.isEmpty() && a[max.peek()] == k) {max.pop();}
			}
			if(!max.isEmpty()) {
				h = Math.min(h, dp[max.peek()] + 1);
			}
			while(!min.isEmpty() && a[i] < a[min.peek()]) {
				int k = a[min.peek()];
				h = Math.min(h, dp[min.pop()] + 1);
				while(!min.isEmpty() && a[min.peek()] == k) {min.pop();}
			}
			if(!min.isEmpty()) {
				h = Math.min(h, dp[min.peek()] + 1);
			}
			dp[i] = h;
			min.add(i);
			max.add(i);
		}
		System.out.println(dp[n - 1]);
	}
	
    static int pint(BufferedReader in) throws IOException {return Integer.parseInt(in.readLine());}
    static int pint(StringTokenizer st) {return Integer.parseInt(st.nextToken());}
}
","import java.util.*;
    import java.io.*;
    public class D{
        
        
         
        static int mod = (int)(1e9+7);
        

        public static void main(String[] args) {
            InputReader in = new InputReader(System.in);
            OutputWriter out = new OutputWriter(System.out);
            int n = in.nextInt();
            int[] arr = in.nextIntArray(n);
            Stack<Integer> min = new Stack<>();
            Stack<Integer> max = new Stack<>();
            int[] dp = new int[n];
            // Arrays.fill(dp,(int)1e9);
            dp[0] = 0;
            min.push(0);
            max.push(0);
            for(int i=1;i<n;i++)
            {
                int h=dp[i-1]+1;
                while(!max.isEmpty() && arr[i]>arr[max.peek()])
                {
                    int x = arr[max.peek()];
                    h = Math.min(h,1+dp[max.pop()]);
                    while(!max.isEmpty() && arr[max.peek()]==x)
                    {
                        max.pop();
                    }
                }
                if(!max.isEmpty())
                {
                    h = Math.min(h,1+dp[max.peek()]);
                }
                while(!min.isEmpty() && arr[i]<arr[min.peek()])
                {
                    int x = arr[min.peek()];
                    h = Math.min(h,1+dp[min.pop()]);
                    while(!min.isEmpty() && arr[min.peek()]==x)
                    {
                        min.pop();
                    }
                }
                if(!min.isEmpty())
                {
                    h = Math.min(h,1+dp[min.peek()]);
                }
                dp[i] = h;
                min.push(i);
                max.push(i);
            }
            out.printLine(dp[n-1]);
            out.flush();
            out.close();
        }
    }
",1,Plagiarised
976fe834,da54dec3,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;
/*
-> Give your 100%, that's it!
-> Feynman Rule To Solve Any Problem:
    1. Read the problem.
    2. Think About It.
    3. Solve it!
*/

public class Template {
    
	static int mod = 1000000007;

	public static void main(String[] args){
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int yo = sc.nextInt();
        while (yo-- > 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[][] arr = new int[n][m];
            for(int i = 0; i < n; i++){
                String s = sc.next();
                for(int j = 0; j < m; j++){
                    arr[i][j] = s.charAt(j)-'0';
                }
            }
            
            List<String> list = new ArrayList<>();
            for(int i = 0; i < n-1; i++){
                for(int j = 0; j < m-1; j++){
                    check(list,i,j,n,m,arr);
                }
            }
            
            // for(int i = 0; i < n; i++){
            //     for(int j = 0; j < m; j++){
            //         out.print(arr[i][j] + "" "");
            //     }
            //     out.println();
            // }
            
            out.println(list.size()/3);
            for(int i = 0; i < list.size(); i+=3){
                out.println(list.get(i) + "" "" + list.get(i+1) + "" "" + list.get(i+2));
            }
            // out.println(list.size());
            // for(int i = 0; i < list.size(); i++){
            //     out.println(list.get(i));
            // }
        }
        out.close();    
	}
    
    static void check(List<String> list, int i, int j, int n, int m, int[][] arr){
        int[][] a = new int[2][2];
        a[0][0] = arr[i][j];
        a[0][1] = arr[i][j+1];
        a[1][0] = arr[i+1][j];
        a[1][1] = arr[i+1][j+1];
        
        int ones = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) ones++;
            }
        }
        
        if(ones == 0) return;
        
        if(ones == 1){
            ones(i,j,list,a);
            twos(i,j,list,a);
            threes(i,j,list,a);
        }
        else if(ones == 2){
            twos(i,j,list,a);
            threes(i,j,list,a);
        }
        else if(ones == 3){
            threes(i,j,list,a);
        }
        else if(ones == 4){
            fours(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            ones(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            twos(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
            threes(i,j,list,a);
            // for(int x = 0; x < 2; x++){
            //     for(int y = 0; y < 2; y++){
            //         out.print(a[x][y] + "" "");
            //     }
            //     out.println();
            // }
        }
        
        arr[i][j] = a[0][0];
        arr[i+1][j] = a[1][0];
        arr[i][j+1] = a[0][1];
        arr[i+1][j+1] = a[1][1];
    }
    
    public static void twos(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1 && count < 1) {
                    count++;
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
                else if(a[x][y] == 0){
                    list.add(get(x,y,i,j));
                    a[x][y] = 1;
                }
            }
        }
    }
    
    public static void threes(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) {
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static void fours(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1 && count < 3) {
                    count++;
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static void ones(int i, int j, List<String> list, int[][] a){
        int count = 0;
        for(int x = 0; x < 2; x++){
            for(int y = 0; y < 2; y++){
                if(a[x][y] == 1) {
                    a[x][y] = 0;
                    list.add(get(x,y,i,j));
                }
                else if(a[x][y] == 0 && count < 2){
                    a[x][y] = 1;
                    count++;
                    list.add(get(x,y,i,j));
                }
            }
        }
    }
    
    public static String get(int x, int y, int i, int j){
        if(x == 0 && y == 0) {
            return (i+1) + "" "" + (j+1);
        }
        else if(x == 0 && y == 1){
            return (i+1) + "" "" + (j+2);
        }
        else if(x == 1 && y == 0){
            return (i+2) + "" "" + (j+1);
        }
        else {
            return (i+2) + "" "" + (j+2);
        }
    }
    
   
    
    
    /*
         Random stuff to try when stuck:
            -if it's 2C then it's dp
            -for combo/probability problems, expand the given form we're interested in
            -make everything the same then build an answer (constructive, make everything 0 then do something)
            -something appears in parts of 2 --> model as graph
            -assume a greedy then try to show why it works
            -find way to simplify into one variable if multiple exist
            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
            -find lower and upper bounds on answer
            -figure out what ur trying to find and isolate it
            -see what observations you have and come up with more continuations
            -work backwards (in constructive, go from the goal to the start)
            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
            -draw something
            -simulate a process
            -dont implement something unless if ur fairly confident its correct
            -after 3 bad submissions move on to next problem if applicable
            -do something instead of nothing and stay organized
            -write stuff down
         Random stuff to check when wa:
            -if code is way too long/cancer then reassess
            -switched N/M
            -int overflow
            -switched variables
            -wrong MOD
            -hardcoded edge case incorrectly
         Random stuff to check when tle:
            -continue instead of break
            -condition in for/while loop bad
         Random stuff to check when rte:
            -switched N/M
            -long to int/int overflow
            -division by 0
            -edge case for empty list/data structure/N=1
      */

	

	

	

	

	

	

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
","import java.util.*;
import java.math.*;
public class Solution {
	final static int MOD = 1000000007;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int t = Integer.parseInt(in.next());
		for(int tt = 0; tt < t; tt++) {
			int n = Integer.parseInt(in.next());
			int m = Integer.parseInt(in.next());
			char[][] grid = new char[n][m];
			List<Integer> ans = new ArrayList<>();
			for(int i = 0; i < n; i++) {
				grid[i] = in.next().toCharArray();
			}
			int iii = 0;
			int jjj = 0;
			if(n % 2 != 0) {
				iii = 1;
				for(int j = 0; j + 1 < m; j++) {
					if(grid[0][j] == '1') {
						grid[0][j] = '0';
						grid[1][j] = (grid[1][j] == '1') ? '0' : '1';
						grid[1][j + 1] = (grid[1][j + 1] == '1') ? '0' : '1';
						ans.add(1); ans.add(j + 1);
						ans.add(2); ans.add(j + 1);
						ans.add(2); ans.add(j + 2);
					}
					if(grid[0][j + 1] == '1') {
						grid[0][j + 1] = '0';
						grid[1][j] = (grid[1][j] == '1') ? '0' : '1';
						grid[1][j + 1] = (grid[1][j + 1] == '1') ? '0' : '1';
						ans.add(1); ans.add(j + 2);
						ans.add(2); ans.add(j + 1);
						ans.add(2); ans.add(j + 2);
					}
				}
			}
			if(m % 2 != 0) {
				jjj = 1;
				for(int i = (n % 2 == 0) ? 0 : 1; i + 1 < n; i++) {
					if(grid[i][0] == '1') {
						grid[i][0] = '0';
						grid[i][1] = (grid[i][1] == '1') ? '0' : '1';
						grid[i + 1][1] = (grid[i + 1][1] == '1') ? '0' : '1';
						ans.add(i + 1); ans.add(1);
						ans.add(i + 1); ans.add(2);
						ans.add(i + 2); ans.add(2);
					}
					if(grid[i + 1][0] == '1') {
						grid[i + 1][0] = '0';
						grid[i][1] = (grid[i][1] == '1') ? '0' : '1';
						grid[i + 1][1] = (grid[i + 1][1] == '1') ? '0' : '1';
						ans.add(i + 2); ans.add(1);
						ans.add(i + 1); ans.add(2);
						ans.add(i + 2); ans.add(2);
					}
				}
			}
			for(int i = iii; i < n; i += 2) {
				for(int j = jjj; j < m; j += 2) {
					int cnt = count(grid, i, j);
					while(cnt > 0) {
						List<G> g = new ArrayList<>();
						for(int k = i; k < i + 2; k++) {
							for(int l = j; l < j + 2; l++) {
								g.add(new G(grid[k][l], k, l));
							}
						}
						Collections.sort(g);
						int l = 0;
						int r = 0;
						if(cnt == 1 || cnt == 3) {
							l = 1; r = 3;
						}else {
							l = 0; r = 2;
						}
						for(int k = l; k <= r; k++) {
							int ii = g.get(k).i;
							int jj = g.get(k).j;
							grid[ii][jj] = (grid[ii][jj] == '1') ? '0' : '1';
							ans.add(ii + 1);
							ans.add(jj + 1);
						}
						cnt = count(grid, i, j);
					}
				}
			}
			System.out.println(ans.size() / 6);
			for(int i = 0; i < ans.size(); i += 6) {
				for(int j = i; j < i + 6; j++) {
					System.out.print(ans.get(j) + "" "" );
				}
				System.out.println();
			}
		}
	}
	public static int count(char[][] grid, int i, int j) {
		int cnt = 0;
		for(int k = i; k < i + 2; k++) {
			for(int l = j; l < j + 2; l++) {
				if(grid[k][l] == '1') cnt += 1;
			}
		}
		return cnt;
	}
}
class G implements Comparable <G> {
	Character val;
	int i;
	int j;
	public G(char val, int i, int j) {
		this.val = val;
		this.i = i;
		this.j = j;
	}
	
}
",0,Non-plagiarised
e6a6e318,fadc1365,"import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class solution { 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(), k=s.nextInt();
			int[] a=s.readArray(k), temp=s.readArray(k);
			long[] ans=new long[n];
			Arrays.fill(ans, Integer.MAX_VALUE);
			for (int i=0; i<k; i++) {
				ans[a[i]-1]=temp[i];
			}
			for (int i=1; i<n; i++) {
				ans[i]=Math.min(ans[i],ans[i-1]+1);
			}
			for (int i=n-2; i>=0; i--) {
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for (int i=0; i<n; i++) {
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
    
    
    
    
    
    
    
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class a{ 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(),k=s.nextInt();
			int pos[]=s.readArray(k);
			int temp[]=s.readArray(k);
			long ans[]=new long[n];
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++){
				ans[pos[i]-1]=temp[i];
			}
			for(int i=1;i<n;i++){
				ans[i]=Math.min(ans[i-1]+1,ans[i]);
			}
			for(int i=n-2;i>=0;i--){
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for(int i=0;i<n;i++){
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
	
    
	
    
    
    
    
    
    
}
",1,Plagiarised
34aa6a45,dd5fd2a2,"import java.util.*;
import java.math.*;
import java.io.*; 
 public class B{
static int[] dx = new int[]{-1,0,1,0};
    static int[] dy = new int[]{0,1,0,-1};
    static FastReader scan=new FastReader();
   public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
  static ArrayList<Pair>es;
  static LinkedList<Integer>edges[];
  static Set<Pair>edges2[][];

   static boolean prime[];
         
     
    
    
      

  
   






    
      
  
    
   
       
    
   static int mid;
   

     
 
   



static int cnt=0;
static int count1[];
  
/*static int rec(int i)
{

}*/
static long arr[];
static int n;
static long res,tmpres;
static ArrayList<Pair>pairs;
static boolean vis[];
static long dp[][];
static long dfs(int x,long last,int prev)
{
  //  vis[x]=true;
   // System.out.println
    if(dp[x][prev]!=-1){
       // out.println(""FUCK"");
        return dp[x][prev];
    }
    long ch1=0,ch2=0,res=0;
    for(int v:edges[x])
    {
        if(!vis[v])
        {
            vis[v]=true;
          //  ch1+=

            //vis[v]=false;
            res+=Math.max((dfs(v,pairs.get(v).x,1)+Math.abs(pairs.get(v).x-last)),(dfs(v,pairs.get(v).y,2)+Math.abs(pairs.get(v).y-last)));
           // res+=Math.max(ch1,ch2);
            vis[v]=false;
        }
    }
    return dp[x][prev]=res;
}
public static void main(String[] args)  throws Exception 
{
    /*int xx=253;
    for(int i=1;i*i<=xx;i++)
    {
        if(xx%i==0)
        {
            System.out.println(i);
            System.out.println(xx/i);
        }
    }*/
//java.util.Scanner scan=new java.util.Scanner(new File(""mootube.in""));
// PrintWriter out = new PrintWriter (new FileWriter(""mootube.out""));
//scan=new FastReader(""skidesign.in"");
//out = new PrintWriter (""skidesign.out"");
//System.out.println(3^2);
//System.out.println(19%4);
   //StringBuilder news=new StringBuilder(""ab"");
   //news.deleteCharAt(1);
   //news.insert(0,'c');
   //news.deleteCharAt(0);
   //System.out.println(news);
   //System.out.println(can(2,15));
    //System.out.println(LCM(2,2));
  // System.out.println(31^15);
 //System.out.println("""");
   //System.out.println(824924296372176000L>(long)1e16);
int tt=1;
//rec(2020);
//System.out.println(Long.MAX_VALUE);
//System.out.println(Integer.MAX_VALUE);
//int st=scan.nextInt();
//System.out.println(calc(91));
//sieve(21000);

//SNWNSENSNNSWNNW

   // System.out.println(set.remove(new Pair(1,1)));
//System.out.println(count(""cccccccccccccccccccccccccooooooooooooooooooooooooodddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffforrrrrrrrrrrrrcesssssssssssss"",""codeforces""));
  //S0ystem.out.println(isPowerOfTwo(446265625L));
//System.out.println(""daaa"".compareTo(""bccc""));
//System.out.println(2999000999L>1999982505L);
//System.out.println(""?bac?bac??a?a?a?abac????abacab?ca?a"".length());
//StringBuilder s=new StringBuilder("""");
//tt=scan.nextInt();
//String ok=""ABDC"";
//System.out.println(ok.substring(2));
//System.out.println(2000000000/2);
tt=scan.nextInt();
//System.out.println(LCM(4,6));
//System.out.println(isprime(23335));
//int T=1;
  outer:while(tt-->0)
 {
int n=scan.nextInt();
pairs=new ArrayList<Pair>();
edges=new LinkedList[n];
for(int i=0;i<n;i++)
edges[i]=new LinkedList();
for(int i=0;i<n;i++)
{
    long l=scan.nextLong(),r=scan.nextLong();
    pairs.add(new Pair(l,r));
}
for(int i=0;i<n-1;i++)
{
    int a=scan.nextInt()-1;
    int b=scan.nextInt()-1;
    edges[a].add(b);
    edges[b].add(a);
}
vis=new boolean[n];
vis[0]=true;
dp=new long[n][3];
for(long K[]:dp)
    Arrays.fill(K,-1);
long x=dfs(0,pairs.get(0).x,0);
vis=new boolean[n];
vis[0]=true;
dp=new long[n][3];
for(long K[]:dp)
    Arrays.fill(K,-1);
out.println(Math.max(x,dfs(0,pairs.get(0).y,0)));

}
out.close();

}





 


 
public static class Pair implements Comparable<Pair>{
         long x;
         long y;
         long ab;
        
        long z;
        public Pair(){}
        public Pair(long x1, long y1,long z) {
            x=x1;
            y=y1;
            this.z=z;
        }
        public Pair(long x1, long y1) {
            x=x1;
            y=y1;
            this.ab=x+y;
        
        }
        
        
        
        
}

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

public class A {
	static FastReader f = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);

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

	static Node[] nodes;
	static long[][] dp;
	static void solve() {
		int n = f.nextInt();

		nodes = new Node[n];

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

		for(int i=1;i<n;i++) {
			int u = f.nextInt() - 1;
			int v = f.nextInt() - 1;
			nodes[u].adj.add(v);
			nodes[v].adj.add(u);
		}


		dp = new long[n][2];
		for(int i=0;i<n;i++) {
			for(int j=0;j<2;j++) {
				dp[i][j] = -1;
			}
		}


		System.out.println(Math.max(rek(-1, 0,false),rek(-1, 0,true)));


	}

	static long rek(int from, int now, boolean left) { //TODO: DP
		if(dp[now][left?0:1] != -1) {
			return dp[now][left?0:1];
		}

		long ret = 0;

		for(int i : nodes[now].adj) {
			if(i == from) {
				continue;
			}
			long l = rek(now,i,false) + Math.abs(nodes[i].right - (left ? nodes[now].left : nodes[now].right));
			long r = rek(now,i,true) + Math.abs(nodes[i].left - (left ? nodes[now].left : nodes[now].right));
			
			ret += Math.max(l, r);
		}

		dp[now][left?0:1] = ret;
		return ret;
	}

	static class Node {
		int left, right;
		ArrayList<Integer> adj = new ArrayList<>();

		Node(int left, int right) {
			this.left = left;
			this.right = right;
		}
	}


	

	
}
",0,Non-plagiarised
ae716b8f,f1a42a42,"import java.io.*;
import java.util.*;

public class DisCenJump {

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

		DisCenJump obj = new DisCenJump();

		obj.doStuff();

	}

	int bslo(int v) {
		int l = 0, r = lo.size()-1;
		while (l < r) {
			int m = (l+r)/2;
			if (v <= lo.get(m)[0]) {
				if (v > lo.get(m+1)[0]) return m;
				l = m+1;
			} else r = m;
		}
		return l;
	}
	int bshi(int v) {
		int l = 0, r = hi.size()-1;
		while (l < r) {
			int m = (l+r)/2;
			if (v >= hi.get(m)[0]) {
				if (v < hi.get(m+1)[0]) return m;
				l = m+1;
			} else r = m;
		}
		return l;
	}
	
	int[] nums;
	int[] dp;
	ArrayList<int[]> lo, hi;
	private void doStuff() throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		nums = new int[Integer.parseInt(br.readLine())];
		StringTokenizer st = new StringTokenizer(br.readLine());
		for (int i = 0; i < nums.length; i++) {
			nums[i] = Integer.parseInt(st.nextToken());
		}
		br.close();
		
		dp = new int[nums.length];
		lo = new ArrayList<>();
		hi = new ArrayList<>();
		lo.add(new int[] {nums[nums.length-1], nums.length-1});
		hi.add(new int[] {nums[nums.length-1], nums.length-1});
		for (int i = dp.length-2; i >= 0; i--) {
			dp[i] = dp[i+1]+1;
			int pos = bslo(nums[i]);
			for (int j = pos; j < lo.size(); j++) {
				dp[i] = Math.min(dp[i], dp[lo.get(j)[1]]+1);
			}
			pos = bshi(nums[i]);
			for (int j = pos; j < hi.size(); j++) {
				dp[i] = Math.min(dp[i], dp[hi.get(j)[1]]+1);
			}
			
			while (lo.size() > 0 && lo.get(lo.size()-1)[0] <= nums[i]) {
				lo.remove(lo.size()-1);
			}
			lo.add(new int[] {nums[i], i});
			
			while (hi.size() > 0 && hi.get(hi.size()-1)[0] >= nums[i]) {
				hi.remove(hi.size()-1);
			}
			hi.add(new int[] {nums[i], i});
		}
		
		System.out.println(dp[0]);

	}

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

public class Jumps {

    public static void main(String[] args) {

        FastScanner sc = new FastScanner();
        int n = sc.nextInt();
        int ar[] = sc.nextIntArray(n);
        // 1 4 6 9 3 2
        int dp[] = new int[n];
        int nextLower[] = new int[n];
        int nextHigher[] = new int[n];
        int nextLowerE[] = new int[n];
        int nextHigherE[] = new int[n];
        Arrays.fill(nextHigher, n);
        Arrays.fill(nextLower, n);
        Arrays.fill(nextHigherE, n);
        Arrays.fill(nextLowerE, n);
        dp[n-1] = 0;
        Stack<Integer> stack = new Stack<>();

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

            while(stack.size() > 0 && ar[stack.peek()] < ar[i])
                stack.pop();
            if(stack.size() > 0)
                nextHigherE[i] = stack.peek();
            stack.push(i);
        }
        stack.clear();

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

            while(stack.size() > 0 && ar[stack.peek()] <= ar[i])
                stack.pop();
            if(stack.size() > 0)
                nextHigher[i] = stack.peek();
            stack.push(i);
        }
        stack.clear();

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

            while(stack.size() > 0 && ar[stack.peek()] > ar[i])
                stack.pop();
            if(stack.size() > 0)
                nextLowerE[i] = stack.peek();
            stack.push(i);
        }
        stack.clear();

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

            while(stack.size() > 0 && ar[stack.peek()] >= ar[i])
                stack.pop();
            if(stack.size() > 0)
                nextLower[i] = stack.peek();
            stack.push(i);
        }

        for(int i = n-2; i >= 0; i--) {

            int maxIndex = Math.max(nextHigherE[i], nextLowerE[i]);
            int ans = dp[i+1];
            if(maxIndex < n) {
                ans = Math.min(ans, dp[maxIndex]);
            }

            if(nextHigherE[i] < nextLowerE[i]) {
                int cur = nextHigherE[i];
                while(cur < maxIndex) {
                    ans = Math.min(ans, dp[cur]);
                    cur = nextLower[cur];
                }
            } else {
                int cur = nextLowerE[i];
                while(cur < maxIndex) {
                    ans = Math.min(ans, dp[cur]);
                    cur = nextHigher[cur];
                }
            }
            dp[i] = ans + 1;
        }
        System.out.println(dp[0]);
    }


    

    

    
    
    
    
    
    

    

    


    

    

    


    
}
",0,Non-plagiarised
9f354c5c,cb032314,"import java.util.*;

import java.io.*;
import java.math.*;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;



public class Solution {
	 
	  
	 
	  static long mod = (long)(1e9 + 7);
	 
	
	
	
	

	
	
	 
	 

	 
	   
	   
	 
	   
     
	      
	      
	      
	      
	      
	      
	      
	      
/************************************************ Query **************************************************************************************/	  
	 
/***************************************** 		Sparse Table	********************************************************/
	      
	      
	      
/********************************************************	Segement Tree	*****************************************************/
/**
	 	 static class SegmentTree{
			 long[] tree;
			 long[] arr;
			 int n;
			 SegmentTree(long[] arr){
				 this.n = arr.length;
				 tree = new long[4*n+1];
				 this.arr = arr;
				 buildTree(0, n-1, 1);
			 }
			 
			 
			  void buildTree(int s ,int e  ,int index ) {
					if(s == e) {
						tree[index] = arr[s];
						return;
					}
				
					int mid = (s+e)/2;
					
					buildTree( s,  mid, 2*index);
					buildTree( mid+1, e, 2*index+1);
					
					tree[index] = Math.min(tree[2*index] , tree[2*index+1]);
				}
			  
			 long query(int si ,int ei) {
				 return query(0 ,n-1 , si ,ei , 1   );
			 }
			 private long query( int ss ,int se ,int qs , int qe,int index) {
					
					if(ss>=qs && se<=qe) return tree[index];
					
					if(qe<ss || se<qs) return (long)(1e17);
					
					int mid = (ss + se)/2;
					long left = query( ss , mid , qs ,qe , 2*index);
					long right= query(mid + 1 , se , qs ,qe , 2*index+1);
					return Math.min(left, right);
				}
			 public void update(int index , int val) {
				 arr[index] = val;
				 for(long e:arr) System.out.print(e+"" "");
				 update(index , 0 , n-1 , 1);
			 }
			 private void update(int id ,int si , int ei , int index) {
				 if(id < si || id>ei) return;
				 if(si == ei ) { 
					 tree[index] = arr[id];
					 return;
				 }
				 if(si > ei) return;
				 int mid = (ei + si)/2;
					
					update( id,  si, mid , 2*index);
					update( id , mid+1, ei , 2*index+1);
					
					tree[index] = Math.min(tree[2*index] ,tree[2*index+1]);
			 }
			  
		 }
		 */

/* ***************************************************************************************************************************************************/	 
	 
//	      static MyScanner sc = new MyScanner(); // only in case of less memory
	      static Reader sc = new Reader();
	 static StringBuilder sb = new StringBuilder();
	 public static void main(String args[]) throws IOException {

		 int tc = 1;
		  tc = sc.nextInt();

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

//			 sb.append(""Case #"" + i + "": ""  );	// During KickStart && HackerCup
			 TEST_CASE();
			  
		 }
		 System.out.println(sb);
	 }

	 static void TEST_CASE() {
		int n = sc.nextInt();
		ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
		for(int i =0 ; i<n ; i++) adj.add(new ArrayList<>());
		int[] U = new int[n-1] , V = new int[n-1];
		for(int i = 0 ; i<n-1 ; i++) {
			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
			U[i] = u; V[i] = v;
			adj.get(u).add(v);
			adj.get(v).add(u);
		}
		int ind = -1;
		for(int i =0 ; i<n ; i++) {
			if(adj.get(i).size()>2) {
				sb.append(""-1\n"");
				return;
			}
			if(adj.get(i).size() == 1) {
				ind = i;
			}
		}
		Map<String , Integer> map = new HashMap<>();
		dfs(adj, ind, -1, true, map);
		for(int i =0 ; i<n-1 ; i++) {
		 int u = U[i];
		 int v = V[i];
		 if(map.containsKey(u+"" ""+v)) sb.append(map.get(u+"" ""+v)+"" "");
		 else sb.append(map.get(v+"" ""+u)+"" "");
		}
		sb.append(""\n"");
		
	 }
	 static void dfs(ArrayList<ArrayList<Integer>> adj ,int u , int p ,boolean eve ,Map<String , Integer> map ) {
		 if(eve) {
			 map.put(u+"" ""+p, 2);
		 }else {
			 map.put(u+"" ""+p, 3);
		 }
		 for(int v:adj.get(u)) {
			 if(v == p) continue;
			 eve = !eve;
			 dfs(adj, v, u, eve, map);
		 }
	 }
	}
","import java.io.*;
import java.util.*;

public class C {

    static FastScanner sc = new FastScanner();
    static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    static class pair{
        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        int x;
        int y;
        

        
    }
    static void solve(){
        int n = sc.nextInt();
        int[]degree = new int[n];
        List<Integer>[]grid = new List[n];
        for (int i = 0; i < n; i++) {
            grid[i] = new ArrayList();
        }
        List<pair>list = new ArrayList<>();
        for (int i = 0; i < n - 1; i++) {
            int x = sc.nextInt() - 1;
            int y = sc.nextInt() - 1;
            grid[x].add(y);
            grid[y].add(x);
            degree[x]++;
            degree[y]++;
            list.add(new pair(Math.min(x,y),Math.max(x,y)));
        }
        int begin = 0;
        for(int i = 0;i < degree.length;i++){
            if(degree[i] > 2){
                System.out.println(-1);
                return;
            }
            if(degree[i] == 1){
                begin = i;
            }
        }
        boolean[]used = new boolean[n];
        int[]p = new int[]{5,2,11,2};
        int idx = 0;
        HashMap<pair,Integer>map = new HashMap<>();
        while (!used[begin]){
            used[begin] = true;
            for(int next : grid[begin]){
                if(used[next])
                    continue;
                map.put(new pair(Math.min(begin,next),Math.max(begin,next)),p[idx % 4]);
                idx++;
                begin = next;
            }
        }
        StringBuilder bd = new StringBuilder();
        for(pair pp : list){
            bd.append(map.get(pp) + "" "");
        }
        System.out.println(bd.toString().trim());
    }

    public static void main(String[] args) {
        int n = sc.nextInt();
        for(int i = 0;i < n;i++){
            solve();
        }
    }

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int t=s.nextInt();
		while(t-->0){
			
			int n = s.nextInt();
			long[] aa =new long[n];
			for(int i=0;i<n;i++)
				aa[i]=s.nextLong();
 
			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
			
		}
	}

}
",0,Non-plagiarised
d2a4c1fb,dcdaf666,"import java.util.*;

public class CodeForcesRound {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int i = 0; i<t; i++)
            System.out.println(solve(sc));
        sc.close();
    }

    public static long solve(Scanner sc) {
        int n = sc.nextInt();
        long[] c = new long[n];
        long[] ps = new long[n];

        c[0] = sc.nextLong();
        c[1] = sc.nextLong();
        ps[0] = c[0];
        ps[1] = c[1];

        for (int i = 2; i<n; i++) {
            c[i] = sc.nextLong();
            ps[i] = ps[i-2] + c[i];
        }

        long res = Long.MAX_VALUE;
        long[] mins = new long[n];
        mins[0] = n*c[0];
        mins[1] = n*c[1];
        int minEven = 0;
        int minOdd = 1;

        for (int i = 2; i<n; i++) {
            if (i%2==0) {
                if (c[i]<c[minEven])
                    minEven = i;

                mins[i] = ps[minEven]-c[minEven] + ps[i]-ps[minEven] + c[minEven]*(n-i/2);
            } else {
                if (c[i]<c[minOdd])
                    minOdd = i;

                mins[i] = ps[minOdd]-c[minOdd] + ps[i]-ps[minOdd] + c[minOdd]*(n-i/2);
            }
        }

        for (int i = 1; i<n; i++) {
            res = Math.min(res, mins[i]+mins[i-1]);
        }

        return res;
    }

    public static long min(long a, long b, long c) {
        long t = Math.min(a, b);
        return Math.min(t, c);
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.StringTokenizer;

public class Solution {

    //

    public static void main(String[] args) {
        PrintStream out = System.out;
        FastScanner fs = new FastScanner();

        int T = fs.nextInt();


        while (T-- > 0) {

            int n = fs.nextInt();
            long[] arr = new long[n];

            for (int i = 0; i < n; i++) {
                arr[i] = fs.nextLong();
            }
            long[] ps = new long[n];
            ps[0] = arr[0];
            for (int i = 1; i < n; i++) {
                ps[i] = ps[i - 1] + arr[i];
            }

            long min = arr[0] * n + arr[1] * n;

            int even = 0;
            int odd = 1;

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

                if (i % 2 == 0) {
                    if (arr[i] < arr[even]) {
                        even = i;
                    }
                } else {
                    if (arr[i] < arr[odd]) {
                        odd = i;
                    }
                }

                int tmp = i + 1;
                int oddCount = tmp / 2;
                int evenCount = (tmp + 1) / 2;


                long local = ps[i];
                local += (n - oddCount) * arr[odd];
                local += (n - evenCount) * arr[even];

                min = Math.min(min, local);
            }
            out.println(min);
        }
    }

    // if these strings are both balanced then as one or zero goes out of the window one or zero must come in
    //

    


}
",0,Non-plagiarised
49b94994,d8654140,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main1582D {
    public static void main(String[] args) {
        final FastScanner in = new FastScanner(System.in);
        final PrintWriter out = new PrintWriter(System.out);
        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int j = 0; j < n; j++) {
                a[j] = in.nextInt();
            }
            int[] b = solution(a, n);
            for (int j = 0; j < n; j++) {
                out.print(b[j]);
                out.print("" "");
            }
            out.println();
        }

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

    private static int[] solution(int[] a, int n) {
        int[] b = new int[n];
        int start = 0;

        if (n % 2 == 1) {
            if (a[0] + a[1] != 0) {
                b[0] = -a[2];
                b[1] = -a[2];
                b[2] = a[0] + a[1];
            } else if (a[0] + a[2] != 0) {
                b[0] = -a[1];
                b[1] = a[0] + a[2];
                b[2] = -a[1];
            } else {
                b[0] = a[1] + a[2];
                b[1] = -a[0];
                b[2] = -a[0];
            }
            start = 3;
        } else {
            b[0] = -a[1];
            b[1] = a[0];
            int gcd = gcd(b[0], b[1]);
            b[0] /= gcd;
            b[1] /= gcd;
            start = 2;
        }
        for (int i = start; i < n; i += 2) {
            b[i] = -a[i + 1];
            b[i + 1] = a[i];
        }
        return b;
    }

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

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;


 
public class Codeforces {
	
	static int mod=1000000007 ;
	static List<Integer>[] adj;
	static boolean vst[];
	static int dp[];
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
		FastScanner fs=new FastScanner();
		int t=fs.nextInt();
		while(t-->0) {
			int n=fs.nextInt();
			int arr[]=fs.readArray(n);
			int ans[]=new int[n];
			if(n%2==0) {
				for(int i=0;i<n;i+=2) {
					ans[i]=-arr[i+1];
					ans[i+1]=arr[i];
				}
			}
			else {
				for(int i=3;i<n;i+=2) {
					ans[i]=-arr[i+1];
					ans[i+1]=arr[i];
				}
				int a=0, b=0, c=0;
				outer:for(int i=0;i<3;i++) {
					for(int j=i+1;j<3;j++) {
						if(arr[i]+arr[j]!=0) {
							b=i;
							c=j;
							a= 3-c-b;
							break outer;
						}
					}
				}
				ans[a]=arr[b]+arr[c];
				ans[b]=-arr[a];
				ans[c]=-arr[a];
			}
			for(int i=0;i<n;i++) {
				out.print(ans[i]+"" "");
			}
			out.println();
//			long sum=0;
//			for(int i=0;i<n;i++) {
//				sum+=arr[i]*ans[i];
//			}
//			if(sum!=0) System.out.println(false);
		}
		out.close();
		
	}
	
	
	
	
	
	
	
	
	
	
	// Use this to input code since it is faster than a Scanner
	
 
}
",0,Non-plagiarised
3951966f,9bc690ef,"import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

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

        return fun(0,0);
    }

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

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

    

    

    

    

    

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.ArrayList;
public class Armchairs {
	static ArrayList<Integer> one;
	static ArrayList<Integer> zero;
	public static void main(String args[]) {
		FastScanner fs=new FastScanner();
		int n=fs.nextInt();
		int []arr=new int[n];
		one=new ArrayList<>();
		zero=new ArrayList<>();
		for(int i=0;i<arr.length;i++) {
			arr[i]=fs.nextInt();
			if(arr[i]==1)
				one.add(i);
			else zero.add(i);
		}
		int [][]dp=new int[arr.length][arr.length];
		for(int i=0;i<arr.length;i++)
			Arrays.fill(dp[i], -1);
		System.out.println(dfs(dp,0,0));
	}
	public static int dfs(int [][]dp,int i,int j) {
		//System.out.println(i+""  ""+j);
		if(i>=one.size())
			return 0;
		if(j>=zero.size())
			return (int)(1e9);
		if(dp[i][j]!=-1)
			return dp[i][j];
		dp[i][j]=Math.min(Math.abs(one.get(i)-zero.get(j))+dfs(dp,i+1,j+1), dfs(dp,i,j+1));
		return dp[i][j];
	}
	

static final Random random=new Random();
	
	
	
}
",0,Non-plagiarised
9c55bc1b,c9da41af,"import java.util.*;
import java.io.*;

public class Main {
    static MyScanner sc;
    static PrintWriter out;
    static {
        sc = new MyScanner();
        out = new PrintWriter(System.out);
    }
    public static void bfs(Node[] g, int[] ans) {
        Arrays.fill(ans, -1);
        boolean[] visited = new boolean[g.length];
        Queue<Integer> q = new LinkedList<>();
        int s = 0;
        for(int i = 0; i < g.length; i++) {
            if(g[i].l.size() == 1) {
                s = i;
                break;
            }
        }
        q.add(s);
        int curr = 2;
        while(!q.isEmpty()) {
            int u = q.poll();
            if(visited[u])
                continue;
            visited[u] = true;
            for(Edge edge : g[u].l) {
                if(!visited[edge.v]) {
                    ans[edge.id] = curr;
                    q.add(edge.v);
                    if(curr == 2) curr = 3;
                    else curr = 2;
                }
            }
        }
    }
    public static void solve() {
        int n = sc.nextInt();
        Node[] a = new Node[n];
        for(int i = 0; i < n; i++)
            a[i] = new Node();
        for(int i = 0; i < n - 1; i++) {
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            a[u].l.add(new Edge(v, i));
            a[v].l.add(new Edge(u, i));
        }
        for(Node node : a) {
            if(node.l.size() > 2) {
                out.println(-1);
                return;
            }
        }
        int[] ans = new int[n - 1];
        bfs(a, ans);
        for(int i = 0; i < n - 1; i++)
            out.print(ans[i] + "" "");
        out.println();
    }
    public static void main(String[] args) {
        int t = sc.nextInt();
        while(t-- > 0)
            solve();
        out.flush();
    }
}

class Edge {
    int v, id;
    Edge(int a, int b) {
        v = a;
        id = b;
    }
}

class Node {
    ArrayList<Edge> l;
    Node() {
        l = new ArrayList<>();
    }
}


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



public class Main {
	static {
		try {
			System.setIn(new FileInputStream(""input.txt""));
			System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
		} catch (Exception e) {}
	}
	void solve() {
		int n = in.nextInt();

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

		for (int i = 0; i < n - 1; i++) {
			int u = in.nextInt();
			int v = in.nextInt();
			v--; u--;
			graph[u].add(new Edge(v, i));
			graph[v].add(new Edge(u, i));
		}

		int[] res = new int[n - 1];

		for (int i = 0; i < n; i++) {
			if (graph[i].size() > 2) {
				out.append(""-1\n"");
				return;
			}
		}

		int start = -1;
		for (int i = 0; i < n; i++) {
			if (graph[i].size() == 1) {
				start  = i;
				break;
			}
		}

		int currNode = start;
		int prevNode = -1;
		int weight = 2;

		while (true) {
			ArrayList<Edge> edges = graph[currNode];
			Edge next = edges.get(0);
			if (next.node == prevNode) {
				if (edges.size() == 1) {
					break;
				}
				next = edges.get(1);
			}
			res[next.index] = weight;
			weight = 5 - weight;
			prevNode = currNode;
			currNode = next.node;
		}

		for (int i = 0; i < n - 1; i++) {
			out.append(res[i] + "" "");
		}
		out.append(""\n"");
	}

	public static void main (String[] args) {
		// Its Not Over Untill I Win - Syed Mizbahuddin
		Main sol = new Main();
		int t = 1;
		t = in.nextInt();
		while (t-- != 0) {
			sol.solve();
		}
		System.out.print(out);
	}

	

	

	void print(int s) {
		System.out.print(s);
	}

	

	

	

	


	static FastReader in;
	static StringBuffer out;
	final int MAX;
	final int MIN;
	int mod ;
	Main() {
		in = new FastReader();
		out = new StringBuffer();
		MAX = Integer.MAX_VALUE;
		MIN = Integer.MIN_VALUE;
		mod = (int)1e9 + 7;
	}
}


class Edge {
	int node, index;
	Edge(int node, int index) {
		this.node = node;
		this.index = index;
	}
}
",0,Non-plagiarised
0ee2f8f1,587307f2,"import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
     int n=sc.nextInt();
     int arr[]=new int[n];
     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
     for(int i=0;i<n;i++){
      arr[i]=sc.nextInt();
      min=Math.min(arr[i],min);
      max=Math.max(arr[i],max);
     }
     while(min<=max){
      int mid=min+(max-min)/2;
      if(helper(arr,mid))
       min=mid+1;
       else max=mid-1;
     }
     System.out.println(min-1);
    }
  }
  public static boolean helper(int arr[],int min){
   int tmp[]=Arrays.copyOf(arr,arr.length);
   for(int i=arr.length-1;i>=2;i--){
    if(tmp[i]<min)
     return false;
    int d=(Math.min(arr[i],tmp[i]-min))/3;
    tmp[i-1]+=d;
    tmp[i-2]+=d*2;
   }
   return tmp[1]>=min && tmp[0]>=min;
  }
}
","import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
     int n=sc.nextInt();
     int arr[]=new int[n];
     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
     for(int i=0;i<n;i++){
      arr[i]=sc.nextInt();
      min=Math.min(arr[i],min);
      max=Math.max(arr[i],max);
     }
     while(min<=max){
      int mid=min+(max-min)/2;
      if(helper(arr,mid))
       min=mid+1;
       else max=mid-1;
     }
     System.out.println(min-1);
    }
  }
  public static boolean helper(int arr[],int min){
   int tmp[]=Arrays.copyOf(arr,arr.length);
   for(int i=arr.length-1;i>=2;i--){
    if(tmp[i]<min)
     return false;
    int d=(Math.min(arr[i],tmp[i]-min))/3;
    tmp[i-1]+=d;
    tmp[i-2]+=d*2;
   }
   return tmp[1]>=min && tmp[0]>=min;
  }
}
",1,Plagiarised
0f3a2acf,dba80ad4,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Practice {
    static int[][] vals;
    static ArrayList<ArrayList<Integer>> adjList;
    static long[][] ans;
    public static void main(String[] args) throws IOException {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(bu.readLine());
        while (t-- > 0) {
            Integer n = Integer.parseInt(bu.readLine());
            vals = new int[2][n];
            adjList = new ArrayList<>();
            for(int i=0;i<n;i++){
                String st[]=bu.readLine().split("" "");
                vals[0][i] = Integer.parseInt(st[0]);
                vals[1][i] = Integer.parseInt(st[1]);
                adjList.add(new ArrayList<>());
            }
            for(int i=0;i<n-1;i++){
                String st[]=bu.readLine().split("" "");
                int source = Integer.parseInt(st[0]);; int dest = Integer.parseInt(st[1]);;
                adjList.get(source-1).add(dest-1);
                adjList.get(dest-1).add(source-1);
            }
            ans = new long[2][n];
            DFS(0, adjList, -1, ans, vals);
            System.out.println(Math.max(ans[0][0], ans[1][0]));
        }
    }

    private static void DFS(Integer current, ArrayList<ArrayList<Integer>> adjList, Integer prev, long[][] ans, int[][] vals) {
        ans[0][current] = 0L; ans[1][current] = 0L;
        for(Integer node: adjList.get(current)){
            if(node.equals(prev)) continue;
            DFS(node, adjList, current, ans, vals);
            ans[0][current] += Math.max(ans[0][node] + Math.abs(vals[0][current] - vals[0][node]), ans[1][node] + Math.abs(vals[0][current] - vals[1][node]));
            ans[1][current] += Math.max(ans[0][node] + Math.abs(vals[1][current] - vals[0][node]) , ans[1][node] + Math.abs(vals[1][current] - vals[1][node]));
        }
    }
}
","import java.util.*;
import static java.lang.Math.*;
import java.io.*;
public class S {
       
      public static void main(String args[])throws IOException{
              BufferedReader br = new  BufferedReader(new InputStreamReader(System.in));
              int test = Integer.parseInt(br.readLine());
              while(test > 0){
                    test--;
                        int n = Integer.parseInt(br.readLine());
                        int a[][] = new int[n][2];
                        for(int i = 0; i < n; i++){
                              StringTokenizer st = new StringTokenizer(br.readLine());
                              a[i][0] = Integer.parseInt(st.nextToken());
                              a[i][1] = Integer.parseInt(st.nextToken());
                        }
                        Map<Integer, List<Integer>> g = new HashMap<Integer, List<Integer>>();
                        for(int i = 0; i < n-1; i++){
                              StringTokenizer st = new StringTokenizer(br.readLine());
                              int u = Integer.parseInt(st.nextToken());
                              int v = Integer.parseInt(st.nextToken());
                              u--;
                              v--;
                              if(!g.containsKey(u))g.put(u, new ArrayList<Integer>());
                              g.get(u).add(v);
                              if(!g.containsKey(v))g.put(v, new ArrayList<Integer>());
                              g.get(v).add(u);
                        }
                        solve(n, a, g);
                    //System.out.println(s + "" "" + tar);
                    //StringTokenizer st = new StringTokenizer(br.readLine());
                    //int n = Integer.parseInt(st.nextToken());
                    //int l = Integer.parseInt(st.nextToken());
                    //st = new StringTokenizer(br.readLine());
                    //int a[] = new int[n];
                    //for(int i = 0; i < n; i++){
                  //      a[i] = Integer.parseInt(st.nextToken());
                    //}
             }
      }
      
      public static void solve(int n, int a[][], Map<Integer, List<Integer>> g){
            Map<Integer, long[]> dp = new HashMap<Integer, long[]>();
            boolean visited[] =  new boolean[n];
            long ans = 0;
            visited[0] = true;
            long part[] = dfs(a, g, 0, visited, dp);
            ans = Math.max(part[0], part[1]);
            System.out.println(ans);
      }
      
      public static long[] dfs(int a[][], Map<Integer, List<Integer>> g, int node, boolean visited[], Map<Integer, long[]> dp){
            if(dp.containsKey(node)){
                  return dp.get(node);
            }
            List<Integer> children = g.get(node);
            if(children == null)return new long[]{0, 0};
            long ansL = 0;
            long ansR = 0;
            for(int child : children){
                  if(!visited[child]){
                        visited[child] = true;
                        long sol[] = dfs(a, g, child, visited, dp);
                        ansL += Math.max(sol[0] + Math.abs(a[node][0] - a[child][0]), sol[1] + Math.abs(a[node][0] - a[child][1]));
                        ansR += Math.max(sol[0] + Math.abs(a[node][1] - a[child][0]), sol[1] + Math.abs(a[node][1] - a[child][1]));
                  }
            }
            long ans[] = new long[]{ansL, ansR};
            dp.put(node, ans);
            return ans;
            
      }
      
      
}
",0,Non-plagiarised
0fd5b95a,41e72d4f,"import java.io.PrintWriter;
import java.util.*;
public class codeforces {
	static int dp[][]=new int[5001][5001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);  
		PrintWriter out=new PrintWriter(System.out);
        int t=1;
        for(int tt=0;tt<t;tt++) {
        	int n=s.nextInt();
        	int a[]=new int[n];
        	ArrayList<Integer> z=new ArrayList<>();
        	ArrayList<Integer> o=new ArrayList<>();
        	for(int i=0;i<n;i++) {
        		a[i]=s.nextInt();
        		if(a[i]==1) {
        			o.add(i);
        		}else {
        			z.add(i);
        		}
        	}
        	for(int i=0;i<5001;i++) {
        		Arrays.fill(dp[i], -1);
        	}
        	System.out.println(sol(0,0,z,o));
        }
        out.close();
	    s.close();
	}
	
	
	
	
	public static int sol(int i,int j,ArrayList<Integer> z,ArrayList<Integer> o) {
		if(j==o.size()) {
			return 0;
		}
		int h=z.size()-i;
		int l=o.size()-j;
		if(i==z.size()) {
			return 10000000;
		}
		if(dp[i][j]!=-1) {
			//System.out.println(i+"" ""+j);
			return dp[i][j];
		}
		int ans1=sol(i+1,j,z,o);
		int ans2=sol(i+1,j+1,z,o)+Math.abs(z.get(i)-o.get(j));
		dp[i][j]=Math.min(ans1, ans2);
		return dp[i][j];
	}
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.StringTokenizer;

public class ProblemD {
	
	public static void main(String[] args) throws IOException {
		final int INF = 20000000;
		InputStream in = System.in;
		InputReader scan = new InputReader(in);
		int n = scan.nextInt();
		int occ = 0;
		List<Integer> occPos = new ArrayList<>();
		HashSet<Integer> occPosSet = new HashSet<>();
		for(int i=1;i<=n;i++) {
			int num = scan.nextInt();
			if(num==1) {
				occ++;
				occPos.add(i);
				occPosSet.add(i);
			}
		}
		int[][] dp = new int[n+1][occ+1];
		for(int i=0;i<=n;i++) {
			for(int j=0;j<=occ;j++) {
				dp[i][j] = 20000000;
			}
		}
		for(int i=1;i<=n;i++) {
			int k=1;
			for(int pos: occPos) {
				if(occPosSet.contains(i)) {
					dp[i][k] = dp[i-1][k];
				} else {
					dp[i][k] = Math.min(dp[i-1][k], dp[i-1][k-1]+Math.abs(pos-i));
					if(k==1) dp[i][k]=Math.min(dp[i][k],Math.abs(pos-i));
				}
				k++;
			}
		}
		if(dp[n][occ]==INF) {
			System.out.println(0);
		} else {
			System.out.println(dp[n][occ]);
		}
	}
	
	
}
",0,Non-plagiarised
11c2ab99,259c1ea4,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main {

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

	
	
	

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

public class E {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int test = scn.nextInt();
        while (test-- > 0) {
            int nrLands = scn.nextInt();
            int[] toRightLands = new int[nrLands];
            Arrays.fill(toRightLands, (int) (1e9 + 1e8));
            int[] toLeftLands = new int[nrLands];
            Arrays.fill(toLeftLands, (int) (1e9 + 1e8));
            int nrAcs = scn.nextInt();

            AC[] acs = new AC[nrAcs];
            for (int i = 0; i < nrAcs; i++) {
                acs[i] = new AC();
                acs[i].myPos = scn.nextInt() - 1;
            }
            for (int i = 0; i < nrAcs; i++) {
                acs[i].myTemp = scn.nextInt();
            }
            Arrays.sort(acs);
            int nextAc = 1;
            AC lastChosen = acs[0];

            for (int i = lastChosen.myPos; i < nrLands; i++) {

                if (nextAc < acs.length && i == acs[nextAc].myPos) {
                    if (acs[nextAc].myTemp < lastChosen.myTemp + i - lastChosen.myPos) {
                        lastChosen = acs[nextAc];
                    }
                    nextAc++;
                }

                toRightLands[i] = lastChosen.myTemp + i - lastChosen.myPos;

            }


            int nextAc1 = acs.length - 2;
            AC lastChosen1 = acs[acs.length - 1];

            for (int i = lastChosen1.myPos; i >= 0; i--) {
                if (nextAc1 >= 0 && i == acs[nextAc1].myPos) {
                    if (acs[nextAc1].myTemp < lastChosen1.myTemp - i + lastChosen1.myPos) {
                        lastChosen1 = acs[nextAc1];
                    }
                    nextAc1--;
                }

                toLeftLands[i] = lastChosen1.myTemp - i + lastChosen1.myPos;
            }
            for (int i = 0; i < nrLands; i++) {
                System.out.print(Integer.min(toLeftLands[i], toRightLands[i]) + "" "");
            }
            System.out.println();


        }


    }


    static class AC implements Comparable<AC> {
        int myPos, myTemp;


        
    }
}
",0,Non-plagiarised
7bc92b7f,9028caf7,"import java.util.*;
import java.io.*;


public class Main{

    public static void main(String[] args) throws java.io.IOException {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        int[][] dp=new int[n][n];
        int[][] min=new int[n][n];
        ArrayList<Integer> ones=new ArrayList<>();
        ArrayList<Integer> zero=new ArrayList<>();
        for(int i=0;i<n;++i) {
            arr[i] = sc.nextInt();
            if(arr[i]==1)
                ones.add(i);
            else
                zero.add(i);
        }
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j) {
                min[i][j] = Integer.MAX_VALUE;
                dp[i][j] = Integer.MAX_VALUE;
            }
        int len=ones.size();
        int zlen=zero.size();
        int minn=0;
        for(int i=0;i<len;++i)
        {
            int cur = ones.get(i);
            for(int j=i;j<zlen;j++)
            {
                int curz = zero.get(j);
                int cost = Math.abs(cur-curz);
                if(i!=0 && curz-1>=0)
                {
                    cost+=min[i-1][curz-1];
                }
                dp[i][curz]=cost;
            }
            minn=Integer.MAX_VALUE;
            for(int j=0;j<n;++j)
            {
                if(dp[i][j]<minn)
                    minn=dp[i][j];
                min[i][j]=minn;
            }
        }
        System.out.println(minn);
    }
}
","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();
    }
    
}
",0,Non-plagiarised
67996c4c,7bc92b7f,"import java.util.*;
import java.io.*;

public class code{

	

	

	public static void main(String[] arg) throws IOException{
		//Reader in=new Reader();
		Scanner in=new Scanner(System.in);

   int n=in.nextInt();
	 int[] arr=new int[n];
	 ArrayList<Integer> zero=new ArrayList<Integer>();
	 ArrayList<Integer> one=new ArrayList<Integer>();

	 for(int i=0;i<n;i++){
		 arr[i]=in.nextInt();
		 if(arr[i]==0) zero.add(i);
		 else one.add(i);
	 }
   if(one.size()==0) {
		 System.out.println(0);
	 }
	 else{
			 int[][] dp=new int[one.size()][zero.size()];

		   for(int i=0;i<one.size();i++){
				 for(int j=0;j<zero.size();j++){
					 if(i==0 && j==0) dp[i][j]=Math.abs(one.get(i)-zero.get(j));
					 else if(j==0) dp[i][j]=Integer.MAX_VALUE/2;
					 else if(i==0) dp[i][j]=Math.min(dp[i][j-1],Math.abs(one.get(i)-zero.get(j)));
					 else{
						 dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(one.get(i)-zero.get(j)));
					 }
				 }
			 }

		  System.out.println(dp[one.size()-1][zero.size()-1]);
		}
	}
}
","import java.util.*;
import java.io.*;


public class Main{

    public static void main(String[] args) throws java.io.IOException {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
        int[][] dp=new int[n][n];
        int[][] min=new int[n][n];
        ArrayList<Integer> ones=new ArrayList<>();
        ArrayList<Integer> zero=new ArrayList<>();
        for(int i=0;i<n;++i) {
            arr[i] = sc.nextInt();
            if(arr[i]==1)
                ones.add(i);
            else
                zero.add(i);
        }
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j) {
                min[i][j] = Integer.MAX_VALUE;
                dp[i][j] = Integer.MAX_VALUE;
            }
        int len=ones.size();
        int zlen=zero.size();
        int minn=0;
        for(int i=0;i<len;++i)
        {
            int cur = ones.get(i);
            for(int j=i;j<zlen;j++)
            {
                int curz = zero.get(j);
                int cost = Math.abs(cur-curz);
                if(i!=0 && curz-1>=0)
                {
                    cost+=min[i-1][curz-1];
                }
                dp[i][curz]=cost;
            }
            minn=Integer.MAX_VALUE;
            for(int j=0;j<n;++j)
            {
                if(dp[i][j]<minn)
                    minn=dp[i][j];
                min[i][j]=minn;
            }
        }
        System.out.println(minn);
    }
}
",0,Non-plagiarised
722e318f,c9159d9c,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class TaskB {

    static long mod = 1000000007;
    static FastScanner scanner;

    static final StringBuilder result = new StringBuilder();

    public static void main(String[] args) {
        // 2 : 1000000000
        scanner = new FastScanner();
        int T = scanner.nextInt();
        for (int t = 0; t < T; t++) {
            solve(t + 1);
            result.append(""\n"");
        }
        System.out.println(result);
    }

    static void solve(int t) {
        int n = scanner.nextInt();
        int[] a = scanner.nextIntArray(n);
        String s = scanner.nextToken();

        List<Integer> blue = new ArrayList<>();
        List<Integer> red = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'B') {
                blue.add(a[i]);
            } else {
                red.add(a[i]);
            }
        }
        Collections.sort(blue);
        Collections.sort(red);
        for (int i = 0; i < blue.size(); i++) {
            if (blue.get(i) < i + 1) {
                result.append(""NO"");
                return;
            }
        }
        for (int i = 0; i < red.size(); i++) {
            if (red.get(i) > i + 1 + blue.size()) {
                result.append(""NO"");
                return;
            }
        }
        result.append(""YES"");
    }

    

    

    

    

    
}
","import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

        return;
    }
}
",0,Non-plagiarised
1dab88fb,f59d9b6e,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef{
    public static class Edge{
        int node;
        int index;
        Edge(int node, int index){
            this.node = node;
            this.index = index;
        }
    }
    static Scanner scn = new Scanner(System.in);
	public static void main (String[] args) throws java.lang.Exception{
		int t = scn.nextInt();
		while(t-->0){
		    solve();
		}
	}
	public static void solve(){
	    int n = scn.nextInt();
	    ArrayList<Edge>[]graph = new ArrayList[n];
	    for(int i = 0; i < n; i++){
	        graph[i] = new ArrayList<>();
	    }
	    for(int i = 0; i < n - 1; i++){
	        int u = scn.nextInt() - 1;
	        int v = scn.nextInt() - 1;
	        graph[u].add(new Edge(v, i));
	        graph[v].add(new Edge(u, i));
	    }
	    int start = 0;
	    for(int i = 0; i < n; i++){
	        if(graph[i].size() > 2){
	            System.out.println(""-1"");
	            return;
	        }else if(graph[i].size() == 1){
	            start = i;
	        }
	    }
	    int[]weight = new int[n - 1];
	    int prevNode = -1, curNode = start, curWeight = 2;
	    while(true){
	        ArrayList<Edge>edges = graph[curNode];
	        Edge next = edges.get(0);
	        if(next.node == prevNode){
	            if(edges.size() == 1){
	                break;
	            }else{
	                next = edges.get(1);
	            }
	        }
	        weight[next.index] = curWeight;
	        prevNode = curNode;
	        curNode = next.node;
	        curWeight = 5 - curWeight;
	    }
	    for(int i = 0; i < n - 1; i++){
	        System.out.print(weight[i]);
	        System.out.print("" "");
	    }
	    System.out.println();
	}
}
",1,Plagiarised
0588b869,11373c16,"import java.util.*;
import java.io.*;
public class Solution
{
    
    static final long mod=(long)1e9+7;
    
    
    /*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();
        int n=fs.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++)
        a[i]=fs.nextInt();
        ArrayList<Integer> o=new ArrayList<>();
        ArrayList<Integer> z=new ArrayList<>();
        for(int i=0;i<n;i++)
        {
            if(a[i]==1)o.add(i);
            else z.add(i);
        }
        int ans[][]=new int[o.size()+1][z.size()+1];
        for(int i=1;i<=o.size();i++)
        {
            for(int j=i;j<=z.size();j++)
            {
                if(i==j)ans[i][j]=ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1));
                else 
                ans[i][j]=Math.min(ans[i][j-1],ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1)));
            }
        }
        pw.println(ans[o.size()][z.size()]);
        pw.flush();
        pw.close();
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{ 
	public static void main (String[] args) throws java.lang.Exception
	{
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int n = scan.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            int x = scan.nextInt();
            if(x==1)
            a.add(i);
            else
            b.add(i);  
        }
        int x = a.size();
        if(x==0){
            pw.println(0);
            pw.flush();
            return;
        }
        int y = b.size();
        int dp[][] = new int[x][y];
        int min = Integer.MAX_VALUE;
        for(int i=0;i<y;i++){
            min = Math.min(Math.abs(a.get(0) - b.get(i)),min);
            dp[0][i] = min;
        }
        for(int i=1;i<x;i++){
            min = Integer.MAX_VALUE;
            for(int j=i;j<y;j++){
                min = Math.min(Math.abs(a.get(i)-b.get(j))+dp[i-1][j-1],min);
                dp[i][j] = min;
            }
        }
        pw.println(dp[x-1][y-1]);
        pw.flush();
	}
   
}
",0,Non-plagiarised
ca3128ab,e270e909,"import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   
	  
	    
	 
	   
	
	
	   public static void main(String args[]) throws Exception { 
		
		   
		   Scanner sc = new Scanner();
		   StringBuilder res = new StringBuilder();
		   
		   int tc = sc.nextInt();
		   
		   while(tc-->0) { 
			
			int n = sc.nextInt();
			
			long c[] = new long[n];
			
			for(int i=0;i<n;i++) { 
				c[i] = sc.nextLong();
			}
			
			
			long min_odd = Integer.MAX_VALUE;
			long min_even = Integer.MAX_VALUE;
		    long ans = Long.MAX_VALUE;
		    long sum = 0;
		    
			int cnt1 = n;
			
			int cnt2 = n;
			
			
		    for(int i = 0; i < n; i++){
		        sum += c[i];
		        if(i % 2 == 0){
		            cnt1--;
		            min_odd = Math.min(min_odd, c[i]);
		        }
		        else{
		            cnt2--;
		            min_even = Math.min(min_even, c[i]);
		        }
		        if(i > 0){
		            long temp = sum + (min_odd * cnt1) + (min_even * cnt2);
		            ans = Math.min(ans, temp);
		        }
		 
		    }
		    
		    System.out.println(ans);
		   }
		   
		   System.out.println(res);
	   }
}
","import java.io.*;
import java.util.*;

public class GFG {
    
    
    
	public static void main (String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int t = sc.nextInt();
	     while(t-- > 0){
	         int n = sc.nextInt();
	         long pre = 0,ans = Long.MAX_VALUE;
	         long[] arr = new long[n];
	         PriorityQueue<Long> epq = new PriorityQueue<>();
	         PriorityQueue<Long> opq = new PriorityQueue<>();
	         for(int i=0;i<n;i++)
	         {
	             arr[i] = sc.nextLong();
	             if(i%2==0)
	             epq.add(arr[i]);
	             else
	             opq.add(arr[i]);
	             pre+=arr[i];
	             if(i>0)
	             ans = Math.min(ans,pre+(n-epq.size())*epq.peek()+(n-opq.size())*opq.peek());
	         }
	         System.out.println(ans);
	     }    
	}
}
",0,Non-plagiarised
bd65846f,d018b49f,"import java.lang.*;
import java.util.*;
import java.io.*;

public class Main {    
    static void deal(int[] arr,int n) {
        int m1 = 0;
        int m2 = 0;
        for(int i=0;i<n;i++) {
            if(arr[i]==1) {
                m1 ++;
            } else {
                m2 ++;
            }
        }
        if(m1 ==0) {
            System.out.println(0);
            return;
        }
        int[] arr1 = new int[m1];
        int[] arr2 = new int[m2];
        int index1 = 0;
        int index2 = 0;
        for(int i=0;i<n;i++) {
            if(arr[i] == 1) {
                arr1[index1] = i;
                index1++;
            } else {
                arr2[index2] = i;
                index2++;
            }
        }
        int[][] dp = new int[m2][m1];
        dp[0][0] = Math.abs(arr1[0]-arr2[0]);
        for(int i=0;i<m1;i++) {
            if(i>0) dp[i][i] = dp[i-1][i-1] + Math.abs(arr1[i]-arr2[i]);
            for(int j=i+1;j<m2;j++) {
                if(i>0) {
                    dp[j][i] = Math.min(dp[j-1][i],dp[j-1][i-1]+Math.abs(arr2[j]-arr1[i]));
                } else {
                    dp[j][i] = Math.min(dp[j-1][i],Math.abs(arr2[j]-arr1[i]));
                }
            }
        }
        System.out.println(dp[m2-1][m1-1]);
    }
    
	public static void main(String[] args) {
      	MyScanner scanner = new MyScanner();
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for(int i=0;i<n;i++) {
            arr[i] = scanner.nextInt();    
        }
        deal(arr,n);
    }
    
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef {
	static long dp[][];
	public static void main(String[] args) throws java.lang.Exception {
		FastReader in = new FastReader(System.in);
		StringBuilder sb = new StringBuilder();
		int t = 1;
		//t = in.nextInt();
		while (t > 0) {
			--t;
			int n = in.nextInt();
			int arr[] = new int[n];
			List<Integer> ones = new ArrayList<Integer>();
			List<Integer> zero = new ArrayList<>();
			for(int i = 0;i<n;i++)
			{
				int a = in.nextInt();
				if(a == 1)
					ones.add(i);
				else 
					zero.add(i);
			}
			if(ones.size() == 0) {
				sb.append(0+""\n"");
				continue;
			}
			dp = new long[ones.size()][zero.size()];
			for(int i = 0;i<ones.size();i++)
			    Arrays.fill(dp[i], -1);
			sb.append(findans(ones, zero, ones.size()-1, zero.size()-1));
           
		}
		System.out.print(sb);
	}
	
	static long findans(List<Integer> ones,List<Integer> zero,int x,int y)
	{
		if(x < 0)
			return 0;
		if(y<0)
			return Integer.MAX_VALUE;
        if(dp[x][y]!=-1)
        	return dp[x][y];
		return  dp[x][y] = Math.min(findans(ones, zero, x, y-1),findans(ones, zero, x-1, y-1) + (long)Math.abs(ones.get(x)-zero.get(y)));
	}

	

	

	
}


",0,Non-plagiarised
fc7dfa16,fe94ee2f,"import java.util.*;
import java.io.*;
public class C {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int integer=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n))
            {
                if(n>='0'&&n<='9')
                {
                    integer*=10;
                    integer+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        
        
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    
    
    
    
    
    
    
    static int n;
    static long arr[];
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        StringBuilder ans=new StringBuilder("""");
        int test=input.scanInt();
        for(int tt=1;tt<=test;tt++) {
            n=input.scanInt();
            arr=new long[n];
            for(int i=0;i<n;i++) {
                arr[i]=input.scanInt();
            }
            ans.append(solve()+""\n"");
        }
        System.out.println(ans);
    }
    
    public static long solve() {
        long ans=Long.MAX_VALUE;
        long r_min=Long.MAX_VALUE,u_min=Long.MAX_VALUE;
        long r_rem=n,u_rem=n,sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==0) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        r_min=Long.MAX_VALUE;
        u_min=Long.MAX_VALUE;
        r_rem=n;
        u_rem=n;
        sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==1) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        return ans;
    }
}
","import java.util.*;
import java.io.*;
public class C {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int integer=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n))
            {
                if(n>='0'&&n<='9')
                {
                    integer*=10;
                    integer+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        
        
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    
    
    
    
    
    
    
    static int n;
    static long arr[];
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        StringBuilder ans=new StringBuilder("""");
        int test=input.scanInt();
        for(int tt=1;tt<=test;tt++) {
            n=input.scanInt();
            arr=new long[n];
            for(int i=0;i<n;i++) {
                arr[i]=input.scanInt();
            }
            ans.append(solve()+""\n"");
        }
        System.out.println(ans);
    }
    
    public static long solve() {
        long ans=Long.MAX_VALUE;
        long r_min=Long.MAX_VALUE,u_min=Long.MAX_VALUE;
        long r_rem=n,u_rem=n,sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==0) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        r_min=Long.MAX_VALUE;
        u_min=Long.MAX_VALUE;
        r_rem=n;
        u_rem=n;
        sum=0;
        
        for(int i=0;i<n;i++) {
            if(i%2==1) {
                r_min=Math.min(r_min,arr[i]);
                r_rem--;
            }
            else {
                u_min=Math.min(u_min,arr[i]);
                u_rem--;
            }
            sum+=arr[i];
            if(i==0) {
                continue;
            }
            
            ans=Math.min(ans,sum+(r_rem*r_min)+(u_rem*u_min));
        }
        
        return ans;
    }
}
",1,Plagiarised
548ffb07,921b6e4a,"import java.io.*;
import java.util.*;

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

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{ 
	public static void main (String[] args) throws java.lang.Exception
	{
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int n = scan.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            int x = scan.nextInt();
            if(x==1)
            a.add(i);
            else
            b.add(i);  
        }
        int x = a.size();
        if(x==0){
            pw.println(0);
            pw.flush();
            return;
        }
        int y = b.size();
        int dp[][] = new int[x][y];
        int min = Integer.MAX_VALUE;
        for(int i=0;i<y;i++){
            min = Math.min(Math.abs(a.get(0) - b.get(i)),min);
            dp[0][i] = min;
        }
        for(int i=1;i<x;i++){
            min = Integer.MAX_VALUE;
            for(int j=i;j<y;j++){
                min = Math.min(Math.abs(a.get(i)-b.get(j))+dp[i-1][j-1],min);
                dp[i][j] = min;
            }
        }
        pw.println(dp[x-1][y-1]);
        pw.flush();
	}
   
}
","import java.io.*;
import java.util.*;

public class E {

	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.parseInt(br.readLine());
		int cnt = n;
		boolean[] non = new boolean[n];
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		for(int i = 0; i < n; i++) {
			
			if(Integer.parseInt(st.nextToken()) == 0) {
				non[i] = true;
				cnt--;
			}
			
		}
		
		int x = 0;
		int y = 0;
		int[] location = new int[cnt];
		int[] rlocation = new int[n-cnt];
		
		for(int i = 0; i < n; i++) {
			
			if(!non[i]) {
				
				location[x] = i;
				x++;
				
			}else{
				
				rlocation[y] = i;
				y++;
				
			}
			
		}
		
		int[][] dp = new int[(n-cnt)+1][cnt+1];
		Arrays.fill(dp[0], 100000000);
		dp[0][0] = 0;
		
		for(int i = 0; i < n-cnt; i++) {
			
			//System.out.println(""HIT"");
			
			if(i < (n-cnt))
				Arrays.fill(dp[i+1], 100000000);
						
			for(int j = 0; j < cnt; j++) {
				
				if(i < (n-cnt)) {
					dp[i+1][j] = Math.min(dp[i+1][j], dp[i][j]);
					dp[i+1][j+1] = Math.min(dp[i+1][j+1], dp[i][j] + Math.abs(rlocation[i] - location[j]));			
					//System.out.println(dp[i+1][j+1] + "" "" + dp[i][j] + "" "" + j + "" "" + rlocation[i] + "" "" + location[j]);
				}
				
			}
			
		}
		
		int min = Integer.MAX_VALUE;
		
		for(int i = 0; i < (n-cnt)+1; i++) {
			
			min = Math.min(dp[i][cnt], min);
			
		}
				
		System.out.println(min);
		
	}

}
",0,Non-plagiarised
99bc7da3,ced4639e,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
 
 
public class Codeforces {
	
	static int mod =1000000007; 
	static Set<Integer> set;
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
	    FastScanner fs=new FastScanner();
	    int t=fs.nextInt();
	    while(t-->0) {
	    	int n=fs.nextInt();
	    	int arr[]=new int[n];
//	    	set=new HashSet<>();
	    	for(int i=0;i<n;i++) {
	    		arr[i]=Math.abs(fs.nextInt());
//	    		set.add(arr[i]);
	    	}
//	    	sort(arr);
//	    	for(int i=0;i<n;i++) System.out.print(arr[i]+"" "");
//	    	System.out.println();
//	    	if(set.size()<n||set.contains(0)) {
//	    		System.out.println(""YES"");
//	    		continue;
//	    	}
	    	boolean f=false;
	    	for(int i=0;i<n;i++) {
	    		boolean cur=recur(0,i,arr,0);
	    		if(cur) {
	    			f=true;
	    			break;
	    		}
	    	}
	    	if(f) System.out.println(""YES"");
	    	else System.out.println(""NO"");
	    }
	    out.close();
	}
	static boolean recur(int pos,int ind,int arr[],int sum) {
		if(pos==ind) return recur(pos+1,ind,arr,sum);
		if(sum==arr[ind]) return true;
		if(pos==arr.length) {
			return false;
		}
		
		if(recur(pos+1,ind,arr,sum+arr[pos])) return true;
		if(recur(pos+1,ind,arr,sum)) return true;
		if(recur(pos+1,ind,arr,sum-arr[pos])) return true;
		return false;
	}
	
	
	
	
	
	
	
	
	// 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;

public class Main {
    public static boolean find(int[] a) {
        int n = a.length;
        for (int i = 1; i < Math.pow(3, n); i++) {
            int sum = 0;
            int x = i;
            for (int j = 0; j < n; j++) {
                int r = x % 3;
                if (r == 1) sum += a[j];
                else if (r ==2) sum -= a[j];
                x /= 3;
            }
            if (sum == 0) return true;
        }
        return false;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int t = Integer.parseInt(br.readLine());
        for (int i = 0; i < t; i++) {
            int n = Integer.parseInt(br.readLine());
            int[] a = new int[n];
            String[] s = br.readLine().trim().split(""\\s+"");
            for (int j = 0; j < n; j++) {
                a[j] = Integer.parseInt(s[j]);
            }
            boolean res = find(a);
            if (res) pw.println(""YES"");
            else pw.println(""NO"");
        }
        pw.flush();
    }
}
",0,Non-plagiarised
034030f3,9e4ddc38,"import java.util.*;
import java.io.*;

public class D_1525 {
	
	static int INF = (int)1e9;
	static int n, m;
	static int[] full, free;
	static int[][] memo;
	
	public static int dp(int i, int j) {
		if(i == n)
			return 0;
		if(j == m)
			return INF;
		
		if(memo[i][j] != -1)
			return memo[i][j];
		
		return memo[i][j] = Math.min(dp(i, j + 1), Math.abs(free[j] - full[i]) + dp(i + 1, j + 1));
	}
	
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int l = sc.nextInt();
		int[] array = sc.nextIntArray(l);
		
		n = 0;
		for(int i = 0; i < l; i++)
			if(array[i] == 1)
				n++;
		m = l - n;
		
		full = new int[n];
		free = new int[m];
		int ind1 = 0, ind2 = 0;
		for(int i = 0; i < l; i++)
			if(array[i] == 0)
				free[ind2++] = i;
			else
				full[ind1++] = i;
		
		memo = new int[n][m];
		for(int[] i : memo)
			Arrays.fill(i, -1);
		
		pw.println(dp(0, 0));
		pw.flush();
	}

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

public class Try2{
	public static void main(String[] args) throws IOException {
		FastScanner fs = new FastScanner();
//		int t =fs.nextInt();
		int t=1;
		
		while (t-- > 0) {
		
			int n = fs.nextInt();
			
			
			int a[] = new int[n];
			
			int countOne = 0;
			
			
			ArrayList<Integer> aa = new ArrayList<Integer>();
			
			for(int i =0;i<n;i++) {
					a[i] =fs.nextInt();
					if(a[i]==1) {
						countOne++;
						aa.add(i);
					}
			}
			
			int dp[][] = new int[n+1][countOne+1];
			
			for(int i =0 ;i<=n;i++) {
				for(int j =0 ;j<=countOne;j++) {
					dp[i][j] = Integer.MAX_VALUE;
				}
			}
			
			
			
			dp[0][0] =0;
			for(int i =0 ;i<n;i++) {
				for(int j =0 ;j<countOne+1;j++) {
					
					if(dp[i][j]==Integer.MAX_VALUE) continue;
					
					dp[i+1][j] = Math.min(dp[i][j], dp[i+1][j]);
					
					if(j<countOne && a[i]==0) {
						dp[i+1][j+1]=Math.min(dp[i][j]+Math.abs(aa.get(j)-i),dp[i+1][j+1]);
					}
					
					
					
				}
			}
			
			System.out.println(dp[n][countOne]);
			
			
		
		}
		
	}
	
	
	
	
	static final Random random = new Random();

	

	

}
",0,Non-plagiarised
1c8bb204,7d7cf9a7,"import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class BST {

    

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-->0){

            int n = Integer.parseInt(br.readLine());
            long [] arr = new long[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                long tmp = Long.parseLong(st.nextToken());
                arr[i] = tmp;

            }

            int h = 1;
            int v = 1;
            long minHor = arr[0];
            long minVir = arr[1];
            long sum0 = arr[0];
            long sum1 = arr[1];
            long total = (arr[0] + arr[1])*n;


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

                if(i%2==0){
                    h++;
                    sum0 += arr[i];
                    minHor = Math.min(arr[i] , minHor);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }else {
                    v++;
                    sum1 += arr[i];
                    minVir = Math.min(arr[i] , minVir);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }

            }


            System.out.println(total);

        }



    }




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

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

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


public class Practice
{
//	static final long mod=7420738134811L;
	static int mod=1000000007;
	static final int size=501;
	static FastReader sc=new FastReader(System.in);
//	static Reader sc=new Reader();
	static  PrintWriter out=new PrintWriter(System.out);
	static long[] factorialNumInverse;
	static long[] naturalNumInverse;	
	static int[] sp;
	static long[] fact;
	static ArrayList<Integer> pr;
	public static void main(String[] args) throws IOException
	{
//		System.setIn(new FileInputStream(""input.txt""));
//		System.setOut(new PrintStream(""output.txt""));
//		factorial(mod);
//		InverseofNumber(mod);
//		InverseofFactorial(mod);
//		make_seive();
		int t=1;
		t=sc.nextInt();
		while(t-->0)
			solve();
		out.close();
		out.flush();
	}
	static void solve() throws IOException
	{
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=sc.nextInt();
		String s=sc.next();
		ArrayList<Integer> blue=new ArrayList<Integer>();
		ArrayList<Integer> red=new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			if(s.charAt(i)=='B')
				blue.add(arr[i]);
			else
				red.add(arr[i]);
		}
		Collections.sort(blue);
		Collections.sort(red);
		for(int i=0;i<blue.size();i++)
		{
			if(blue.get(i)<i+1)
			{
				out.println(""NO"");
				return;
			}
		}
		for(int i=0;i<red.size();i++)
		{
			if(red.get(i)>i+1+blue.size())
			{
				out.println(""NO"");
				return;
			}
		}
		out.println(""YES"");
	}
	
	
	
	
	
	
	
	// Function to precompute inverse of factorials
	
	// Function to calculate factorial of 1 to 200001
	
	 
	// Function to return nCr % p in O(1) time
	
	
	
	
	
	
	
	
	
	
	
}
","import java.util.*;
import java.util.concurrent.Exchanger;

public class Codeforces {

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


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

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

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


   

   
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.StringTokenizer;

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


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

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

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


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

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

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

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

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

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

    

    
}
",0,Non-plagiarised
624b8db5,90f01508,"import java.io.*;
import java.util.*;
public class C
{
    private static ArrayDeque<Integer>[] edge;
    private static HashMap<String,Integer> map;

    private static String getHash(int u, int v)
    {
        if(u>v)
        {
            int tmp=u;
            u=v;
            v=tmp;
        }

        return u+"" ""+v;
    }
    private static void DFS(int u, int p, int[] ans, int val)
    {
        for(int v:edge[u])
        {
            if(v==p) continue;
            ans[map.get(getHash(u,v))]=val;

            DFS(v,u,ans,5-val);
            val=5-val;
        }
    }
    public static void main(String[] args) throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        int i,N;

        int T=Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();

        while (T-->0)
        {
            N=Integer.parseInt(br.readLine().trim());
            edge=new ArrayDeque[N];
            for(i=0;i<N;i++) edge[i]=new ArrayDeque<>();

            map=new HashMap<>();
            int[] ans=new int[N-1];
            int[] deg=new int[N];

            for(i=0;i<N-1;i++)
            {
                String[] s=br.readLine().trim().split("" "");
                int u=Integer.parseInt(s[0])-1;
                int v=Integer.parseInt(s[1])-1;

                edge[u].add(v); edge[v].add(u);
                deg[u]++; deg[v]++;

                map.put(getHash(u,v),i);
            }

            for(i=0;i<N;i++) if(deg[i]>2) break;
            if(i<N)
            {
                sb.append(-1).append(""\n"");
                continue;
            }

            DFS(0,0,ans,2);
            for(int x:ans) sb.append(x).append("" "");
            sb.append(""\n"");
        }
        System.out.println(sb);
    }
}
","import java.io.*; 
import java.util.*;

public class 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;
    }
  }
}
",0,Non-plagiarised
3d06b643,f6ca6fc8,"import java.io.*;
import java.util.*;

public class ArmChairs {
    

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

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

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

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

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

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


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

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

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

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

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

public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n = sc.nextInt();
		ArrayList<Integer>  o=new ArrayList<Integer>();
		ArrayList<Integer>  e=new ArrayList<Integer>();
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		int dp[][]=new int[o.size()+1][e.size()+1];
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++){
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",1,Plagiarised
464a03b8,f0ede32a,"import java.util.*;

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
","import java.util.*;

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
",1,Plagiarised
680ba922,90dc2b20,"import java.util.*;
import java.io.*;

public class Solution
{
    
    
   
  
  
  
  
  
  
  
 
  
    // 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.*;
import java.io.*;
public class C1615{
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-->0) {
			int n = fs.nextInt();
			String a = fs.next();
			String b = fs.next();
			char ch1[] = a.toCharArray();
			char ch2[] = b.toCharArray();
			int c00 = 0;
			int c01 = 0;
			int c10 = 0;
			int c11 = 0;
			for(int i=0;i<n;i++){
				if(ch1[i]=='0'){
					if(ch2[i]=='0'){
						c00+=1;
					}
					else{
						c01+=1;
					}
				}
				else{
					if(ch2[i]=='0'){
						c10+=1;
					}
					else{
						c11+=1;
					}
				}
			}
			int ans = -1;
			if((c11-c00)==1 || c10==c01){
				int s1 = (int)1e7; 
				int s2 = (int)1e7;
				if((c11-c00)==1){
					s1 = c11+c00;
				}
				if(c10==c01)
				s2 = c10+c01;
				ans = Math.min(s1,s2); 
			}
			out.println(ans);
		}
		out.close();
	}
	
	
}
",0,Non-plagiarised
67241a76,8a39dbf5,"import java.util.*;
import java.io.*;

public class CodeForces {

    public void run() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int q = Integer.parseInt(br.readLine());
            while (q-- > 0){
                br.readLine();
                StringTokenizer st = new StringTokenizer(br.readLine());
                int n = Integer.parseInt(st.nextToken());
                int k = Integer.parseInt(st.nextToken());
                int[] a = new int[k];
                int[] t = new int[k];
                long[] L = new long[n];
                long[] R = new long[n];
                for (int i = 0; i < n; i++) {
                    L[i] = Integer.MAX_VALUE;
                    R[i] = Integer.MAX_VALUE;
                }
                st = new StringTokenizer(br.readLine());
                StringTokenizer st1 = new StringTokenizer(br.readLine());
                for (int i = 0; i < k; i++) {
                    a[i] = Integer.parseInt(st.nextToken());
                    t[i] = Integer.parseInt(st1.nextToken());
                    L[a[i] - 1] = t[i];
                    R[a[i] - 1] = t[i];
                }
                for (int i = 1; i < n; i++) {
                    L[i] = Math.min(L[i-1] + 1, L[i]);
                }
                for (int i = n - 2; i >= 0; i--) {
                    R[i] = Math.min(R[i], R[i + 1] + 1);
                }
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < n; i++) {
                    long tmp = Math.min(L[i], R[i]);
                    sb.append(tmp);
                    sb.append("" "");
                }
                System.out.println(sb.toString().trim());

            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

import java.io.*;

public class abc {
	static PrintWriter pw;

	static long x = 1, y = 1;

	/*
	 * static long inv[]=new long[1000001]; static long dp[]=new long[1000001];
	 */
	/// MAIN FUNCTION///
	public static void main(String[] args) throws Exception {

		FastReader sc = new FastReader();
		pw = new PrintWriter(System.out);
		// use arraylist as it uses the concept of dynamic table(amortized analysis)
		// Arrays.stream(array).forEach(a -> Arrays.fill(a, 0));
		/* List<Integer> l1 = new ArrayList<Integer>(); */
		// Random rand = new Random();
		int tst = sc.nextInt();
		while(tst-->0) {
			int n=sc.nextInt();
			int app[]=new int[n];
			int h[]=new int[n];
			for(int i=0;i<n;i++)
			{
				app[i]=sc.nextInt();
			}
			for(int i=0;i<n;i++)
			{
				h[i]=sc.nextInt();
			}
			long man = 0;
			long last = app[n - 1] - h[n - 1] + 1;
			int end = n-1;
			for (int i = n-2; i >=0; i--) {
				if(app[i]>=last) {
					last = Math.min(last,app[i] - h[i] + 1);
				}
				else {
					long s = app[end]-last+1;
					man += (s*(s+1))/2;
					end = i;
					last = app[i] - h[i] + 1;;
				}
			}
			long s = app[end]-last+1;
			man += (s*(s+1))/2;
			pw.println(man);
		}
		pw.flush();
	}

	

	

	

	

	

	

	

	

	// ch.charAt(i)+"""" converts into a char sequence
	

	

	

	

	

	

	

	

	// modular exponentiation
	

	

	/*
	 * public static void extract(ArrayList<Integer> ar, int k, int d) { int c = 0;
	 * for (int i = 1; i < k; i++) { int x = 0; boolean dm = false; while (x > 0) {
	 * long dig = x % 10; x = x / 10; if (dig == d) { dm = true; break; } } if (dm)
	 * ar.add(i); } }
	 */

	

// counts the set(1) bit of a number
	

//tells whether a particular index has which bit of a number	
	

	

	

//use collections.swap for swapping 
	

	

	

	// return the hash value of a string
	

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

public class hmm {

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


	public static void main(String[] args) throws Exception {
		int t =sc.nextInt();
		while (t-- > 0) {
             int n = sc.nextInt();
             int []k = sc.nextIntArray(n);
             int h[]=sc.nextIntArray(n);
     
             long mana = 0;
             pair cur = new pair(k[n-1]-h[n-1]+1,k[n-1]);
             for(int i=n-1;i>=0;i--) {
            	 int s = k[i];
            	 int start = s-h[i]+1;
            	 if(s>=cur.x) {
            		 cur.x = Math.min(start, cur.x);
            	 }
            	 else {
            		 long x = cur.y - cur.x +1;
            		 mana += x*(x+1)/2;
            		 cur.x = start;
            		 cur.y = s;
            	 }
             }
       
             long x = cur.y - cur.x +1;
       
    		 mana += x*(x+1)/2;
    		 pw.println(mana);
             
           
		}

		pw.close();

	}

	// -------------- stuff ------------------------------
	static class pair {
		int x ;
		int y;
	
		
		public pair(int n,int c) {
			x= n;
			y = c;
		
			
		}
	
	
		
	}

	

}
",1,Plagiarised
2b2d3b84,aaccc000,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Main
{



public static void main(String[] args)
{
   FastReader in = new FastReader();
   int t=in.nextInt();
   while(t-->0)
   {
       int n=in.nextInt();
       int k=in.nextInt();
       
       int a[]=new int[k];
       int ans[]=new int[n];
       int tem[]=new int[k];
       
       for(int i=0;i<k;i++)
           a[i]=in.nextInt();
       for(int  i=0;i<k;i++)
           tem[i]=in.nextInt();
       
      long c[]=new long[n];
      long l[]=new long[n];
      long r[]=new long[n];
      Arrays.fill(c,Integer.MAX_VALUE);
      Arrays.fill(l, Integer.MAX_VALUE);
      Arrays.fill(r,Integer.MAX_VALUE);
      
      long p=Integer.MAX_VALUE;
      for(int i=0;i<k;i++)
          c[a[i]-1]=tem[i];
      
      for(int i=0;i<n;i++)
      {
         p=Math.min(p+1,c[i]);
         l[i]=p;
      }
      p=Integer.MAX_VALUE;
      for(int i=n-1;i>=0;i--)
      {
         p=Math.min(p+1,c[i]);
         r[i]=p;
      }
    
       
      for(int i=0;i<n;i++)
          System.out.print(Math.min(l[i],r[i])+"" "");
      System.out.println();
   }
}
}
","import java.io.*;
import java.util.*;

public class GFG {
	public static void main (String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int t = sc.nextInt();
	    while(t-- > 0){
	        int n = sc.nextInt();
	        int k = sc.nextInt();
	        int[] a = new int[k];
	        int[] temp = new int[k];
	        for(int i=0;i<k;i++){
	            a[i] = sc.nextInt();
	        }
	        for(int i=0;i<k;i++){
	            temp[i] = sc.nextInt();
	        }
	        long[] c = new long[n];
	        Arrays.fill(c,Integer.MAX_VALUE);
	        for(int i=0;i<k;i++){
	            c[a[i]-1] = temp[i];
	        }
	        long p = Integer.MAX_VALUE;
	        long[] left = new long[n];
	        for(int i=0;i<n;i++){
	            p = (p+1<c[i])?p+1:c[i];
	            left[i] = p;
	        }
	        p = Integer.MAX_VALUE;
	        long[] right = new long[n];
	        for(int i=n-1;i>=0;i--){
	            p = (p+1<c[i])?p+1:c[i];
	            right[i] = p;
	        }
	        for(int i=0;i<n;i++){
	            long kl = (left[i]>right[i])?right[i]:left[i];
	            System.out.print(kl+"" "");
	        }
	        System.out.println();
	    }
	}
}
",1,Plagiarised
487c9f62,54488276,"import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) {
        scan = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

        int t = scan.nextInt();
        while (t-->0){
            solve();
        }

        out.close();
    }

    static void solve() {
        int n = scan.nextInt();
        int[][] words = new int[n][6];
        for (int i = 0; i < n; i++) {
            String input = scan.next();
            words[i][0] = input.length();
            for (int j = 0; j < input.length(); j++) {
                words[i][input.charAt(j)-96]++;
            }
            for (int j = 1; j <= 5; j++) {
                words[i][j] =  words[i][0] - 2*words[i][j];
            }
        }
        int maxCounter = 0;
        for (int i = 1; i <= 5; i++) {
            int[] arr = new int[n];

            for (int j = 0; j < n; j++) {
                arr[j] = words[j][i];
            }
            shuffleArray(arr);
            Arrays.sort(arr);
            int sum = 0;
            int counter = 0;
            while (counter < n && sum + arr[counter] < 0){
                sum += arr[counter];
                counter++;
            }
            maxCounter = Math.max(maxCounter, counter);
        }
        out.println(maxCounter);
    }

    private static void shuffleArray(int[] array)
    {
        int index, temp;
        Random random = new Random();
        for (int i = array.length - 1; i > 0; i--)
        {
            index = random.nextInt(i + 1);
            temp = array[index];
            array[index] = array[i];
            array[i] = temp;
        }
    }

    public static MyScanner scan;
    public static PrintWriter out;

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

public class C {
	static int n;
	public static void main (String[] args) throws IOException {
		FastReader io = new FastReader();
		int t = io.nextInt();
		for (int ii=0; ii<t; ii++) {
			n = io.nextInt();

			String[] arr = new String[n];

			for (int i=0; i<n; i++) {
				String str = io.next();
				arr[i] = str;
			}

			char[] chars = new char[]{'a','b','c','d','e'};

			int ans = -1;

			for (int i=0; i<5; i++) {
				ans = Math.max(ans, solve(arr, chars[i]));
			}
			System.out.println(ans);
		}
	}

	static int solve(String[] arr, char c) {
		//System.out.println(""Comparing based on "" + c);
		Arrays.sort(arr, new Comp(c));

		int good = 0;
		int total = 0;
		int ret = 0;

		for (int i=0; i<n; i++) {
			//System.out.println(good + "" "" + total);
			for (int j=0; j<arr[i].length(); j++) {
				if (arr[i].charAt(j) == c) good++;
			}
			total += arr[i].length();
			if (2 * good > total) {
				ret++;
			} else {
				return ret;
			}
		}

		return ret;
	}

	static class Comp implements Comparator<String> {
		char c;

		public Comp (char c) {
			this.c = c;
		}

		
	}
}
",0,Non-plagiarised
0b04b41e,4da08761,"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.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();
        }

        


        

    }

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

public class MinimumGridPath {
    
    static int mod = 1000000007;

    

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

    

    

    

    

    

    

    // (x^y)%p in O(logy)
    

    
    
    
    
    

    // TC- O(logmax(a,b))
    

    

    

    // TC- O(logmax(a,b))
    

    

     
}
","import java.util.*;


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

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

}


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

public class Main {

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

	
	
	

	
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class solution { 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(), k=s.nextInt();
			int[] a=s.readArray(k), temp=s.readArray(k);
			long[] ans=new long[n];
			Arrays.fill(ans, Integer.MAX_VALUE);
			for (int i=0; i<k; i++) {
				ans[a[i]-1]=temp[i];
			}
			for (int i=1; i<n; i++) {
				ans[i]=Math.min(ans[i],ans[i-1]+1);
			}
			for (int i=n-2; i>=0; i--) {
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for (int i=0; i<n; i++) {
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
    
    
    
    
    
    
    
}
",1,Plagiarised
584b0e9e,c9159d9c,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;


public class D_Round_753_Div3 {
    public static int MOD = 1000000007;

    static int[][] dp;


    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // ""output.txt"")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int T = in.nextInt();
        for (int z = 0; z < T; z++) {
            int n = in.nextInt();
            int[] data = new int[n];
            for (int i = 0; i < n; i++) {
                data[i] = in.nextInt();
            }
            String line = in.next();
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (line.charAt(i) == 'B') {
                    blue.add(data[i]);
                } else {
                    red.add(data[i]);
                }
            }
            Collections.sort(blue);
            Collections.sort(red);
            int st = 1;
            boolean ok = true;
            for (int i : blue) {
                if (i < st) {
                    ok = false;
                    break;
                }
                st++;
            }
            if (ok) {
                for (int i : red) {
                    if (i > st) {
                        ok = false;
                        break;
                    }
                    st++;
                }
            }
            out.println(ok ? ""Yes"" : ""No"");
        }
        out.close();
    }

    


    


    

    

    

    

    

    

    

    

    
}
","import java.util.*;

public class SolutionB {

    

    

    

    

    

    


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

        for(int i =0;i<t;i++) {
            int n = s.nextInt();
            int arr [] = new int[n];
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();

            for(int j=0;j<n;j++){
                int num = s.nextInt();
                arr[j]=num;
            }
            String color = s.next();

            for(int j=0;j<n;j++){
                if(color.charAt(j)=='B'){
                    blue.add(arr[j]);
                }
                else{
                    red.add(arr[j]);
                }
            }
            Collections.sort(blue);
            String ans = ""YES"";
            int counter = 0;

            for(int j=0;j<blue.size();j++){
                int current = blue.get(j);
                if (current<1){
                    ans=""NO"";
                    break;
                }
                if(current>counter){
                    counter++;
                }
                else{
                    ans=""NO"";
                    break;
                }

            }

            if(ans==""NO""){
                System.out.println(ans);
            }
            else{
                int tempCounter = n+1;
                Collections.sort(red);
                for(int j=red.size()-1;j>=0;j--){
                    int  current  = red.get(j);
                    if(current>=tempCounter){
                        ans=""NO"";
                        break;
                    }
                    else{
                        tempCounter--;
                    }
                }
                if(tempCounter-counter!=1)
                    System.out.println(""NO"");
                else
                    System.out.println(ans);
            }

        }

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

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

		int t = sc.nextInt();

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

			int n = sc.nextInt();

			HashMap<Integer, HashSet<Integer>> adj = new HashMap<>();
			HashMap<HashSet<Integer>, Integer> inv = new HashMap<>();
			boolean f = false;
			for ( int i=0; i<n-1; i++ ) {
				int u = sc.nextInt();
				int v = sc.nextInt();
				if ( adj.containsKey(u) ) {
					HashSet<Integer> s = adj.get(u);
					if ( s.size()>1 ) f = true;
					s.add(v);
					adj.put(u, s);
				} else {
					HashSet<Integer> s = new HashSet<>();
					s.add(v);
					adj.put(u, s);
				}
				if ( adj.containsKey(v) ) {
					HashSet<Integer> s = adj.get(v);
					if ( s.size()>1 ) f = true;
					s.add(u);
					adj.put(v, s);
				} else {
					HashSet<Integer> s = new HashSet<>();
					s.add(u);
					adj.put(v, s);
				}

				HashSet<Integer> si = new HashSet<>();
				si.add(u);
				si.add(v);
				inv.put(si, i);
			}

			if ( f ) {
				System.out.println(-1);
				continue;
			}

			String[] ans = new String[n-1];
			boolean g = false;
			ArrayDeque<Integer> q = new ArrayDeque<>();
			q.addLast(1);
			boolean[] seen = new boolean[n+1];
			while ( q.size()>0 ) {
				int v = q.removeLast();
				seen[v] = true;

				HashSet<Integer> s = adj.get(v);
				for ( int e : s ) {
					if ( seen[e] ) continue;

					HashSet<Integer> st = new HashSet<>();
					st.add(v);
					st.add(e);
					int pos = inv.get(st);
					if ( g ) {
						ans[pos] = ""3"";
					} else {
						ans[pos] = ""2"";
					}
					g = !g;
					q.addLast(e);
					break;
				}
			}

			g = true;
			q.addLast(1);
			while ( q.size()>0 ) {
				int v = q.removeLast();
				seen[v] = true;

				HashSet<Integer> s = adj.get(v);
				for ( int e : s ) {
					if ( seen[e] ) continue;

					HashSet<Integer> st = new HashSet<>();
					st.add(v);
					st.add(e);
					int pos = inv.get(st);
					if ( g ) {
						ans[pos] = ""3"";
					} else {
						ans[pos] = ""2"";
					}
					g = !g;
					q.addLast(e);
					break;
				}
			}

			System.out.println(String.join("" "", ans));
		}
	}
}
","import java.util.*;
import java.io.*;

public class Main {
    static FastScanner sc = new FastScanner(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static StringBuilder sb = new StringBuilder();
    static long mod = (long) 1e9 + 7;

    public static void main(String[] args) throws Exception {
        int t = sc.nextInt();
        for(int i = 0; i < t; i++) solve();
        pw.flush();
    }
    
    static ArrayList<ArrayList<int[]>> map;
    static int[] ans;
    public static void solve() {
        sb.setLength(0);
        int n = sc.nextInt();
        ans = new int[n-1];
        map = new ArrayList<>();
        for(int i = 0; i < n; i++){
            map.add(new ArrayList<>());
        }
        int[] cnt = new int[n];
        for(int i = 0; i < n-1; i++){
            int[] e = sc.nextIntArray(2);
            e[0]--;
            e[1]--;
            cnt[e[0]]++;
            cnt[e[1]]++;
            //edge.add(e);
            map.get(e[0]).add(new int[]{e[1],i});
            map.get(e[1]).add(new int[]{e[0],i});
        }
        for(int i = 0; i < n; i++){
            if(cnt[i] > 2){
                pw.println(-1);
                return;
            }
        }
        
        for(int i = 0; i < n; i++){
            if(cnt[i] == 1){
                ArrayDeque<int[]> dq = new ArrayDeque<>();
                boolean[] used = new boolean[n];
                used[i] = true;
                dq.add(new int[]{i,0});
                while(dq.size() > 0){
                    int[] now = dq.poll();
                    int u = now[0];
                    int c = now[1];
                    //System.err.println(u + "" "" + c + "" ""+ map.get(u).size());
                    for(int[] next : map.get(u)){
                        int v = next[0];
                        int ei = next[1];
                        //System.err.println(u + "" "" + v + "" "" + c + "" "" + ei);
                        if(!used[v]){
                            used[v] = true;
                            //System.err.println(u + "" "" + v + "" "" + c);
                            ans[ei] = c % 2 == 0 ? 3 : 2;
                            dq.add(new int[]{v,c+1});
                        }
                    }
                }
                for(int v : ans){
                    if(v == 0){
                        pw.println(-1);
                        return;
                    }
                    sb.append(v).append("" "");
                }
                pw.println(sb.toString().trim());
                return;
            }
        }
        pw.println(-1);
    }

    
}


",0,Non-plagiarised
4241f473,4685c420,"import java.io.*;
import java.util.*;

public class C {
	
	public static void main(String[] args)throws IOException {
		
		FastScanner scan = new FastScanner();
		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		int t = scan.nextInt();
		for(int tt = 0;tt<t;tt++) {
			
			int n = scan.nextInt();
			ArrayList<String> arr = new ArrayList<>();
			for(int i = 0;i<n;i++) arr.add(scan.next());
			int max = -1;
			for(int cases = 0;cases<5;cases++) {
				ArrayList<Integer> list = new ArrayList<>();
				char ch = (char)('a'+cases);
				for(int i = 0;i<n;i++) {
					String s = arr.get(i);
					int countch = 0, countTotal = 0;
					for(int j = 0;j<s.length();j++) {
						if(s.charAt(j)==ch) countch++;
						else countTotal++;
					}
					list.add(countch-countTotal);
				}
				Collections.sort(list);
				int sum = 0, count = 0;
				for(int i = n-1;i>=0;i--) {
					sum+=list.get(i);
					if(sum>0) count++;
					else break;
				}
				max = Math.max(max, count);
			}
			output.write(max+""\n"");
		}
		output.flush();

	}

	public static int[] sort(int arr[]) {

		List<Integer> list = new ArrayList<>();
		for(int i:arr)
			list.add(i);
		Collections.sort(list);
		for(int i = 0;i<list.size();i++) {
			arr[i] = list.get(i);
		}
		return arr;

	}
	
	
	
	

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class ProblemC {
    public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder print=new StringBuilder();
        int test=Integer.parseInt(br.readLine());
        while(test--!=0){
            int n=Integer.parseInt(br.readLine());
            ArrayList<Story> stories[]=new ArrayList[5];
            for(int i=0;i<5;i++){
                stories[i]=new ArrayList<>();
            }
            for(int i=1;i<=n;i++){
                char c[]=br.readLine().toCharArray();
                int freq[]=new int[5];
                for(int j=0;j<c.length;j++){
                    freq[c[j]-97]++;
                }
                for(int j=0;j<5;j++){
                    stories[j].add(new Story(freq[j],c.length-freq[j]));
                }
            }
            for(int i=0;i<5;i++){
                Collections.sort(stories[i]);
            }
            int max=0;
            for(int i=0;i<5;i++){
                int def=0;
                int count=0;
                for(Story story:stories[i]){
                    int diff=story.diff;
                    if(def+diff<=0){
                        break;
                    }
                    else{
                        def+=diff;
                        count++;
                    }
                }
                max=Math.max(max,count);
            }
            print.append(max+""\n"");
        }
        System.out.print(print);
    }
}

class Story implements Comparable<Story>{
    int x,y,diff;
    public Story(int x,int y){
        this.x=x;
        this.y=y;
        this.diff=this.x-this.y;
    }

    
}
",0,Non-plagiarised
2120328e,b790ef12,"import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static int mod=10000007;
   static StringBuilder sb=new StringBuilder();
    /* start */
       public static void main(String [] args)
    {
            int t = i();
            while(t-->0)
            {
                int n = i();
                int a[] = input(n);
                char c[] = inputC();
                ArrayList<Integer> b = new ArrayList<>();
                ArrayList<Integer> r = new ArrayList<>();
                for(int i=0;i<n;i++)
                {
                    if(c[i]=='R')
                    r.add(a[i]);
                    else 
                    b.add(a[i]);
                }
                Collections.sort(b);
                Collections.sort(r,Collections.reverseOrder());
                boolean is = true;
                int cnt = 1;
                for(int i=0;i<b.size();i++)
                {
                    if(b.get(i)<cnt)
                    {
                        is = false;
                        break;
                    }
                    cnt++;
                }
                for(int i=0;i<r.size();i++)
                {
                    if(r.get(i)>n-i)
                    {
                        is = false;
                        break;
                    }
                }

                out.println(is==true?""YES"":""NO"");
            }
            out.close();
    }

    
    /* end */
     

    
    static int i() {
        return sc.nextInt();
    }

    static String s() {
        return sc.next();
    }

    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

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

    

    

    
      
     

      

     
    
     

     
    
    

    
    
    
    
    
    
    
    
    

    

    

    

    

    

    

     

      
        //pair class
        
}
","import java.io.*;
import java.util.*;
public class Main {
    

    public static void main(String[] args) {
        FastReader obj = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int l = obj.nextInt();
        while (l-- != 0) {
            int n = obj.nextInt();
            int[] num = new int[n];
            for (int i = 0; i < n; i++) num[i] = obj.nextInt();
            Vector<Integer> red = new Vector<>();
            Vector<Integer> blue = new Vector<>();
            String s = obj.next();
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == 'R') red.add(num[i]);
                else blue.add(num[i]);
            }
            Collections.sort(blue);
            Collections.sort(red);
            int c = 1, f = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < c) {
                    f = 1;
                    break;
                }
                c++;
            }
            for (int i = 0; i < red.size(); i++) {
                if (red.get(i) > c) {
                    f = 1;
                    break;
                }
                c++;
            }
            if (f == 0) out.println(""YES"");
            else out.println(""NO"");
        }
        out.flush();
    }
}
",1,Plagiarised
8535bdf7,e86eb5b0,"import java.util.*;
import java.io.*;
import java.lang.*;
public class Problem {
    public static void dfs(int u, int parent, ArrayList<ArrayList<Integer>> graph,long[][] dp,Pair[] arr)
    {
        ArrayList<Integer> adja=graph.get(u);
        for(int i=0;i<adja.size();i++)
        {
            int adja_ele=adja.get(i);
            if(adja_ele!=parent)
            {
                dfs(adja_ele, u,graph,dp,arr);
                long res1=Math.max(Math.abs(arr[u].getL()-arr[adja_ele].getL())+dp[adja_ele][0],Math.abs(arr[u].getL()-arr[adja_ele].getR())+dp[adja_ele][1]);
                long res2=Math.max(Math.abs(arr[u].getR()-arr[adja_ele].getL())+dp[adja_ele][0],Math.abs(arr[u].getR()-arr[adja_ele].getR())+dp[adja_ele][1]);
                dp[u][0]+=res1;
                dp[u][1]+=res2;
//                System.out.println(u+"" ""+adja_ele+"" ""+res1+"" ""+res2);

            }
        }
    }



    public static void main(String[] args) throws IOException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int t =Integer.parseInt(br.readLine());
        while(t-- >0)
        {

            int n =Integer.parseInt(br.readLine().trim());
            Pair[] arr=new Pair[n+1];

            for(int i=1;i<n+1;i++) {
                String[] sa=br.readLine().trim().split("" "");
                int l=Integer.parseInt(sa[0]);
                int r=Integer.parseInt(sa[1]);
                Pair p=new Pair(l,r);
                arr[i]=p;
            }
            ArrayList<ArrayList<Integer>> graph=new ArrayList<ArrayList<Integer>>(n+1);
            for(int i=0;i<n+1;i++)
            {
               graph.add(new ArrayList<Integer>());
            }
            for(int i=0;i<n-1;i++)
            {
                String[] sa=br.readLine().trim().split("" "");
                int u=Integer.parseInt(sa[0]);
                int v=Integer.parseInt(sa[1]);
                graph.get(u).add(v);
                graph.get(v).add(u);
            }
            long[][] dp=new long[n+1][2];
            dfs(1,0,graph,dp,arr);
//            for(int i=0;i<dp.length;i++)
//            {
//                System.out.println(dp[i][0]+"" ""+dp[i][1]);
//            }
            System.out.println(Math.max(dp[1][0],dp[1][1]));
        }
    }

}
class Pair
{
    private int l;
    private int r;

    public Pair(int l, int r) {
        this.l = l;
        this.r = r;
    }

    public int getL() {
        return l;
    }

    

    public int getR() {
        return r;
    }

    
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;


public class Exam1 {
    /*
    1. Time complexity: O(t*n*logn).
    2. Space complexity: O(n).
    2. n*t < 10^8 , it should be finished in the time constraint.
     */

    static int[] l, r;
    static List<Integer>[] adj;
    static Long[][] a;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        int t = Integer.parseInt(s);
        while (t-- > 0) {
            s = br.readLine();
            int n = Integer.parseInt(s);
            l = new int[n];
            r = new int[n];
            for (int i = 0; i < n; i++) {
                s = br.readLine();
                String[] num = s.split("" "");
                l[i] = Integer.parseInt(num[0]);
                r[i] = Integer.parseInt(num[1]);
            }
            adj = new ArrayList[n];
            for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
            for (int i = 1; i < n; i++) {
                s = br.readLine();
                String[] num = s.split("" "");
                int u = Integer.parseInt(num[0]) - 1, v = Integer.parseInt(num[1]) - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            a = new Long[n][2];
            dfs(0, 0);
            System.out.println(Math.max(a[0][0], a[0][1]));
        }
    }
    private static void dfs(int cur, int fa) {
        a[cur][0] = a[cur][1] = 0L;
        for (int i = 0; i < adj[cur].size(); i++) {
            int p = adj[cur].get(i);
            if (p == fa) continue;
            dfs(p, cur);
            a[cur][0] += Math.max(a[p][0] + Math.abs(l[cur] - l[p]), a[p][1] + Math.abs(l[cur] - r[p]));
            a[cur][1] += Math.max(a[p][0] + Math.abs(r[cur] - l[p]), a[p][1] + Math.abs(r[cur] - r[p]));
        }
    }
}
",0,Non-plagiarised
5756162d,808f7516,"import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static int MOD = 1000000007;

    // After writing solution, quick scan for:
    //   array out of bounds
    //   special cases e.g. n=1?
    //
    // Big numbers arithmetic bugs:
    //   int overflow
    //   sorting, or taking max, after MOD
    void solve() throws IOException {
        int n = ri();
        int[] h = ril(n);
        
        List<List<Integer>> adj = new ArrayList<>(n);
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
        int[] nextGe = new int[n];
        nextGe[n-1] = n;
        for (int i = n-2; i >= 0; i--) {
            int j = i+1;
            while (j != n && h[j] < h[i]) j = nextGe[j];
            nextGe[i] = j;
        }
        int[] nextLe = new int[n];
        nextLe[n-1] = n;
        for (int i = n-2; i >= 0; i--) {
            int j = i+1;
            while (j != n && h[j] > h[i]) j = nextLe[j];
            nextLe[i] = j;
        }
        int[] prevGe = new int[n];
        prevGe[0] = -1;
        for (int i = 1; i < n; i++) {
            int j = i-1;
            while (j != -1 && h[j] < h[i]) j = prevGe[j];
            prevGe[i] = j;
        }
        int[] prevLe = new int[n];
        prevLe[0] = -1;
        for (int i = 1; i < n; i++) {
            int j = i-1;
            while (j != -1 && h[j] > h[i]) j = prevLe[j];
            prevLe[i] = j;
        }
        for (int i = 0; i < n; i++) {
            if (prevLe[i] != -1) adj.get(prevLe[i]).add(i);
            if (prevGe[i] != -1) adj.get(prevGe[i]).add(i);
            if (nextLe[i] != n) adj.get(i).add(nextLe[i]);
            if (nextGe[i] != n) adj.get(i).add(nextGe[i]);
        }

        int dist = 0;
        Deque<Integer> q = new ArrayDeque<>();
        boolean[] visited = new boolean[n];
        q.addLast(0);
        visited[0] = true;
        while (!q.isEmpty()) {
            int sz = q.size();
            for (int i = 0; i < sz; i++) {
                int u = q.removeFirst();
                if (u == n-1) {
                    q.clear();
                    break;
                }
                for (int v : adj.get(u)) {
                    if (!visited[v]) {
                        visited[v] = true;
                        q.addLast(v);
                    }
                }
            }
            dist++;
        }
        pw.println(dist-1);
    }

    // Template code below

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        Main m = new Main();
        m.solve();
        m.close();
    }

    void close() throws IOException {
        pw.flush();
        pw.close();
        br.close();
    }

    int ri() throws IOException {
        return Integer.parseInt(br.readLine());
    }

    

    int[] ril(int n) throws IOException {
        int[] nums = new int[n];
        int c = 0;
        for (int i = 0; i < n; i++) {
            int sign = 1;
            c = br.read();
            int x = 0;
            if (c == '-') {
                sign = -1;
                c = br.read();
            }
            while (c >= '0' && c <= '9') {
                x = x * 10 + c - '0';
                c = br.read();
            }
            nums[i] = x * sign;
        }
        while (c != '\n' && c != -1) c = br.read();
        return nums;
    }

    

    

    

    

    
}
","import java.util.*;
import java.io.*;
public class EdD {
	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
//	 		String input1 = bf.readLine().trim();
//	 		String input2 = bf.readLine().trim();
 		int n = Integer.parseInt(bf.readLine());
 		int[] array = new int[n];
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		for(int j = 0;j<n;j++){
 			array[j] = Integer.parseInt(st.nextToken());
 		}
 		Map<Integer, Set<Integer>> mp = new HashMap<Integer, Set<Integer>>();
 		for(int j =0;j<n;j++)
 			mp.put(j, new HashSet<Integer>());
 		int[] nextge = new int[n];
 		int[] nextle = new int[n];
 		int[] prevge = new int[n];
 		int[] prevle = new int[n];
 		nextge[n-1] = -1;
 		nextle[n-1] = -1;
 		prevge[0] = -1;
 		prevle[0] = -1;
 		for(int j = n-2;j>=0;j--){
 			if (array[j+1] < array[j]){
 				nextle[j] = j+1;
 				mp.get(j).add(j+1);
 				int temp = j+1;
 				while(temp!= -1 && array[temp] < array[j])
 					temp = nextge[temp];
 				nextge[j] = temp;
 				if (temp!= -1)
 					mp.get(j).add(temp);
 			}
 			else if (array[j+1] > array[j]){
 				nextge[j] = j+1;
 				mp.get(j).add(j+1);
 				int temp = j+1;
 				while(temp!= -1 && array[temp] > array[j])
 					temp = nextle[temp];
 				nextle[j] = temp;
 				if (temp!= -1)
 					mp.get(j).add(temp);
 			}
 			else{
 				nextge[j] = j+1;
 				mp.get(j).add(j+1);
 				nextle[j] = j+1;
 				mp.get(j).add(j+1);
 			}	
 		}
 		for(int j = 1;j<n;j++){
 			if (array[j] < array[j-1]){
 			
 				prevge[j] = j-1;
 				mp.get(j-1).add(j);
 				int temp = j-1;
 				while(temp!= -1 && array[temp] > array[j])
 					temp = prevle[temp];
 				prevle[j] = temp;
 				if (temp!= -1)
 					mp.get(temp).add(j);
 			}
 			else if (array[j] > array[j-1]){
 				prevle[j] = j-1;
 				mp.get(j-1).add(j);
 				int temp = j-1;
 				while(temp!= -1 && array[temp] < array[j])
 					temp = prevge[temp];
 				prevge[j] = temp;
 				if (temp!= -1)
 					mp.get(temp).add(j);
 			}
 			else{
 				prevge[j] = j-1;
 				prevle[j] = j-1;
 				mp.get(j-1).add(j);
 			}	
 		}
	 	int[] depth = new int[n+1];
 		Set<Integer> seen = new HashSet<Integer>();
 		Queue<Integer> bfs = new LinkedList<Integer>();
 		bfs.add(0);
 		seen.add(0);
 		while(!bfs.isEmpty()){
 			int v = bfs.remove();
 			for(int child : mp.get(v)){
 				if (!seen.contains(child)){
 					bfs.add(child);
 					seen.add(child);
 					depth[child] = depth[v]+1;
 				}
 			}
 		}
 		
 		
 		out.println(depth[n-1]);
	 		
 		out.close();
 		
 		
 		
 	}
}
",0,Non-plagiarised
317a209c,9ab3c0e1,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.util.*;

public class d {

    public static Scanner sc = new Scanner(System.in);
    public static final int MOD = 998244353;
    int []f; int [] lf;

    public static int mul(int a, int b) {
        return (int)((long)a * (long)b % MOD);
    }

    public static int ksm(int a, int n) {
        int ans = 1;
        while(n > 0) {
            if((n & 1) == 1)
                ans = mul(a, ans);
            a = mul(a, a);
            n >>= 1;
        }
        return ans;
    }

    public int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
    }

    public static int inv(int a) {
        return ksm(a, MOD - 2);
    }

    public void solve() {
        int n = sc.nextInt();
        int k = sc.nextInt();
        f = new int[n + 42];
        lf = new int[n + 42];
        f[0] = lf[0] = 1;
        for(int i = 1; i < f.length; i++) {
            f[i] = mul(f[i  - 1], i);
            lf[i] = mul(lf[i - 1], inv(i));
        }

        int[] events = new int[2 * n];
        for(int i = 0; i < n; i++) {
            int le = sc.nextInt();
            int ri = sc.nextInt();
            events[i] = le * 2;
            events[i + n] = ri * 2 + 1;
        }

        Arrays.sort(events);
        int ans = 0, balance = 0;
        for(int r = 0; r < 2 * n;) {
            int l = r;
            while(r < 2 * n && events[l] == events[r]) ++r;
            int added = r - l;
            if(events[l] % 2 == 0) {
                ans += C(balance + added, k);
                if(ans >= MOD) ans -= MOD;
                ans += MOD - C(balance, k);
                if(ans >= MOD) ans -= MOD;
                balance += added;
            }
            else balance -= added;
        }
        sc.close();
        System.out.println(ans);
    }

    public static void main(String[] args) {
        (new d()).solve();
    }
}
",1,Plagiarised
38b356b7,c77654b8,"import java.awt.*;
import java.io.*;
import java.util.*;

public class Main {
	static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
	static StringBuilder str = new StringBuilder();
	
	public static void main(String[] args) throws NumberFormatException, IOException {
		int t = Integer.parseInt(reader.readLine());
		while (t-- > 0) {
			solve();
		}
		printRes();
	}
	
	public static void printRes() {
		
		System.out.println(str);
	}

	public static void solve() throws IOException {
		int n = Integer.parseInt(reader.readLine());
		String[] s = reader.readLine().split("" "");
		int[] nums = new int[n];
		
		for (int i = 0; i < n; i++) {
			nums[i] = Integer.parseInt(s[i]);
		}
		
		int i = 0;
		
		if (n % 2 == 1) {
			if (nums[1] + nums[2] != 0) {
				str.append(-(nums[1] + nums[2]) + "" "" + nums[0] + "" "" + nums[0] + "" "");
			} else if (nums[0] + nums[2] != 0) {
				str.append(nums[1] + "" "" + -(nums[0] + nums[2]) + "" "" + nums[1] + "" "");
			} else {
				str.append(nums[2] + "" "" + nums[2] + "" "" + -(nums[0] + nums[1]) + "" "");
			}
			i = 3;
		}
		for (; i < n; i+=2) {
			if (nums[i] > 0 && nums[i+1] > 0) {
				str.append(nums[i+1] + "" "" + (-nums[i]) + "" "");
			} else if (nums[i] < 0 && nums[i+1] < 0) {
				str.append(nums[i+1] + "" "" + Math.abs(nums[i]) + "" "");
			} else {
				str.append(Math.abs(nums[i+1]) + "" "" + Math.abs(nums[i]) + "" "");
			}
		}
		str.append(""\n"");
	}
}
","import java.io.PrintWriter;
import java.util.*;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int tc = sc.nextInt();
        while(tc-->0){
            int n = sc.nextInt();
            int[] arr = new int[n]; for(int i = 0; i<n; i++)arr[i] = sc.nextInt();
            if(n % 2 == 0){
                for(int i = 0; i<n; i+=2){
                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
                }
                pw.println();
            }else{
                if(arr[0] + arr[1] != 0) pw.print(arr[2] + "" "" + arr[2] + "" "" + (-(arr[0] + arr[1])) + "" "");
                else if(arr[0] + arr[2] != 0)pw.println(arr[1] + "" "" + (-(arr[0] + arr[2]))+"" "" + arr[1]);
                else pw.println(-(arr[1] + arr[2]) + "" "" + arr[0]+"" "" + arr[0]);
                for(int i = 3; i<n; i+=2){
                    pw.print((-arr[i + 1]) + "" "" + arr[i] + "" "");
                }
                pw.println();
            }
        }
        pw.flush();
    }
}
",0,Non-plagiarised
1500a4fa,d7a8434f,"import java.io.*;
import java.util.*;

public class GFG {
	public static void main (String[] args) {
	Scanner sc=new Scanner(System.in);
	int t=sc.nextInt();
	while(t-->0){
	    int n=sc.nextInt();
	    String a=sc.next();
	    String b=sc.next();
	   int i;
	   int zero=0,one=0;
	     int x=0,y=0,x1=0,y1=0;
	    for(i=0;i<n;i++){
	        if(a.charAt(i)=='0')
	        zero++;
	        else
	        one++;
	    }
	    if(one==0){
	        if(a.equals(b))
	        System.out.println(""0"");
	        else
	        System.out.println(""-1"");
	    }
	    else{
	        int same=0,diff=0;
	        for(i=0;i<n;i++){
	            if(a.charAt(i)==b.charAt(i)){
	                same++;
	                x++;
	                if(a.charAt(i)=='1'){
	                    x1++;
	                    
	                }
	            }
	            else{
	                diff++;
	                y++;
	                if(a.charAt(i)=='1'){
	                    y1++;
	                    
	                }
	            }
	            
	        }
	        int ans=Integer.MAX_VALUE;
    if(x%2!=0&&(x+1)/2==x1){
        ans=x;
        
    }
    if(y%2==0&&(y/2)==y1){
ans=Math.min(ans,y);
    }
    if(ans==Integer.MAX_VALUE){
        
        System.out.println(""-1"");
        
    }else{
        
        System.out.println(ans);
    }
	       
	    }
	    
	}
	    
	}
    
}
","import java.util.*;
import java.io.*;
public class C {

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

}
",0,Non-plagiarised
25597bcb,5fcbdd19,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class PhoenixAndTowers { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        
    }

    

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int T = Integer.parseInt(f.readLine());
        for (int i = 0; i < T; i++) {
            StringTokenizer st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(f.readLine());
            List<Integer> list = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                int a = Integer.parseInt(st.nextToken());
                list.add(a);
            }
            ArrayList<Integer> copy = new ArrayList<>(list);
            Collections.sort(list);
            TreeSet<List<Integer>> set = new TreeSet<>(new ListComparator());
            for (int j = 1; j <= m; j++) {
                List<Integer> temp = new ArrayList<>();
                temp.add(0);
                temp.add(j);

                set.add(temp);
                // System.out.println(temp);
            }
            // System.out.println(set);
            Map<Integer, LinkedList<Integer>> map = new HashMap<>();
            for (int j = n - 1; j >= 0; j--) {
                if (map.containsKey(list.get(j))) {
                    map.get(list.get(j)).addLast(set.first().get(1));
                } else {
                    map.put(list.get(j), new LinkedList<>());
                    map.get(list.get(j)).addLast(set.first().get(1));
                }
                List<Integer> temp = new ArrayList<>();
                temp.add(set.first().get(0) + list.get(j));
                temp.add(set.pollFirst().get(1));
                set.add(temp);
            }
            // System.out.println(set);

            if (set.last().get(0) - set.first().get(0) > x) {
                out.println(""NO"");
            } else {
                out.println(""YES"");
                for (int j = 0; j < n; j++) {
                    out.print(map.get(copy.get(j)).pollFirst() + "" "");
                }
                out.println();
            }
        }
        out.close();
    }

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

public class C {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = in.nextInt();
        for (int t1 = 0; t1 < t; t1++) {
            int n = in.nextInt(), m = in.nextInt(), x = in.nextInt();
            ArrayList<Pair> list = new ArrayList<>();
            for (int i = 1; i <= n; i++) list.add(new Pair(in.nextInt(), i));
            pw.println(solve(list, n, m, x));
        }

        pw.close();
    }

    static StringBuilder solve(ArrayList<Pair> arr, int n, int m, int x) {
        Stack<Pair> stack = new Stack<>();
        HashMap<Integer, Integer> map = new HashMap<>();
        PriorityQueue<Pair> pq = new PriorityQueue<>();
        Collections.sort(arr);
        for (int i = m; i < n; i++) stack.push(arr.get(i));
        for (int i = 0, j = 1; i < m; i++, j++) {
            Pair p = arr.get(i);
            pq.add(new Pair(p.f, j));
            map.put(p.s, j);
        }
        while (!stack.isEmpty()) {
            Pair val = stack.pop();
            Pair p = pq.remove();
            map.put(val.s, p.s);
            pq.add(new Pair(p.f + val.f, p.s));
        }
      //  debug(pq);
        int min = pq.remove().f;
        while (!pq.isEmpty()) {
            int val = pq.remove().f;
            if ((val - min) > x) return new StringBuilder().append(""NO"");
        }
        StringBuilder sb = new StringBuilder();
        sb.append(""YES\n"");
        for (int i = 1; i <= n; i++) {
            sb.append(map.get(i) + "" "");
        }
        return sb;
    }

    static class Pair implements Comparable<Pair> {
        int f, s;

        Pair(int f, int s) {
            this.f = f;
            this.s = s;
        }

        

        
    }

    
}
",0,Non-plagiarised
c48673a6,ebed1250,"import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class C {
    public static void main(String[] args) {
        new C().solve(System.in, System.out);
    }

    public void solve(InputStream in, OutputStream out) {
        InputReader inputReader = new InputReader(in);
        PrintWriter writer = new PrintWriter(new BufferedOutputStream(out));

        int t = inputReader.nextInt();
        for (int t1 = 0; t1 < t; t1++) {
            int n = inputReader.nextInt();
            List<Long> c = new ArrayList<>(n);
            for (int i = 0; i < n; i++) {
                c.add(inputReader.nextLong());
            }
            writer.println(solve(n, c));
        }

        writer.close();
    }

    public long solve(int n, List<Long> c) {
        long[] minEven = new long[n];
        long[] minOdd = new long[n];
        long[] sumOdd = new long[n];
        long[] sumEven = new long[n];

        minEven[0] = Long.MAX_VALUE;
        minOdd[0] = Long.MAX_VALUE;

        for (int i = 0; i < n; i++) {
            if (i > 0) {
                minEven[i] = minEven[i - 1];
                minOdd[i] = minOdd[i - 1];
                sumOdd[i] = sumOdd[i - 1];
                sumEven[i] = sumEven[i - 1];
            }
            if (i % 2 == 0) {
                minEven[i] = Math.min(minEven[i], c.get(i));
                sumEven[i] += c.get(i);
            } else {
                minOdd[i] = Math.min(minOdd[i], c.get(i));
                sumOdd[i] += c.get(i);
            }
        }

        long best = Long.MAX_VALUE;
        for (int k = 1; k < n; k++) {
            int countOdd = (k + 1) / 2;
            int countEven = (k + 1) / 2;
            if (k % 2 == 0) {
                countEven++;
            }
            long oddResult = minOdd[k] * (n - countOdd) + sumOdd[k];
            long evenResult = minEven[k] * (n - countEven) + sumEven[k];
            long current = oddResult + evenResult;
            best = Math.min(best, current);
        }
        return best;
    }

    
}
","import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Main {

    private static void run() throws IOException {
        int n = in.nextInt();
        long[] c = new long[n];
        for (int i = 0; i < n; i++) {
            c[i] = in.nextInt();
        }

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

            int[] times = new int[2];
            times[index] = n - (i / 2 + 1);
            times[index ^ 1] = n - ((i - 1) / 2 + 1);
            ans = Math.min(ans, sum + min[0] * times[0] + min[1] * times[1]);
        }
        out.println(ans);
    }

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

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

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

    

    static final long mod = 1000000007;

    

    

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

    

    

    
}
",0,Non-plagiarised
00f79486,fb312dc6,"import java.util.*;

import java.io.*;  
public class Main
{
	
    PrintWriter out;
    FastReader sc;
    StringBuilder sb;
   
    /******************************************************************************************
     *****************************************************************************************/
    
	public void sol() {
		int n=ni();
		int[] ar=new int[n];
		for(int i=0;i<n;i++)ar[i]=ni();
		char[] s=rl();
		PriorityQueue<Integer> red=new PriorityQueue<>(Collections.reverseOrder()),blue=new PriorityQueue<>();
		for(int i=0;i<n;i++) {
			if(s[i]=='R')red.add(ar[i]);
			else blue.add(ar[i]);
		}
		int a=n;
		while(red.size()>0) {
			if(red.poll()>a) {
				no();return;
			}a--;
		}a=1;
		while(blue.size()>0) {
			if(blue.poll()<a) {
				no();return;
			}a++;
		}yes();
	}
    public static void main(String[] args) 
	{ 
	    Main g=new Main();
		g.out=new PrintWriter(System.out);
		g.sc=new FastReader();
		int t=1;
 		t=g.ni();
		while(t-->0)
		g.sol();
		g.out.flush();
	}
	
	/****************************************************************************************
     *****************************************************************************************/
	 public int ni(){
	      return sc.nextInt();
	}public char[] rl(){
	      return sc.nextLine().toCharArray();
	}
	public void pl(Object s){
	      out.println(s);
	}
	public String next(){
	      return sc.next();
	}
	
	
      
      
       
	 
	 
	
	
	
	
      
      void yes(){
            pl(""YES"");
      }void no(){
            pl(""NO"");
      }
      
    
     
    
    
    
      
	 
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class D {
    
    public static void main(String[] args)
    {
        FastScanner sc=new FastScanner();
        int t=sc.nextInt();
        PrintWriter pw=new PrintWriter(System.out);
        while(t-->0) {
            int n=sc.nextInt();
            int[] a=sc.readArray(n);
            char[] s=sc.next().toCharArray();
            boolean ok=true;
            ArrayList<Integer> blues=new ArrayList<>();
            ArrayList<Integer> reds=new ArrayList<>();
            for(int i=0;i<n;i++){
                if(s[i]=='B'){
                    blues.add(a[i]);
                } else {
                    reds.add(a[i]);
                }
            }
            Collections.sort(blues);
            Collections.sort(reds);
            for(int i=0;i<blues.size();i++){
                if(blues.get(i)<(i+1)){
                    ok=false;
                    break;
                }
            }
            int start=blues.size()+1;
            for(int i=0;i<reds.size();i++){
                if(reds.get(i)>(start++)){
                    ok=false;
                    break;
                }
            }
            if(ok){
               pw.println(""YES"");
            } else {
                pw.println(""NO"");
            }
        }
        pw.flush();
    }

    
}
",0,Non-plagiarised
3ef54b1a,bac616ee,"import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        FastIO fio = new FastIO();

        int t = fio.nextInt();

        for (int i = 0; i < t; i++) {
            int n = fio.nextInt();
            ArrayList<ArrayList<Tuple>> adjList = new ArrayList<>();

            for (int j = 0; j < n; j++) {
                adjList.add(new ArrayList<>());
            }

            for (int j = 0; j < n - 1; j++) {
                int u = fio.nextInt() - 1;
                int v = fio.nextInt() - 1;
                adjList.get(u).add(new Tuple(v, j));
                adjList.get(v).add(new Tuple(u, j));
            }

            boolean possible = true;

            for (ArrayList<Tuple> neighbours : adjList) {
                if (neighbours.size() > 2) {
                    possible = false;
                    break;
                }
            }

            if (!possible) {
                fio.println(-1);
                continue;
            }

            int[] assignments = new int[n - 1];
            boolean[] visited = new boolean[n];
            visited[0] = true;
            Queue<Integer> queue = new LinkedList<>();
            queue.offer(0);

            while (!queue.isEmpty()) {
                int u = queue.poll();
                List<Tuple> neighbors = adjList.get(u);

                for (int j = 0; j < neighbors.size(); j++) {
                    Tuple tt = neighbors.get(j);
                    int pi = j;

                    if (neighbors.size() == 2 && visited[neighbors.get(1 - j).v]) {
                        pi = 1 - assignments[neighbors.get(1 - j).num];
                    }

                    if (!visited[tt.v]) {
                        assignments[tt.num] = pi;
                        visited[tt.v] = true;
                        queue.offer(tt.v);
                    }
                }
            }

            for (int j = 0; j < n - 1; j++) {
                if (j > 0) {
                    fio.print("" "");
                }

                fio.print(assignments[j] == 0 ? 2 : 3);
            }

            fio.println();
        }

        fio.close();
    }
}

class Tuple {
    int v, num;

    Tuple(int v, int num) {
        this.v = v;
        this.num = num;
    }
}



/**
 * Fast I/O
 * @source https://www.geeksforgeeks.org/fast-io-in-java-in-competitive-programming/
 */

","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
2bbf754b,d9199dfd,"import java.util.*;

/** 
__                  __
( _)                ( _)
/ / \\              / /\_\_
/ /   \\            / / | \ \
/ /     \\          / /  |\ \ \
/  /   ,  \ ,       / /   /|  \ \
/  /    |\_ /|      / /   / \   \_\
/  /  |\/ _ '_| \   / /   /   \    \\
|  /   |/  0 \0\    / |    |    \    \\
|    |\|      \_\_ /  /    |     \    \\
|  | |/    \.\ o\o)  /      \     |    \\
\    |     /\\`v-v  /        |    |     \\
| \/    /_| \\_|  /         |    | \    \\
| |    /__/_ `-` /   _____  |    |  \    \\
\|    [__]  \_/  |_________  \   |   \    ()
/    [___] (    \         \  |\ |   |   //
|    [___]                  |\| \|   /  |/
/|    [____]                  \  |/\ / / ||
(  \   [____ /     ) _\      \  \    \| | ||
\  \  [_____|    / /     __/    \   / / //
|   \ [_____/   / /        \    |   \/ //
|   /  '----|   /=\____   _/    |   / //
__ /  /        |  /   ___/  _/\    \  | ||
(/-(/-\)       /   \  (/\/\)/  |    /  | /
(/\/\)           /   /   //
_________/   /    /
\____________/    (



*/

public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int  t=sc.nextInt();
		while(t-- >0) {
			int n=sc.nextInt();
			int[] arr=new int[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextInt();
			}
			String str=sc.next();
			
			ArrayList<Pair> plist=new ArrayList<>();
			for(int i=0;i<n;i++) {
				char ch=str.charAt(i);
				plist.add(new Pair(arr[i],ch));
			}
			
			//B-reduce
			//R-increse
			Collections.sort(plist);
			
			int counter=1;
			boolean flag=false;
			for(int i=0;i<plist.size();i++) {
				int val=plist.get(i).number;
				int clr=plist.get(i).color;
				
				if(clr=='B') {
					if(val<counter) {
						flag=true;
						break;
					}
				}
				else {
					if(val>counter) {
						flag=true;
						break;
					}
					
				}
				counter++;
			}
			System.out.println(flag?""NO"":""YES"");
			
			
		}
	}
	public static class Pair implements Comparable<Pair>{
		int number;
		char color;
		
		Pair(int number,char color){
			this.number=number;
			this.color=color;
		}
		
		
		
		
	}
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",0,Non-plagiarised
808f7516,9ebe348d,"import java.util.*;
import java.io.*;
public class EdD {
	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
//	 		String input1 = bf.readLine().trim();
//	 		String input2 = bf.readLine().trim();
 		int n = Integer.parseInt(bf.readLine());
 		int[] array = new int[n];
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		for(int j = 0;j<n;j++){
 			array[j] = Integer.parseInt(st.nextToken());
 		}
 		Map<Integer, Set<Integer>> mp = new HashMap<Integer, Set<Integer>>();
 		for(int j =0;j<n;j++)
 			mp.put(j, new HashSet<Integer>());
 		int[] nextge = new int[n];
 		int[] nextle = new int[n];
 		int[] prevge = new int[n];
 		int[] prevle = new int[n];
 		nextge[n-1] = -1;
 		nextle[n-1] = -1;
 		prevge[0] = -1;
 		prevle[0] = -1;
 		for(int j = n-2;j>=0;j--){
 			if (array[j+1] < array[j]){
 				nextle[j] = j+1;
 				mp.get(j).add(j+1);
 				int temp = j+1;
 				while(temp!= -1 && array[temp] < array[j])
 					temp = nextge[temp];
 				nextge[j] = temp;
 				if (temp!= -1)
 					mp.get(j).add(temp);
 			}
 			else if (array[j+1] > array[j]){
 				nextge[j] = j+1;
 				mp.get(j).add(j+1);
 				int temp = j+1;
 				while(temp!= -1 && array[temp] > array[j])
 					temp = nextle[temp];
 				nextle[j] = temp;
 				if (temp!= -1)
 					mp.get(j).add(temp);
 			}
 			else{
 				nextge[j] = j+1;
 				mp.get(j).add(j+1);
 				nextle[j] = j+1;
 				mp.get(j).add(j+1);
 			}	
 		}
 		for(int j = 1;j<n;j++){
 			if (array[j] < array[j-1]){
 			
 				prevge[j] = j-1;
 				mp.get(j-1).add(j);
 				int temp = j-1;
 				while(temp!= -1 && array[temp] > array[j])
 					temp = prevle[temp];
 				prevle[j] = temp;
 				if (temp!= -1)
 					mp.get(temp).add(j);
 			}
 			else if (array[j] > array[j-1]){
 				prevle[j] = j-1;
 				mp.get(j-1).add(j);
 				int temp = j-1;
 				while(temp!= -1 && array[temp] < array[j])
 					temp = prevge[temp];
 				prevge[j] = temp;
 				if (temp!= -1)
 					mp.get(temp).add(j);
 			}
 			else{
 				prevge[j] = j-1;
 				prevle[j] = j-1;
 				mp.get(j-1).add(j);
 			}	
 		}
	 	int[] depth = new int[n+1];
 		Set<Integer> seen = new HashSet<Integer>();
 		Queue<Integer> bfs = new LinkedList<Integer>();
 		bfs.add(0);
 		seen.add(0);
 		while(!bfs.isEmpty()){
 			int v = bfs.remove();
 			for(int child : mp.get(v)){
 				if (!seen.contains(child)){
 					bfs.add(child);
 					seen.add(child);
 					depth[child] = depth[v]+1;
 				}
 			}
 		}
 		
 		
 		out.println(depth[n-1]);
	 		
 		out.close();
 		
 		
 		
 	}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int[] h = new int[N];
            int[] hsort = new int[N];
            HashMap<Integer, Integer> condense = new HashMap<>();
            for (int i = 0; i < N; i++) {
                h[i] = in.nextInt();
                hsort[i] = h[i];
            }
            ArrayUtils.sort(hsort);
            int timer = 0;
            int[] t = new int[N];
            for (int i = 0; i < N; i++) {
                if (!condense.containsKey(hsort[i])) {
                    condense.put(hsort[i], timer++);
                    t[timer - 1]++;
                } else {
                    t[condense.get(hsort[i])]++;
                }
            }
            int[][] heights = new int[timer][];
            for (int i = 0; i < timer; i++) {
                heights[i] = new int[t[i]];
                t[i] = 0;
            }
            for (int i = 0; i < N; i++) {
                h[i] = condense.get(h[i]);
                heights[h[i]][t[h[i]]++] = i;
            }
            TreeSet<Integer> cur = new TreeSet<>();
            ArrayList<Integer>[] to = new ArrayList[N];
            for (int i = 0; i < N; i++) {
                to[i] = new ArrayList<>();
                if (i != N - 1) {
                    to[i].add(i + 1);
                }
            }
            int low = N + 1;
            int high = -1;
            for (int i = 0; i < timer; i++) {
                for (int e : heights[i]) {
                    cur.add(e);
                    low = Math.min(low, e);
                    high = Math.max(high, e);
                }
                for (int e : heights[i]) {
                    if (low < e) {
                        to[cur.lower(e)].add(e);
                    }
                    if (high > e) {
                        to[e].add(cur.higher(e));
                    }
                }
            }
            cur.clear();
            low = N + 1;
            high = -1;
            for (int i = timer - 1; i >= 0; i--) {
                for (int e : heights[i]) {
                    cur.add(e);
                    low = Math.min(low, e);
                    high = Math.max(high, e);
                }
                for (int e : heights[i]) {
                    if (low < e) {
                        to[cur.lower(e)].add(e);
                    }
                    if (high > e) {
                        to[e].add(cur.higher(e));
                    }
                }
            }
            long[] dp = new long[N];
            Arrays.fill(dp, (int) (1e8));
            dp[0] = 0;
            for (int i = 0; i < N; i++) {
                for (int toa : to[i]) {
                    dp[toa] = Math.min(dp[toa], dp[i] + 1);
                }
            }
            out.println(dp[N - 1]);
        }

    }

    

    static class ArrayUtils {
        public static void shuffle(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                int rand = (int) (Math.random() * (i + 1));
                swap(arr, i, rand);
            }
        }

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

        public static void sort(int[] arr) {
            shuffle(arr);
            Arrays.sort(arr);
            //get rid of quicksort cases
        }

    }
}
",0,Non-plagiarised
3d06b643,db7f80a5,"import java.io.*;
import java.util.*;

public class ArmChairs {
    

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

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

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

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

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

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


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

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

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

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

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

public class CodeForces {

    public static void main(String[] args) throws IOException {
        FastReader input = new FastReader();
        PrintWriter output = new PrintWriter(System.out);
        //BufferedReader bf = new BufferedReader(new FileReader(""input.txt""));
        //PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(""output.txt"")));
        //StringTokenizer stk = new StringTokenizer(bf.readLine());
        //int n=Integer.parseInt(stk.nextToken());
        int n=input.nextInt();
        ArrayList<Integer>seated=new ArrayList<>();
        ArrayList<Integer>empty=new ArrayList<>();
        for(int i=0;i<n;i++){
            int x=input.nextInt();
            if(x==1)
                seated.add(i);
            else
                empty.add(i);
        }
        if(seated.size()==0)
            output.println(0);
        else{
            output.println(helper(seated,empty));
        }
        output.close();
    }
    public static long helper(ArrayList<Integer>seated,ArrayList<Integer>empty){
        long dp[][]=new long[seated.size()+1][empty.size()+1];
        for(int i=1;i<= seated.size();i++){
            dp[i][i]=dp[i-1][i-1]+Math.abs(seated.get(i-1)-empty.get(i-1));
            for(int j=i+1;j<= empty.size();j++){
                dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(seated.get(i-1)-empty.get(j-1)));
            }
        }
        return dp[seated.size()][empty.size()];

    }

    

    

    
    
}







//Undirected Graph


//Directed non-weighted Graph


    
    
    
}
",1,Plagiarised
34b9ed7f,8311f375,"import java.io.*;
import java.util.*;

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

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


        int[] arr = new int[n + 1];
        boolean[] vis = new boolean[n + 1];

        for(int i = 1;i <= n;i++){
            if(vis[i]) continue;

            ArrayList<Integer> list = new ArrayList<>();
            while(true){
                System.out.println(""? "" + i);
                int val = Integer.parseInt(br.readLine());
                vis[val] = true;
                list.add(val);

                if(list.size() > 1 && val == list.get(0)) break;
            }

            for(int j = 0;j < list.size() - 1;j++) arr[list.get(j)] = list.get(j + 1);
//            arr[list.get(list.size() - 1)] = list.get(0);
        }

        System.out.print(""! "");
        StringBuilder ans = new StringBuilder();
        for(int i = 1;i <= n;i++) ans.append(arr[i]).append("" "");
        System.out.println(ans);


    }

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

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


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

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

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

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


        int[] arr = new int[n + 1];
        boolean[] vis = new boolean[n + 1];

        for(int i = 1;i <= n;i++){
            if(vis[i]) continue;

            ArrayList<Integer> list = new ArrayList<>();
            while(true){
                System.out.println(""? "" + i);
                int val = Integer.parseInt(br.readLine());
                vis[val] = true;
                list.add(val);

                if(list.size() > 1 && val == list.get(0)) break;
            }

            for(int j = 0;j < list.size() - 1;j++) arr[list.get(j)] = list.get(j + 1);
        }

        System.out.print(""! "");
        StringBuilder ans = new StringBuilder();
        for(int i = 1;i <= n;i++) ans.append(arr[i]).append("" "");
        System.out.println(ans);


    }

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

}
",1,Plagiarised
45f5632f,5dc1f7b3,"import java.io.*;
import java.util.*;


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

        double eps= 0.00000001;
        static final int MAXN = 10000001; 
       
        // stores smallest prime factor for every number 
        static int spf[] = new int[MAXN]; 

        Map<Integer,Set<Integer>> dp= new HashMap<>();
        
        // Calculating SPF (Smallest Prime Factor) for every 
        // number till MAXN. 
        // Time Complexity : O(nloglogn) 
         
        
        // 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;
    
}
","import java.io.*;
import java.util.*;

public class D {

	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

	public static void main(String[] args) throws IOException {
		readInput();
		out.close();
	}
	
	static List<Integer> o1, o0;
	static int[][] dp;
	
	static int solve(int i, int j) {
		if (i >= dp.length) return 0;
		if (j >= dp[0].length) return Integer.MAX_VALUE/10;
		
		if (dp[i][j] == -1) {
			dp[i][j] = Integer.min(solve(i,j+1), solve(i+1,j+1) + Math.abs(o1.get(i)-o0.get(j)));
		}
		return dp[i][j];
	}
	
	public static void readInput() throws IOException {
		// br = new BufferedReader(new FileReader("".in""));
		// out = new PrintWriter(new FileWriter("".out""));
		int n;
		n = Integer.parseInt(br.readLine());
		int[] a=  new int[n];
		StringTokenizer st = new StringTokenizer(br.readLine());
		o1 = new ArrayList<Integer>();
		o0 = new ArrayList<Integer>();
		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(st.nextToken());
			if (a[i] == 1) o1.add(i);
			else o0.add(i);
		}
		if (o1.size() == 0) {
			out.println(0);
			return;
		}
		dp = new int[o1.size()][o0.size()];
		for (int[] x: dp) Arrays.fill(x, -1);
		out.println(solve(0,0));
		
	}
}
",0,Non-plagiarised
54eb12ca,949502c2,"import java.io.*;
import java.util.*;
public class huge implements Runnable 
{
	private boolean console=false;
	
	ArrayList<Integer> adj[]; int maxi,maxc; int dis[];
	int vis[];
	Queue<Integer> q;
	public void solve() 
	{
		int i;
		int n=in.ni(); maxi=0; maxc=0;
		int a=in.ni()-1,b=in.ni()-1; 
		int da=in.ni(); int db=in.ni();
		adj=new ArrayList[n];
		for(i=0;i<n;i++)
			adj[i]=new ArrayList();
		for(i=0;i<n-1;i++)
		{
			int u=in.ni()-1; int v=in.ni()-1;
			adj[u].add(v); adj[v].add(u); 
		}
		maxc=maxi=0;
		vis=new int[n]; int cur=-1; dfs(1,cur);
		Arrays.fill(vis,0);
		cur=-1; maxc=0; dfs(maxi,cur);
		
		int d=(maxc);
		int ans=1;
		if(db<=2*da||2*da>=d||da>=db)
			ans=0;
		q= new LinkedList();
		vis=new int[n];
		q.add(a);
		dis=new int[n];
		dis[a]=0; int cu=0;
		while(!q.isEmpty()||vis[b]==0)
		{
			int v=q.poll();
			vis[v]=1;
			bfs(v);
		}
		if(dis[b]<=da)
			ans=0;
		if(ans==1)
			out.println(""Bob"");
		else
			out.println(""Alice"");
	}
	public void bfs(int v)
	{
		for(int node:adj[v])
		{
			if(vis[node]==0)
			{
				q.add(node);
				dis[node]=dis[v]+1;
			}
		}
	}
	public void dfs(int v,int cur)
	{
		cur++;
		if(cur>maxc)
		{
			maxc=cur; maxi=v;
		}
		vis[v]=1;
		for(int node:adj[v])
		{
			if(vis[node]==0)
				dfs(node,cur);
		}
	}
	@Override
	public void run() {
		try {  init();  } 
		catch (FileNotFoundException e) {  e.printStackTrace();   }

		int t= in.ni();

		while (t-->0) {
			solve();
			out.flush(); }
	}
	private FastInput in;    private PrintWriter out;
	public static void main(String[] args) throws Exception {	 new huge().run();	 }

	private void init() throws FileNotFoundException {
		InputStream inputStream = System.in; 	 OutputStream outputStream = System.out;
		try {  if (!console && System.getProperty(""user.name"").equals(""sachan"")) {
			outputStream = new FileOutputStream(""/home/sachan/Desktop/output.txt"");
			inputStream = new FileInputStream(""/home/sachan/Desktop/input.txt"");   	}
		}	catch (Exception ignored) {	}
		out = new PrintWriter(outputStream); 	 in = new FastInput(inputStream);
	}
	
}
","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);
}
",0,Non-plagiarised
d55c238c,ebce9e39,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class First {

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

    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            int n, m, x;
            n = in.nextInt();
            m = in.nextInt();
            x = in.nextInt();

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

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

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


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

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

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

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

            int[] answer = new int[n];

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

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

        }
    }

    

    

    static class answer implements Comparable<answer>{
        int a;
        int b;

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

        

        
    }

    

    

    static void sort(long[] a) {
        ArrayList<Long> l=new ArrayList<>();
        for (Long i:a) l.add(i);
        l.sort(Collections.reverseOrder());
        for (int i=0; i<a.length; i++) a[i]=l.get(i);
    }

    static final Random random=new Random();

    

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

public class First {

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

    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            int n, m, x;
            n = in.nextInt();
            m = in.nextInt();
            x = in.nextInt();

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

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

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


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

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

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

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

            int[] answer = new int[n];

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

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

        }
    }

    

    

    static class answer implements Comparable<answer>{
        int a;
        int b;

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

        

        
    }

    

    

    static void sort(long[] a) {
        ArrayList<Long> l=new ArrayList<>();
        for (Long i:a) l.add(i);
        l.sort(Collections.reverseOrder());
        for (int i=0; i<a.length; i++) a[i]=l.get(i);
    }

    static final Random random=new Random();

    

    
}
",1,Plagiarised
b2590225,fdcbdf85,"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.*;
import java.lang.*;

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

        

        
    }
    
    public static long add(long a, long b) {
        return ((a % MOD) + (b % MOD)) % MOD;
    }
    
    //Brian Kernighans Algorithm
    
    //Euclidean Algorithm
    
    //Modular Exponentiation
    
    //AKS Algorithm
    
    
    


    
}
",0,Non-plagiarised
8d9871a9,e431de28,"import java.util.*;

public class Main {
	static Scanner scan = new Scanner(System.in);

	static int[] readArray(int[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
		return x;
	}

	static long[] readArray(long[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
		return x;
	}


	

	public static void main(String[] args) {
		int t = scan.nextInt();
		for(int it=0; it<t; ++it) {
			int n = scan.nextInt();
			long[] aa = readArray(new long[n]);

			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
		}
	}
}
","import java.io.*;
import java.lang.*;
import java.util.*;
public class MinGridPath {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int t=s.nextInt();
		while(t-->0){
			
			int n = s.nextInt();
			long[] aa =new long[n];
			for(int i=0;i<n;i++)
				aa[i]=s.nextLong();
 
			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
			
		}
	}

}
",1,Plagiarised
6a47e491,f2cf6a74,"import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class InterestingStory {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            String[] a = new String[n];
            for (int i = 0; i < n; i++) {
                a[i] = scan.next();
            }
            int res = -1;
            int[] st = new int[n];
            for (int i = 0; i < n; i++) {
                String s = a[i];
                int c = 0;
                for (int j = 0; j < s.length(); j++) {
                    if (s.charAt(j) == 'a') {
                        ++c;
                    }
                }
                st[i] = ((s.length() - c) - c);
            }
            sort(st);
            long sum = 0;
            int count = 0;
            for (int i = 0; i < n; i++) {
                if (st[i] + sum >= 0) {
                    break;
                }
                sum += st[i];
                ++count;
            }
            res = Math.max(res, count);

            for (int i = 0; i < n; i++) {
                String s = a[i];
                int c = 0;
                for (int j = 0; j < s.length(); j++) {
                    if (s.charAt(j) == 'b') {
                        ++c;
                    }
                }
                st[i] = ((s.length() - c) - c);
            }
            sort(st);
            sum = 0;
            count = 0;
            for (int i = 0; i < n; i++) {
                if (st[i] + sum >= 0) {
                    break;
                }
                sum += st[i];
                ++count;
            }
            res = Math.max(res, count);

            for (int i = 0; i < n; i++) {
                String s = a[i];
                int c = 0;
                for (int j = 0; j < s.length(); j++) {
                    if (s.charAt(j) == 'c') {
                        ++c;
                    }
                }
                st[i] = ((s.length() - c) - c);
            }
            sort(st);
            sum = 0;
            count = 0;
            for (int i = 0; i < n; i++) {
                if (st[i] + sum >= 0) {
                    break;
                }
                sum += st[i];
                ++count;
            }
            res = Math.max(res, count);

            for (int i = 0; i < n; i++) {
                String s = a[i];
                int c = 0;
                for (int j = 0; j < s.length(); j++) {
                    if (s.charAt(j) == 'd') {
                        ++c;
                    }
                }
                st[i] = ((s.length() - c) - c);
            }
            sort(st);
            sum = 0;
            count = 0;
            for (int i = 0; i < n; i++) {
                if (st[i] + sum >= 0) {
                    break;
                }
                sum += st[i];
                ++count;
            }
            res = Math.max(res, count);

            for (int i = 0; i < n; i++) {
                String s = a[i];
                int c = 0;
                for (int j = 0; j < s.length(); j++) {
                    if (s.charAt(j) == 'e') {
                        ++c;
                    }
                }
                st[i] = ((s.length() - c) - c);
            }
            sort(st);
            sum = 0;
            count = 0;
            for (int i = 0; i < n; i++) {
                if (st[i] + sum >= 0) {
                    break;
                }
                sum += st[i];
                ++count;
            }
            res = Math.max(res, count);
            System.out.println(res);

        }
    }

    static final Random random = new Random();

    static void sort(int[] a) {
        int n = a.length;//shuffle, then sort 
        for (int i = 0; i < n; i++) {
            int oi = random.nextInt(n), temp = a[oi];
            a[oi] = a[i];
            a[i] = temp;
        }
        Arrays.sort(a);
    }
}
","import java.util.*;
public class shivam{
    public static int diff(String str, char ch){
        int cnt=0;
        for(int i=0;i<str.length();i++){
            if(ch==str.charAt(i)){
                cnt++;
            }
        }
        return cnt-(str.length()-cnt);
    }
    public static int process(char ch,int n,String  []arr){
        int[]a=new int[n];
            for(int i=0;i<n;i++){
                a[i]=diff(arr[i],ch);
            }
            Arrays.sort(a);
            int max=0;
            int sum=0;
            for(int i=n-1;i>=0;i--){
                sum+=a[i];
                if(sum>0){
                    max++;
                }
                else{
                    break;
                }
            }





        return max;
    }


    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int k=sc.nextInt();
        while(k-->0){
            int n=sc.nextInt();
            String []arr=new String[n];
            for(int i=0;i<n;i++){
                arr[i]=sc.next();
            }
            int a=process('a',n,arr);
            int b=process('b',n,arr);
            int c=process('c',n,arr);
            int d=process('d',n,arr);
            int e=process('e',n,arr);
            System.out.println(Math.max(a,Math.max(b,Math.max(c,Math.max(d,e)))));
           
        }

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

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

	

	

	

	static long mod = 1000000007;
	static Random rn = new Random();
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
}
","import java.util.*;
import java.io.*;
public class C1615{
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-->0) {
			int n = fs.nextInt();
			String a = fs.next();
			String b = fs.next();
			char ch1[] = a.toCharArray();
			char ch2[] = b.toCharArray();
			int c00 = 0;
			int c01 = 0;
			int c10 = 0;
			int c11 = 0;
			for(int i=0;i<n;i++){
				if(ch1[i]=='0'){
					if(ch2[i]=='0'){
						c00+=1;
					}
					else{
						c01+=1;
					}
				}
				else{
					if(ch2[i]=='0'){
						c10+=1;
					}
					else{
						c11+=1;
					}
				}
			}
			int ans = -1;
			if((c11-c00)==1 || c10==c01){
				int s1 = (int)1e7; 
				int s2 = (int)1e7;
				if((c11-c00)==1){
					s1 = c11+c00;
				}
				if(c10==c01)
				s2 = c10+c01;
				ans = Math.min(s1,s2); 
			}
			out.println(ans);
		}
		out.close();
	}
	
	
}
",0,Non-plagiarised
3088ca9c,6f393cfe,"import java.util.*;
import java.io.*;


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

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
",1,Plagiarised
b790ef12,ff34fab2,"import java.io.*;
import java.util.*;
public class Main {
    

    public static void main(String[] args) {
        FastReader obj = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int l = obj.nextInt();
        while (l-- != 0) {
            int n = obj.nextInt();
            int[] num = new int[n];
            for (int i = 0; i < n; i++) num[i] = obj.nextInt();
            Vector<Integer> red = new Vector<>();
            Vector<Integer> blue = new Vector<>();
            String s = obj.next();
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == 'R') red.add(num[i]);
                else blue.add(num[i]);
            }
            Collections.sort(blue);
            Collections.sort(red);
            int c = 1, f = 0;
            for (int i = 0; i < blue.size(); i++) {
                if (blue.get(i) < c) {
                    f = 1;
                    break;
                }
                c++;
            }
            for (int i = 0; i < red.size(); i++) {
                if (red.get(i) > c) {
                    f = 1;
                    break;
                }
                c++;
            }
            if (f == 0) out.println(""YES"");
            else out.println(""NO"");
        }
        out.flush();
    }
}
","import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.*;
 
public class Div2 {
	
	

	 public static String solution(int [] arr, int n, String st) 
	 {
        ArrayList<Integer> red = new ArrayList<>();
        ArrayList<Integer> blue = new ArrayList<>();
        
        for(int i = 0; i<n; i++)
        {
        	if(st.charAt(i)=='R')
        		red.add(arr[i]);
        	else
        		blue.add(arr[i]);
        }
	    	
        Collections.sort(red);
        Collections.sort(blue);
        int cb = 1;
        
        for(int j = 0; j<blue.size(); j++)
        {
            if(blue.get(j)<cb)
            	return ""NO"";
            cb++;
        }
        
        int cr = n;
        for(int j = red.size()-1; j>=0; j--)
        {
            if(red.get(j)>cr)
            	return ""NO"";
            cr--;
        }
        
        return ""YES"";

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

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
	  
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	String st = s.next();
   
    	out.println(solution(arr,n, st));
    }
    
		     
    out.flush();
    out.close();
    
}
}
",0,Non-plagiarised
07749c65,2bbf754b,"import java.io.*;
import java.util.*;


public class Nov1P4 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        long o = sc.nextInt();
        for(long i = 0; i < o; i++)
        {
            int n = sc.nextInt();
            long[] m = new long[n];
            for(int j = 0; j < n; j++)
            {
                m[j] = sc.nextLong();
            }
            String str = sc.nextLine();
            ArrayList<Long> a = new ArrayList<Long>();
            ArrayList<Long> b = new ArrayList<Long>();

            for(int j = 0; j < n; j++)
            {
                if(str.charAt(j) == 'B')
                {
                    b.add(m[j]);
                }
                else
                {
                    a.add(m[j]);
                }
            }
            Collections.sort(a);
            Collections.sort(b);
            boolean tf = true;
            for(int j = 0; j < b.size(); j++)
            {
                if(b.get(j) < (j+1) && tf)
                {
                    out.println(""NO"");
                    tf = false;
                }
            }
            for(int j = 0; j < a.size(); j++)
            {
                if(a.get(j) > j+1+b.size() && tf)
                {
                    out.println(""NO"");
                    tf = false;
                }
            }
            if(tf)
                out.println(""YES"");
        }
        // Start writing your solution here. -------------------------------------

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as String
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter
      */

        // Stop writing your solution here. -------------------------------------
        out.close();
    }


    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    
    //--------------------------------------------------------
}
","import java.util.*;

/** 
__                  __
( _)                ( _)
/ / \\              / /\_\_
/ /   \\            / / | \ \
/ /     \\          / /  |\ \ \
/  /   ,  \ ,       / /   /|  \ \
/  /    |\_ /|      / /   / \   \_\
/  /  |\/ _ '_| \   / /   /   \    \\
|  /   |/  0 \0\    / |    |    \    \\
|    |\|      \_\_ /  /    |     \    \\
|  | |/    \.\ o\o)  /      \     |    \\
\    |     /\\`v-v  /        |    |     \\
| \/    /_| \\_|  /         |    | \    \\
| |    /__/_ `-` /   _____  |    |  \    \\
\|    [__]  \_/  |_________  \   |   \    ()
/    [___] (    \         \  |\ |   |   //
|    [___]                  |\| \|   /  |/
/|    [____]                  \  |/\ / / ||
(  \   [____ /     ) _\      \  \    \| | ||
\  \  [_____|    / /     __/    \   / / //
|   \ [_____/   / /        \    |   \/ //
|   /  '----|   /=\____   _/    |   / //
__ /  /        |  /   ___/  _/\    \  | ||
(/-(/-\)       /   \  (/\/\)/  |    /  | /
(/\/\)           /   /   //
_________/   /    /
\____________/    (



*/

public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int  t=sc.nextInt();
		while(t-- >0) {
			int n=sc.nextInt();
			int[] arr=new int[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextInt();
			}
			String str=sc.next();
			
			ArrayList<Pair> plist=new ArrayList<>();
			for(int i=0;i<n;i++) {
				char ch=str.charAt(i);
				plist.add(new Pair(arr[i],ch));
			}
			
			//B-reduce
			//R-increse
			Collections.sort(plist);
			
			int counter=1;
			boolean flag=false;
			for(int i=0;i<plist.size();i++) {
				int val=plist.get(i).number;
				int clr=plist.get(i).color;
				
				if(clr=='B') {
					if(val<counter) {
						flag=true;
						break;
					}
				}
				else {
					if(val>counter) {
						flag=true;
						break;
					}
					
				}
				counter++;
			}
			System.out.println(flag?""NO"":""YES"");
			
			
		}
	}
	public static class Pair implements Comparable<Pair>{
		int number;
		char color;
		
		Pair(int number,char color){
			this.number=number;
			this.color=color;
		}
		
		
		
		
	}
}
",0,Non-plagiarised
464ad4dd,9291ca83,"import java.io.*;
import java.util.*;
public class Solution{
    public static int in = 0, count=0;
    static class comparator implements Comparator<int[]>{
        
    }
    public static int solve(ArrayList<int[]> al, int[] total){
        ArrayList<int[]> c = (ArrayList<int[]>) al.clone();
        java.util.Collections.sort(c, new comparator());

        int i= al.size()-1;
        int sum=0; for(int ii:total) sum+=ii;
        int check = total[in];
        sum-=check;
        for(; i>=0; i--){
            if(check>sum) return i+1;
            else{
                int newSum=0; for(int ii:c.get(i)) newSum+=ii;
                newSum-=c.get(i)[in];
                sum-=newSum;
                check-=c.get(i)[in];
            }
        }
        return 0;
    }
    public static void main (String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        int testCase = sc.nextInt();
        while (testCase-->0){
            int n = sc.nextInt();
            String[] strArr = new String[n];
            for(int i=0; i<n; i++) {
                strArr[i]=sc.nextLine();
            }
            int[] total = new int[5];
            ArrayList<int[]> al = new ArrayList<>();
            for(int i=0; i<n; i++){
                int[] arr= new int[5];
                for(int j=0; j<strArr[i].length(); j++){
                    arr[strArr[i].charAt(j)-'a']++;
                }
                for(int j=0; j<5; j++){
                    total[j]+=arr[j];
                }
                al.add(arr);
            }
            int ans = Integer.MIN_VALUE;
            for(int i=0; i<5; i++) {
                in = i;
                ans = Math.max(solve(al, total), ans);
                count=0;
            }
            System.out.println(ans);
        }
    }
    // Fast Reader Class
    
}
","import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Practice {
    static HashMap<String, Integer> map = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            int[][] occurances = new int[5][n];
            for(int i=0;i<n;i++){
                String s = sc.next();
                int[] count = new int[5];
                int len = s.length();
                for(int j=0;j<s.length();j++){
                    count[s.charAt(j)-'a']++;
                }
                for(int j=0;j<5;j++){
                    occurances[j][i] = count[j] - (len-count[j]);
                }
            }
            int ans = 0;
            for(int i=0;i<5;i++){
                Arrays.sort(occurances[i]);
                int tmpAns = 0; int tmpSum=0;
                for(int j=n-1;j>=0;j--){
                    tmpSum+=occurances[i][j];
                    if(tmpSum>0) tmpAns++;
                    else break;
                }
                ans = Math.max(ans, tmpAns);
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
35bb6075,42fe7dd0,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.util.*;

public class Main {

    static final long M = 1000000007;

    // use main for only io
    public static void main(String args[]) {
        FastReader io = new FastReader();
        new Solver().solve(io);
    }
}

//class Pair{
//    int key;String value;
//
//    public Pair(int key, String value){
//        this.key = key;
//        this.value = value;
//    }
//}



class Solver {
    static final int M = 998244353;

    void solve(FastReader io) {
       int t = io.nextInt();

       while(t-- > 0){
           int n = io.nextInt();

           String s[] = new String[n];

           for(int i = 0;i < n;i++)s[i] = io.nextLine();

           int ans = 0;

           for(int i = 0;i < 5;i++){
               int count[] = new int[n];

               for(int j = 0;j < n;j++){
                   int freq = 0;
                   for(int k = 0;k < s[j].length();k++){
//                       System.out.println(s[j].charAt(k) - 'a');
                       if((s[j].charAt(k) - 'a') == i){

                           freq++;
                       }
                   }
//                    System.out.println(i + "" "" + freq);
                   count[j] = 2*freq - s[j].length();
               }


               Arrays.sort(count);
//                for(int it : count)System.out.print(it + "" "");
//                System.out.println();

               int curr = 0;
               int j = n - 1;
               for(;j >= 0 && (curr + count[j] > 0);j--){
                   curr += count[j];
               }

               ans = Math.max(ans, n - j - 1);

           }

           System.out.println(ans);
       }
    }

    // returns the first key greater than or equal to val
    

    // returns the first key strictly greater than val
    
    

    

    

    

    

    

    
}



","import java.util.*;
 public class Solution {
    static Scanner sc=new Scanner(System.in);
    public static void main(String args[]) {
      int t=sc.nextInt();
      outer:while(t-->0){
        int n=sc.nextInt();
        int[][] ct=new int[n][5];
        int[] len=new int[n];
        for (int i=0;i<n;i++) {
            String s=sc.next();
            len[i]=s.length();
            for(char c:s.toCharArray()){
                ct[i][c-'a']++;
            }
        }
        int mx=0;
        for (int i=0;i<5;i++) {
            int[] diff=new int[n];
            for (int j=0;j<n;j++) {
                diff[j]=ct[j][i]-(len[j]-ct[j][i]);
            }
            Arrays.sort(diff);
            int sum=0,inc=0;
            for(int j=n-1;j>=0;j--){
                sum+=diff[j];
                if (sum>0) {
                    inc++;
                }else {
                    break;
                }
            }
            mx=Math.max(mx,inc);
        }
        System.out.println(mx);
        }
        
      }

    }
",0,Non-plagiarised
2e404969,597195ee,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Codechef {
	static long fans[] = new long[200001];
	static long inv[] = new long[200001];
	static long mod = 1000000007;

	

	

	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.Arrays;
import java.util.StringTokenizer;

public class C_MonstersAndSpells_1700 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while(t-->0) {
            int n = sc.nextInt();
            int[] times = new int[n];
            int[] health = new int[n];
            for(int i = 0; i < n; i++) {
                times[i] = sc.nextInt();
            }
            for(int i = 0; i < n; i++) {
                health[i] = sc.nextInt();
            }
            Point[] points = new Point[n];
            for(int i = 0; i < n; i++) {
                points[i] = new Point(times[i]-health[i], times[i]);
            }
            Arrays.sort(points);
            long ans = 0;
            for(int i = 0; i < n; i++) {
                int j = i+1;
                int latestTime = points[i].time;
                while(j < n && points[j].startBy < latestTime) {
                    latestTime = Math.max(latestTime, times[j]);
                    j++;
                }
                long length = latestTime-points[i].startBy;
                ans += (length*(length + 1))/2;
                i = j - 1;
            }
            System.out.println(ans);
        }

        out.close();
    }

    static class Point implements Comparable<Point> {
        Integer startBy;
        Integer time;

        Point(int startBy, int time) {
            this.startBy = startBy;
            this.time = time;
        }

        
    }

    public static PrintWriter out;

    
    
}
",0,Non-plagiarised
04df7bb8,1ea771ea,"import java.math.BigInteger;
										import java.sql.Array;
									    import java.util.ArrayList;
										import java.util.Arrays;
										import java.util.Collection;
										import java.util.Collections;
										import java.util.Comparator;
										import java.util.Deque;
										import java.util.HashMap;
										import java.util.HashSet;
										import java.util.InputMismatchException;
										import java.util.LinkedList;
										import java.util.PriorityQueue;
										import java.util.Queue;
										import java.util.Scanner;
										import java.util.Set;
										import java.util.Stack;
										import java.io.BufferedReader;
										import java.io.IOException;
										import java.io.InputStream;
										import java.io.InputStreamReader;
										import java.util.Scanner;
										import java.util.StringTokenizer;
										import java.util.TreeMap;
										import java.util.TreeSet;
										
											
											
											
											
											
											public class Main {
							
												
												static HashMap<Integer,Boolean>map;
												
											static long dp[][];
											static 	boolean flag;
										static	HashSet<Long>hs;
											static long mod=(long)(1e9+7);
												public static void main(String[] args) {
												StringBuilder ans=new StringBuilder();
												FastReader sc=new FastReader();
													
												
												int t=sc.nextInt();
												
												
												while(t-->0) {
													
													int n=sc.nextInt();
													
													
													//int n=sb.length();
													
													
													
													int k=sc.nextInt();
													
													
													long L[]=new long[n];
													long R[]=new long[n];
													int a[]=new int[k];
													int temp[]=new int[k];
													
													for(int i=0;i<k;i++)
														a[i]=sc.nextInt();
													
													for(int i=0;i<k;i++)
														temp[i]=sc.nextInt();
													
													int c[]=new int [n];
													Arrays.fill(c, Integer.MAX_VALUE);
													for(int i=0;i<k;i++)
														c[a[i]-1]=temp[i];
												
													long p=Integer.MAX_VALUE;
													
													for(int i=0;i<n;i++)
													{
														p=Math.min(p+1, c[i]);
														
														L[i]=p;
														
														
													}
													p=Integer.MAX_VALUE;
													for(int i=n-1;i>=0;i--)
													{
														p=Math.min(p+1, c[i]);
														
														R[i]=p;
														
														
													}
													
													for(int i=0;i<n;i++)
													{
														ans.append(Math.min(L[i], R[i])+"" "");
													}
											ans.append(""\n"");
													
												}
												System.out.println(ans);
												
												}
													
											
													


												
												
							
												
												
												
												
												
												
												
												
											
												
												
												
												
												
												
												
												
												
												
												
												
												
													
													
												
												
												
												
												
												
												
												
												
												
												
												
												
												
												
									
												
												
											
												
										
												
												
												
												
												
											 
												
											 
												
												
												
											
												
											
												
												
												
												
												
												 
												  
												
												   
												
									
												//System.out.println(count);
												
											
												
												
												
												
												
												
										
										
												
										
												
												
												
												
												//	System.out.println(max);
										
												
											
												
											
									
				//System.out.println(ans.toString());
				//main(						
											
							
					
				
						
												
												
												
								
												
								
												
												
								
												
												
												
												
												
												
												
									
									
												
												
												
												
								
								
								
							
								
									
												
												
												
								
												
												
												
									
							
												
									
									
												
												
												
												
												
												
												
												
												
												
												
									
										
										
										
										
				
				
					
				
				
										
											
																					
											
									    
									 
										
											}
","import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
",1,Plagiarised
36f1b52a,558df7d4,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Solution {
    public static void main(String[] args) throws java.lang.Exception {
        out = new PrintWriter(new BufferedOutputStream(System.out));
        sc = new FastReader();

        int test = sc.nextInt();
        for (int t = 0; t < test; t++) {
            solve();
        }
        out.close();
    }

    private static void solve() {
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        int[] res = new int[n];
        if (n % 2 == 0) {
            for (int i = 1; i < n; i += 2) {
                res[i] = arr[i - 1];
                res[i - 1] = -arr[i];
            }
        }else {
            for (int i = 4; i < n; i += 2) {
                res[i] = arr[i - 1];
                res[i - 1] = -arr[i];
            }

            if (arr[0] + arr[1] != 0) {
                res[0] = -arr[2];
                res[1] = -arr[2];
                res[2] = arr[0] + arr[1];
            }else if (arr[0] + arr[2] != 0) {
                res[0] = -arr[1];
                res[2] = -arr[1];
                res[1] = arr[0] + arr[2];
            }else {
                res[1] = -arr[0];
                res[2] = -arr[0];
                res[0] = arr[1] + arr[2];
            }
        }

        for (int i = 0; i < n; i++) {
            out.print(res[i] + "" "");
        }
        out.println();
    }


    public static FastReader sc;
    public static PrintWriter out;
    
}
","import java.io.*;
import java.util.*;
public class Pupsen {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i=0; i<n; i++) {
				a[i] = in.nextInt();
			}
			int[] b = new int[n];
			if (n%2==0) {
				for (int i=0; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			else {
				if (a[0]+a[1]!=0) {
					b[0] = -a[2];
					b[1] = -a[2];
					b[2] = a[0]+a[1];
				}
				else if (a[0]+a[2]!=0) {
					b[0] = -a[1];
					b[2] = -a[1];
					b[1] = a[0]+a[2];
				}
				else {
					b[1] = -a[0];
					b[2] = -a[0];
					b[0] = a[1]+a[2];
				}
				for (int i=3; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			System.out.println();
		}
	}
	
}
",1,Plagiarised
46e9aed4,ee4f7b06,"import java.util.*;

import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public final class Solution {
    

    public static void main(String[] args) throws Exception {
        
        Reader sc = new Reader();
        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
         
         int n=sc.nextInt();
          ArrayList<Integer> fill= new ArrayList<Integer>();
          ArrayList<Integer> unfilled= new ArrayList<>();
          for(int i=0;i<n;i++){
              int x =sc.nextInt();
              if(x==1){
                  fill.add(i);
              }else{
                  unfilled.add(i);
              }
          }
          Collections.sort(fill);
          Collections.sort(unfilled);
          
          
          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
           for(int i=0;i<fill.size()+1;i++){
              for(int j=0;j<unfilled.size()+1;j++){
                  dp[i][j]=Integer.MAX_VALUE;
              }
          }
          for(int i=0;i<unfilled.size()+1;i++){
              dp[0][i]=0;
          }
        //   for(int j=0;j<fill.size()+1;j++){
        //       dp[j][0]=0;
        //   }
         

          for(int i=1;i<fill.size()+1;i++){
              for(int j=1;j<unfilled.size()+1;j++){
                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
              }
          }
          System.out.println(dp[fill.size()][unfilled.size()]);
        //   for(int i=0;i<fill.size()+1;i++){
        //       for(int j=0;j<unfilled.size()+1;j++)
        //       {
        //           System.out.print(dp[i][j]+"" "");
        //       }
        //       System.out.println();
        //   }
         
    }




   
    }


","import java.io.*;
    import java.util.*;
    import java.lang.Math;


    public class Main {

          static Scanner sc;
          static StringBuilder ans;


          /*-------------- for input in an value ---------------------*/
          static int ni()     { return sc.nextInt();       }
          
          
          




          /*-------------- for input in an array ---------------------*/
          
          
              
          


          /*-------------- File vs Input ---------------------*/
          
          static void runIo() throws Exception  {
               sc = new Scanner(System.in);
          }    

          

          

          
          
           
          
                   

          

          

          
  

          
     
          public static void main(String[] args)  throws Exception {

               // runFile();

               runIo();              

               int t;
               t = 1;     
            
               // t =  sc.nextInt();
          
               ans = new StringBuilder();
          
               while( t-- > 0 ) {   
                    solve();
               }                
          
               System.out.println(ans+""""); 
 
          }
    
          static int N ; 
          static int M ; 
          static ArrayList<Integer> f;
          static ArrayList<Integer> e;
          static long dp[][];

          static long find(int i, int j ) {
               
               if( i == N )   return 0;
               if( j == M )   return Integer.MAX_VALUE;


               if (dp[i][j] != -1 )
                    return dp[i][j];

               return dp[i][j] = Math.min( find(i, j+1), Math.abs(f.get(i)-e.get(j)) +  find(i+1, j+1) );
          }       


          public static void solve() {          
          
               int n = ni();
               f = new ArrayList();
               e = new ArrayList();               

               for(int i = 0; i<n; i++) {
                    int v = ni();
                    if( v == 0 ) {
                         e.add(i);
                    }
                    else
                         f.add(i);
               }

               N = f.size();
               M = e.size();               

               dp = new long[N][M];

               for(int i = 0; i<N; i++)
                    Arrays.fill(dp[i], -1);

               ans.append(find(0, 0)+""\n"");
          }
 
     }
",0,Non-plagiarised
9756f13a,ea899386,"import java.util.*;
import java.io.*;

public class PhoenixAndTowers {
    public static void main(String [] args) throws IOException{

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.readLine());
        for (int test = 0; test < t; test++){
            String [] data = in.readLine().split("" "");
            int n = Integer.parseInt(data[0]);
            int m = Integer.parseInt(data[1]);
            int x = Integer.parseInt(data[2]);

            data = in.readLine().split("" "");
            intPair [] blocks = new intPair[n];
            for (int i = 0; i < n; i++){
                blocks[i] = new intPair(i, Integer.parseInt(data[i]));
            }
            Arrays.sort(blocks);
            TreeSet<intPair> towers = new TreeSet<>();
            // intPair [] towers = new intPair[m];
            for (int i = 0; i < m; i++){
                // towers[i] = new intPair(i+1, 0);
                towers.add(new intPair(i+1, 0));
            }
            int [] newIdx = new int[n];

            for (int i = n - 1; i >= 0; i--){
                //Arrays.sort(towers);
                intPair low = towers.pollFirst();
                //towers[0].value += blocks[i].value;
                low.value += blocks[i].value;
                newIdx[blocks[i].idx] = low.idx;
                towers.add(low);
            }

            int min = n*x;
            int max = 0;
            for (intPair tower : towers){
                if (tower.value < min){
                    min = tower.value;
                }
                if (tower.value > max){
                    max = tower.value;
                }
            }
            if (max - min <= x){
                out.write(""YES\n"");
                for (int i = 0; i < n; i++){
                    if (i != 0){
                        out.write("" "" + newIdx[i]);
                    }else {
                        out.write("""" + newIdx[i]);
                    }
                }
                out.write(""\n"");
            } else {
                out.write(""NO\n"");
            }
        }
        out.close();
    } 

    static class intPair implements Comparable<intPair>{
        int idx;
        int value;
        intPair(int idx, int value){
            this.idx = idx;
            this.value = value;
        }
        
    }
}
","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
6db218a2,8ad1ad84,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main{
    
 
    
    
    public static void sortbyColumn(int arr[][], int col) 
    { 
        
        Arrays.sort(arr, new Comparator<int[]>() { 
            
           
        });  
    } 
    
    public static class Pair<U extends Comparable<U>, V extends Comparable<V>> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;
    
        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }
    
        
    
        
    
        
    
        
    
    }
    
    
    
    
    
    
    
    // static void calc(int n){
    //     int i,j;
    //     dp[n-1]=0;
    //     if(n>1)
    //     dp[n-2]=1;
    //     for(i=n-3;i>=0;i--){
    //         long ind=n-i-1;
    //         dp[i]=((ind*(long)mypow(10,ind-1))%MOD+dp[i+1])%MOD;
    //     }
    // }
    
    static long dist[],dp[][],left[],right[];
    static int visited[],isit[];
    static ArrayList<Pair<Integer,Pair<Long,Long>>> adj[],li;
    //static int dp[][][];
    static int MOD=1000000007;
    static char ch[];
    static int[] sieve,is_sieve;
    static TreeSet<Integer> tr;
    static long mat[][];
    
    
    static void dfs(int node,int par, Pair<Long,Long> p[]){
        for(Pair<Integer,Pair<Long,Long>> pp:adj[node]){
            if(pp.x!=par){
                //sum+=Math.abs(selected[node]-selected[pp.x]);
                dfs(pp.x,node,p);
                //System.out.println(node+"" ""+pp.x);
                long x=Math.abs(p[node].x-p[pp.x].x);
                long y=Math.abs(p[node].x-p[pp.x].y);
                long z=Math.abs(p[node].y-p[pp.x].x);
                long w=Math.abs(p[node].y-p[pp.x].y);
                
                left[node]+=Math.max(x+left[pp.x],y+right[pp.x]);
                right[node]+=Math.max(z+left[pp.x],w+right[pp.x]);
                
            }
        }
    }
    
    public static void main(String args[]){
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter w = new PrintWriter(outputStream);
        int t,i,j,tno=0,tte;
        
        t=in.nextInt();
        //t=1;
        //tte=t;
        
        while(t-->0){
            //sum=0;
            int n=in.nextInt();
            adj=new ArrayList[n+1];
            left=new long[n+1];
            right=new long[n+1];
            visited=new int[n+1];
            for(i=0;i<n+1;i++){
                adj[i]=new ArrayList<>();
            }
            Pair<Long,Long> p[]=new Pair[n+1];
            for(i=1;i<=n;i++){
                p[i]=new Pair<>(in.nextLong(),in.nextLong());
            } 
            for(i=0;i<n-1;i++){
                int u,v;
                u=in.nextInt();
                v=in.nextInt();
                adj[u].add(new Pair<>(v,p[v]));
                adj[v].add(new Pair<>(u,p[u]));
            }
            
            dfs(1,-1,p);
            // for(i=0;i<n+1;i++){
            //     w.print(selected[i]+"" "");
            // }
            // w.println();
            w.println((long)Math.max(left[1],right[1]));
        }
        w.close();
    }
}
","import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	 static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<Integer> g[];
	static long L[],R[],dp[][];
	public static void main(String args[])throws IOException
	{  					
		int T=i();
		outer:while(T-->0)
		{
			int N=i();
			setGraph(N);
			for(int i=1; i<=N; i++)
			{
				L[i]=l();
				R[i]=l();
			}
			for(int i=1; i<N; i++)
			{
				int a=i(),b=i();
				g[a].add(b);
				g[b].add(a);
			}
			f(1,-1);
			out.println(Math.max(dp[0][1], dp[1][1]));
		}
		out.close();
		//print(L);
		//print(R);
		
		//print(dp[0]);
		//print(dp[1]);
		

	}	
	static void f(int n,int p)
	{
		for(int c:g[n])
		{
			if(c!=p)
			{
			f(c,n);
			long a=dp[0][c]+Math.abs(L[c]-L[n]);
			long b=dp[1][c]+Math.abs(R[c]-L[n]);
			dp[0][n]+=Math.max(a, b);
			a=dp[0][c]+Math.abs(L[c]-R[n]);
			b=dp[1][c]+Math.abs(R[c]-R[n]);
			dp[1][n]+=Math.max(a, b);
			}
		}
	}
	

	
	


	
	

	
	
	
	

	

	
	
	
	
	

	
	static void setGraph(int N)
	{
		g=new ArrayList[N+1];
		dp=new long[2][N+1];
		L=new long[N+1];
		R=new long[N+1];
		for(int i=0; i<=N; i++)
		{

			g[i]=new ArrayList<Integer>();
		}
	}

	
	
	
	
	
	

	//Debugging Functions Starts

	
	
	
	
	

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	
	static int i()
	{
		return in.nextInt();
	}

	static long l()
	{
		return in.nextLong();
	}

	

	

	//IO FUNCTIONS END

}



//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader

",0,Non-plagiarised
51019113,bf85ab7b,"import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   static class Pair{ 
		   long x;
		   long y;
		   
		   Pair(long x,long y){ 
			   this.x = x;
			   this.y = y;
			   
		   }
	   }
	  
	    
	 
	   
	
	   static void dfs(int cur , int prnt , ArrayList<Integer> graph[],long dp[][],Pair p[]) { 
		   
		   for(int i : graph[cur]) { 
			   
			   if(i!=prnt) { 
				   dfs(i,cur,graph,dp,p);
				   
				   dp[cur][0] += Math.max(Math.abs(p[cur].x - p[i].x)+ dp[i][0], Math.abs(p[cur].x - p[i].y)+dp[i][1]);
				   dp[cur][1] += Math.max(Math.abs(p[cur].y -p[i].x) + dp[i][0], Math.abs(p[cur].y - p[i].y)+dp[i][1]);
			   }
		   }
	   }
	   public static void main(String args[]) throws Exception { 
		
		   
		   Scanner sc = new Scanner();
		   StringBuffer res = new StringBuffer();
		   
		   int tc = sc.nextInt();
		   
		   while(tc-->0) { 
			
			int n = sc.nextInt();
			
			Pair p[] = new Pair[n+1];
			
			for(int i=1;i<=n;i++) { 
				p[i] = new Pair(0,0);
				p[i].x = sc.nextLong();
				p[i].y = sc.nextLong();
			}
			
			ArrayList<Integer> graph[] = new ArrayList[n+1];
			
			for(int i=0;i<n+1;i++) { 
				graph[i] = new ArrayList<>();
			}
			for(int i=0;i<n-1;i++) { 
				
				int u = sc.nextInt();
				int v = sc.nextInt();
				
				graph[u].add(v);
				graph[v].add(u);
				
			}
			
			long dp[][] = new long[n+1][2];
			
			dfs(1,0,graph,dp,p);
			
			System.out.println(Math.max(dp[1][0], dp[1][1]));
		   }
			System.out.println(res);
		   
	   }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.io.DataInputStream;
import java.io.FileInputStream;

import java.io.IOException;

public class ParsasHumongousTree {

    public static void main(String args[]) throws IOException {
        Reader scan = new Reader();
        StringBuilder sb = new StringBuilder();

        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            int[] l = new int[n + 1];
            int[] r = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                l[i] = scan.nextInt();
                r[i] = scan.nextInt();
            }
            Graph g = new Graph(n);
            for (int i = 0; i < n - 1; i++) {
                g.addEdge(scan.nextInt(), scan.nextInt());
            }
            sb.append(g.dfs(l, r) + ""\n"");
        }
        System.out.println(sb);
    }
}

class Graph {

    ArrayList<Integer>[] node;
    int n;
    int c = 0;
    boolean[] vis;

    Graph(int s) {
        n = s + 1;
        vis = new boolean[n + 1];
        node = new ArrayList[n + 1];
        for (int i = 0; i < n + 1; i++) {
            node[i] = new ArrayList<>();
        }
    }

    void addEdge(int u, int v) {

        node[u].add(v);
        node[v].add(u);
        if (node[u].size() == 1) {
            c = u;
        }
        if (node[v].size() == 1) {
            c = v;
        }
    }

    void cleanVisArray() {
        for (int i = 0; i < n + 1; i++) {
            vis[i] = false;
        }
    }

    long dfs(int[] l, int[] r) {
        cleanVisArray();

        long[][] dp = new long[n][2];
        dfsMain(1, dp, l, r);
        return Math.max(dp[1][0], dp[1][1]);
    }

    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
        vis[v] = true;
        for (int i : node[v]) {
            if (!vis[i]) {
                dfsMain(i, dp, l, r);
                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
            }
        }
    }

}


",0,Non-plagiarised
e2fe9d7d,ece1820d,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class C_Edu_Round_120 {
    public static long MOD = 998244353;

    static int[] dp;


    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // ""output.txt"")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int T = in.nextInt();
        //System.out.println(cal(1608737403, 1000000000) - 923456789987654321L);
        for (int z = 0; z < T; z++) {
            int n = in.nextInt();
            long k = in.nextLong();
            long[] data = new long[n];
            long total = 0;
            PriorityQueue<Integer> q = new PriorityQueue<>();
            for (int i = 0; i < n; i++) {
                q.add(in.nextInt());
            }
            for (int i = 0; i < n; i++) {
                data[i] = q.poll();
                total += data[i];
            }
            Arrays.sort(data);
            long result = Long.max(0, total - k);
            long cur = 0;
            int num = 0;
            for (int i = n - 1; i > 0 && total > k + cur; i--) {

                num++;
                cur += data[i] - data[0];
                long left = Long.max(0, total - cur - k);
                left /= (num + 1);
                if (total - cur - (left * (num + 1)) > k) {
                    left++;
                }
                //System.out.println(num + "" "" + left + "" "" + cur + "" "" + total);
                result = Long.min(result, left + num);
            }


            out.println(result);

        }

        out.close();
    }

    

    

    

    


    

    

    

    

    

    

    

    

    
}
","import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
 
public class a729 {
 
	public static void main(String[] args) throws IOException {
   
		
//		try {
			
		BufferedWriter out = new BufferedWriter(
	            new OutputStreamWriter(System.out));
		BufferedReader br = new BufferedReader(
		        new InputStreamReader(System.in));
		PrintWriter pt = new PrintWriter(System.out);
		FastReader sc = new FastReader();
		int t = sc.nextInt();
	
for(int o = 0 ; o<t;o++){
int n = sc.nextInt();
long k = sc.nextLong();
long[] arr = new long[n];
for(int i = 0 ; i<n;i++) {
	arr[i] = sc.nextLong();
}
shuffleArray(arr);
Arrays.sort(arr);
long[] psum = new long[n+1];
for(int i = 1; i<=n;i++){
	psum[i] = psum[i-1] + arr[i-1];
}
if(n==1) {
	long val = arr[0]-k;
	val = Math.max(0, val);
	System.out.println(val);
	continue;
}
if(k>=psum[n]) {
	System.out.println(0);
	continue;
}
long ans = Integer.MAX_VALUE;
long x = 0;
long a1 = arr[0];
for(int y = 0 ; y<n;y++) {
	long val = psum[n-y] + y*a1 - k;
//	if(val<0) {
//		continue;
//	}
	x = val/(y+1);
	if(val%(y+1)!=0 && val>0) {
		x++;
	}
//	if(x<0) {
//		continue;
//	}
	ans = Math.min(ans, Math.max(x, 0) + y);
	
	
}
ans = Math.max(ans, 0);
System.out.println(ans);
}
//     }catch(Exception e) {
//    	 return;
//     }
     }
     
     
//------------------------------------------------------------------------------------------------------------------------------------------------
 
	
	
	
	
	
	
	
	
	
 
	
	
	
	
//for f/inding minimum in range 

//// for sum
//

	
	
	
	
	
	
	
	
	
 
//	-----------------------------------------------------------------------------------------------------------------------------------------------
	
//--------------------------------------------------------------------------------------------------------------------------------------------------------
	
 
		
 
//-----------------------------------------------------------------------------------------------------------------------------------
 
	//segment tree
	//for finding minimum in range 
//	public static void build(int [] seg,int []arr,int idx, int lo , int hi) {
//		if(lo == hi) {
//			seg[idx] = arr[lo];
//			return;
//		}
//		int mid = (lo + hi)/2;
//	build(seg,arr,2*idx+1, lo, mid);
//	build(seg,arr,idx*2+2, mid +1, hi);
//	seg[idx] = Math.min(seg[2*idx+1],seg[2*idx+2]);
//	}
////for finding minimum in range 
//public static int query(int[]seg,int idx , int lo , int hi , int l , int r) {
//		if(lo>=l && hi<=r) {
//			return seg[idx];
//		}
//	if(hi<l || lo>r) {
//		return Integer.MAX_VALUE;
//	}
//	int mid = (lo + hi)/2;
//	int left = query(seg,idx*2 +1, lo, mid, l, r);
//	int right = query(seg,idx*2 + 2, mid + 1, hi, l, r);
//	return Math.min(left, right);
//}
//	// for sum
//
//public static void update(int[]seg,int idx, int lo , int hi , int node , int val) {
//	if(lo == hi) {
//		seg[idx] += val;
//	}else {
//int mid = (lo + hi )/2;
//if(node<=mid && node>=lo) {
//	update(seg, idx * 2 +1, lo, mid, node, val);
//}else {
//	update(seg, idx*2 + 2, mid + 1, hi, node, val);
//}
//seg[idx] = seg[idx*2 + 1] + seg[idx*2 + 2];
//
//}
 
//}
//---------------------------------------------------------------------------------------------------------------------------------------
 
 
	static void shuffleArray(long[] ar)
	  {
	    // If running on Java 6 or older, use `new Random()` on RHS here
	    Random rnd = ThreadLocalRandom.current();
	    for (int i = ar.length - 1; i > 0; i--)
	    {
	      int index = rnd.nextInt(i + 1);
	      // Simple swap
	      long a = ar[index];
	      ar[index] = ar[i];
	      ar[i] = a;
	    }
	  }
//-----------------------------------------------------------------------------------------------------------------------------------------------------------
 
}
 
 

//------------------------------------------------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------------------------------------------------

 

",0,Non-plagiarised
51d857bc,63118334,"import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Round659 {

	static int rec = 0;
	static int X[] = { -1, 0, 0, 1 };
	static int Y[] = { 0, -1, 1, 0 };
	static long mod = 1000000007;
	static int last=0;
	static int maxDepth=0;
	

	

	

	

	

	public static List<Integer>[] initAdjacency(int n, int e, Reader scan, boolean type) throws IOException {

		List<Integer> adj[] = new ArrayList[n + 1];

		for (int i = 0; i < e; i++) {
			int u = scan.nextInt();
			int v = scan.nextInt();

			if (adj[u] == null)
				adj[u] = new ArrayList<>();
			if (type && adj[v] == null)
				adj[v] = new ArrayList<>();

			adj[u].add(v);

			if (type)
				adj[v].add(u);

		}

		return adj;
	}

	public static void main(String[] args) throws IOException {

		Reader scan = new Reader();
//		Scanner scan = new Scanner(System.in);

		int t = scan.nextInt();
		while (t-- > 0) {
			
			D(scan);
		}

	}
	
	
	public static void D(Reader scan) throws IOException {
		
		int n=scan.nextInt();
		int a=scan.nextInt();
		int b=scan.nextInt();
		int da=scan.nextInt();
		int db=scan.nextInt();
		
		List<Integer> adj[]=initAdjacency(n, n-1, scan, true);
		
		int d= dist(a, 0, adj, b);
		
		if(d<=da) {
			System.out.println(""Alice"");
			return;
		}
		
		if(db<=2*da) {
			System.out.println(""Alice"");
			return;
		}
		
		MyPair far1= farthest(1, 0, adj);
		MyPair far2=farthest(far1.weight, 0, adj);
		
		int diameter= far2.value-1;
		
		
		if(diameter<=2*da) {
			System.out.println(""Alice"");
		}else {
			System.out.println(""Bob"");
		}
		
		
//		int val=d-2*a;
//		
//		if(val>0) {
//			System.out.println(""Bob"");
//			return;
//		}
//		
//		int dep=0;
//		for(Integer x: adj[a]) {
//			if(x==last) continue;
//			
//			dep=Math.max(getDepth(x, a, adj), dep);
//		}
//		
//		if(dep>=val) {
//			System.out.println(""Bob"");
//		}else {
//			System.out.println(""Alice"");
//		}
		
		
		
	}
	
	public static MyPair farthest(int i, int parent, List<Integer> adj[]) {
		
		int dist=0;
		int node= i;
		
		for(Integer x: adj[i]) {
			if(x==parent) continue;
			
			MyPair recAns= farthest(x, i, adj);
			if(recAns.value>dist) {
				dist= recAns.value;
				node= recAns.weight;
			}
		}
		
		return new MyPair(dist+1, node);
		
	}
	
	
	
	public static int dist(int i, int parent, List<Integer> adj[], int target) {
		
		if(i==target) return 0;
		
		for(Integer x: adj[i]) {
			if(x==parent) continue;
			
			int recAns= dist(x, i, adj, target);
			if(recAns!=-1) {
				last=x;
				return recAns+1;
			}
		}
		
		return -1;
		
		
	}
	
	
	
	
	
	
	

}

class MyPair {

	int value;
	int weight;

	public MyPair(int value, int w) {
		this.value = value;
		weight = w;
	}

}
","import java.util.*;
import java.io.*;
public class MyClass
{
    
    
    static ArrayList<Integer> edge[];
    public static void main(String args[])
    {
        FastReader fs=new FastReader();
        PrintWriter pw=new PrintWriter(System.out);
        int tc=fs.nextInt();
        while(tc-->0)
        {
            int n=fs.nextInt();
            int a=fs.nextInt();
            int b=fs.nextInt();
            int da=fs.nextInt();
            int db=fs.nextInt();
            edge=new ArrayList[n+1];
            for(int i=1;i<=n;i++)
            edge[i]=new ArrayList<>();
            for(int i=1;i<n;i++)
            {
                int u=fs.nextInt();
                int v=fs.nextInt();
                edge[u].add(v);
                edge[v].add(u);
            }
            int dist[]=new int[n+1];
            Arrays.fill(dist,-1);
            dist[a]=0;
            Queue<Integer> queue=new LinkedList<>();
            queue.add(a);
            while(!queue.isEmpty())
            {
                int node=queue.poll();
                for(int v:edge[node])
                {
                    if(dist[v]==-1)
                    {
                        dist[v]=dist[node]+1;
                        queue.add(v);
                    }
                }
            }
            if(dist[b]<=da)
            {
                pw.println(""Alice"");
                continue;
            }
            int mx=0,mxvert=1;
            for(int i=1;i<=n;i++)
            {
                if(dist[i]>mx)
                {
                    mx=dist[i];
                    mxvert=i;
                }
            }
            Arrays.fill(dist,-1);
            dist[mxvert]=0;
            queue.add(mxvert);
            while(!queue.isEmpty())
            {
                int node=queue.poll();
                for(int v:edge[node])
                {
                    if(dist[v]==-1)
                    {
                        dist[v]=dist[node]+1;
                        queue.add(v);
                    }
                }
            }
            for(int i=1;i<=n;i++)
            mx=Math.max(mx,dist[i]);
            db=Math.min(db,mx);
            if(db>2*da)
            pw.println(""Bob"");
            else
            pw.println(""Alice"");
        }
        pw.flush();
        pw.close();
    }
}
",0,Non-plagiarised
3b498a39,9028caf7,"import java.util.*;


import java.io.*;
import java.math.*;

public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];
	 static int max;
	  public static void main(String[] args)
{
		   PrintWriter out=new PrintWriter(System.out);
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		   //ttt =i();
		 
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int A[]=input(n);
	        	dp=new long[n+1][n+1];
	        	for(int i=0;i<=n;i++) {
	        		Arrays.fill(dp[i],-1);
	        	}
		        	
	        	
	        	ArrayList<Integer> l=new ArrayList<Integer>();
	        	ArrayList<Integer> m=new ArrayList<Integer>();
	        	for(int i=0;i<n;i++) {
	        		if(A[i]==0) {
	        			l.add(i+1);
	        		}
	        		else {
	        			m.add(i+1);
	        		}
	        	}
	        	A=new int[m.size()];
	        	int B[]=new int[l.size()];
	        	for(int i=0;i<l.size();i++) {
	        		B[i]=l.get(i);
	        	}
	        	for(int i=0;i<m.size();i++) {
	        		A[i]=m.get(i);
	        	}
	        	n=m.size();
	        	int o=l.size();
		        	System.out.println(go(A,B,0,0,n,o));
	        	
			}

	     //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	//CHECK FOR N=1
       	//CHECK FOR N=1
		        
		     
    }
	  
	 
	  
	  
	
	 
	private static long go(int[] A, int[] B, int i, int j, int n, int m) {
		if(i==n)
			return 0;
		if(j==m)
			return Integer.MAX_VALUE;
		if(dp[i][j]!=-1)
			return dp[i][j];
		long op1=go(A, B, i+1, j+1, n, m)+Math.abs(A[i]-B[j]);
		long op2=go(A, B, i, j+1, n, m);
		return dp[i][j]=Math.min(op1, op2);
	
		
		
		
		
		}








static int[] input(int n) {
	int A[]=new int[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.nextInt();
	   }
	   return A;
   }

















     static int i() {
    	 return sc.nextInt();
     }
     
     static long l() {
    	 return sc.nextLong();
     }  
     
     
  
  
  
      
      
      
      
     
        
     
}
","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();
    }
    
}
",0,Non-plagiarised
49e94e7e,d7a8434f,"import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	
	
	

	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
			
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   
			
			
			
			
			
			
			   
				
		   
		   
		
			   /*
			    * 
			    * >=         <=
			   0 1 2 3 4 5 6 7  
			   5 5 5 6 6 6 7 7
			   lower_bound for 6 at index 3 (>=)
			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
			   */

		   
		   
			
			
			
			
			
	
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out); 
		
		int tt = sc.nextInt();
		while(tt-- > 0)
		{
	       int n = sc.nextInt();
	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
	       
	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
	       for(int i = 0;i<n;i++)
	       {
	    	   if(a[i] == '0' && b[i] == '0')
	    	   {
	    		   c00++;
	    	   }
	    	   else if(a[i] == '0' && b[i] == '1')
	    	   {
	    		   c01++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '0')
	    	   {
	    		   c10++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '1')
	    	   {
	    		   c11++;
	    	   }
	       }
	       
	       int ans = mod;
	       if(c01 == c10) ans = min(ans, c01 + c10);
	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
	       
	       fout.println((ans == mod) ? -1 : ans);
		}
		
		fout.close();
	}
}
","import java.util.*;
import java.io.*;
public class C {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt();
			char[] s = new char[n];
			char[] t = new char[n];
			s = sc.next().toCharArray();
			t = sc.next().toCharArray();
			int a = 0, b = 0, c = 0, d = 0;
			for(int i = 0; i < n; i++) {
				if(s[i] == '0' && t[i] == '0') a++;
				if(s[i] == '1' && t[i] == '0') b++;
				if(s[i] == '0' && t[i] == '1') c++;
				if(s[i] == '1' && t[i] == '1') d++;
			}
			int res = Integer.MAX_VALUE;
			if(b == c || b+1 == c) {
				if((b + c) % 2 == 0) {
					res = Math.min(res, b + c);
				}
			}
			if(a == d || a+1 == d) {
				if((a + d) % 2 == 1) {
					res = Math.min(res, a + d);
				}
			}
			if(res == Integer.MAX_VALUE) System.out.println(-1);
			else System.out.println(res);
		}
	}
	
	

}
",0,Non-plagiarised
ca8f11a4,e185bce5,"import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;

public class GR18_C2 {
	public static FastScanner sc;
	public static StringBuilder sb ;public static int MOD= 1000000007;
	

    public static void solve(int t) throws IOException {
    	int n=sc.nextInt();
    	String a=sc.next();
    	String b=sc.next();
    	
    	int _00=0;
    	int _01=0;
    	int _10=0;
    	int _11=0;
    	
    	for(int i=0;i<n;i++) {
    		if(a.charAt(i)=='0' && b.charAt(i)=='0') _00++;
    		if(a.charAt(i)=='0' && b.charAt(i)=='1') _01++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='0') _10++;
    		if(a.charAt(i)=='1' && b.charAt(i)=='1') _11++;
    	}
    	
    	int ans=Integer.MAX_VALUE;
    	
    	
    	// All _01 and _10 can be converted to _11 and _00 by swapping and this requires to operations
    	if(_01==_10) {
    		ans=Math.min(ans, _10*2);
    	}
    	// By performing one operation, we get _01==_10 and then even operations can be done.
    	// Possible when _11=_00 and one additional _11 for odd operation
    	if(_00+1==_11) {
    		ans=Math.min(ans, (_11-1)*2+1);
    	}
    	if(ans==Integer.MAX_VALUE) sb.append(-1).append('\n');
    	else sb.append(ans).append('\n');
    }
    
	public static void main(String[] args) throws IOException {
		sb = new StringBuilder("""");
		sc = new FastScanner();
		int t=sc.nextInt();
		for(int i=1;i<=t;i++){
			solve(i);
		}
		System.out.println(sb);
	}
	
	
}
","import java.util.*;

import java.io.*;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
	
public class Main {
		private static FS sc = new FS();
		
		
		
		
		
		static int mod = (int) 1e9;
		
		static LinkedList<Integer>[] temp, idx;
		static long inf = (long) Long.MAX_VALUE;
//		static long inf = Long.MAX_VALUE;
//		static int max;
		
		public static void main(String[] args) { 
			int t = sc.nextInt();
//			int t = 1;
			StringBuilder ret = new StringBuilder();
			while(t-- > 0) {
				int n = sc.nextInt();
				String a = sc.next(), b = sc.next();
				int _00 = 0, _01 = 0, _10 = 0, _11 = 0;
				for(int i = 0; i < n; i++) {
					if(a.charAt(i) == '0' && b.charAt(i) == '0') _00++;
					if(a.charAt(i) == '0' && b.charAt(i) == '1') _01++;
					if(a.charAt(i) == '1' && b.charAt(i) == '0') _10++;
					if(a.charAt(i) == '1' && b.charAt(i) == '1') _11++;
				}
				int ans = Integer.MAX_VALUE;
				if(_10 == _01) ans = _01 + _10;
				if(_10 > 0) {
					int n00 = _10 - 1;
		            int n01 = _11;
		            int n10 = _00 + 1;
		            int n11 = _01;
		            if (n01 == n10) {
		                ans = Math.min(ans, 1 + n01 + n10);
		            }
				}
				if(_11 > 0) {
					int n00 = _10;
		            int n01 = _11 - 1;
		            int n10 = _00;
		            int n11 = _01 + 1;
		            if (n01 == n10) {
		                ans = Math.min(ans, 1 + n01 + n10);
		            }
				}
				ret.append(ans == Integer.MAX_VALUE ? -1 : ans);
				ret.append(""\n"");
			}
			System.out.println(ret);
		}

	}
",0,Non-plagiarised
81fb6415,fb69b3b4,"import java.math.BigInteger;
import java.util.*;
import java.io.*;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class CodeForces {


    public void run() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        next : while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long k = Long.parseLong(st.nextToken());
            Long[] a = new Long[n];
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                a[i] = Long.parseLong(st.nextToken());
            }
            Arrays.sort(a);
            long ans = Long.MAX_VALUE;
            long[] lsum = new long[n + 1];
            for (int i = 0; i < n; i++) {
                lsum[i + 1] = lsum[i] + a[i];
            }
            for (long y = 0; y < n; y++) {
                long x = 0;
                if ((k - lsum[n - (int)y] + a[0]) >= 0) {
                    x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
                } else {
                    if ((k - lsum[n - (int)y] + a[0]) % (y + 1) == 0) {
                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1);
                    } else {
                        x = (k - lsum[n - (int)y] + a[0]) / (y + 1) - 1;
                    }
                }
                x = a[0] - x;
                ans = Math.min(ans, Math.max(0, x) + y);
            }
            System.out.println(ans);
        }

    }

    public static void main(String[] args) throws Exception {
        new CodeForces().run();
    }

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
public class Main {
    public static long floor(long a, long b) {
        long res = a / b;
        while(res * b > a) res--;
        return res;
    }
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            long k = Long.parseLong(st.nextToken());
            st = new StringTokenizer(br.readLine());
            Long[] p = new Long[n];
            for(int i = 0 ;i<n;i++) {
                p[i] = Long.parseLong(st.nextToken());
            }
            Arrays.sort(p);
            long[] sums = new long[n+1];
            for(int i=0;i<n;i++) sums[i+1] = sums[i] + p[i];
            long ans = Long.MAX_VALUE;
            for(int y=0;y<n;y++) {
                long x = p[0] - floor(k - sums[n-y] + p[0], y+1);
                ans = Math.min(Math.max(x, 0) + y, ans);
            }
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
77d22fc3,d3528b2a,"import java.io.*;
import java.util.*;

public class A {
    //--------------------------INPUT READER---------------------------------//
    //-----------------------------------------------------------------------//
    static int t = 0;
    //---------------------------PRINTER-------------------------------------//
    //-----------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    static long ima = Integer.MAX_VALUE;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-----------------------------------------------------------------------//
    static int tt = 0;
    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        t = sc.ni();while(t-->0) {
            tt++;
            solve();
        }


    }

    static void solve() throws IOException {
        int n = sc.ni();
        String s1 = sc.ns();
        String s2 = sc.ns();
        char[] strr = s1.toCharArray();
        char[] strr2 = s2.toCharArray();
        HashSet<Integer> lia = new HashSet<>(), lib = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr[i]=='1') lia.add(i);
            else lib.add(i);
        }
        HashSet<Integer> liaa = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr2[i]=='1') liaa.add(i);
        }
        if(!(lia.size() == liaa.size() || lib.size()+1 == liaa.size())) {
            System.out.println(-1);
            return;
        }
        int ac = 0, bc = 0;
        for(int i: lia) {
            if(liaa.contains(i)) ac++;
        }
        bc = liaa.size()-ac;
        if(lia.size() == liaa.size() && lia.size() == ac) {
            System.out.println(0);
            return;
        }

        int nac = lia.size()-ac;
        int nbc = lib.size()-bc;

        long ansa = ac != 0 && (ac-1 == nbc)? Math.abs(ac-1+nbc): ima;
        long ansb = nac != 0 && (nac-1 == bc-1)? Math.abs(nac-1+bc): ima;


        if(ansa == ima && ansb == ima) {
            System.out.println(-1);
            return;
        }

        System.out.println(Math.min(ansa, ansb)+1);
    }

}
","import java.io.*;
import java.util.*;

public class A {
    //--------------------------INPUT READER---------------------------------//

    //-----------------------------------------------------------------------//
    static int t = 0;
    //---------------------------PRINTER-------------------------------------//
    //-----------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    static long ima = Integer.MAX_VALUE;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-----------------------------------------------------------------------//
    static int tt = 0;
    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        t = sc.ni();while(t-->0) {
            tt++;
            solve();
        }


    }

    static void solve() throws IOException {
        int n = sc.ni();
        String s1 = sc.ns();
        String s2 = sc.ns();
        char[] strr = s1.toCharArray();
        char[] strr2 = s2.toCharArray();
        HashSet<Integer> lia = new HashSet<>(), lib = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr[i]=='1') lia.add(i);
            else lib.add(i);
        }
        HashSet<Integer> liaa = new HashSet<>();
        for(int i = 0; i < n; i++) {
            if(strr2[i]=='1') liaa.add(i);
        }
        if(!(lia.size() == liaa.size() || lib.size()+1 == liaa.size())) {
            System.out.println(-1);
            return;
        }
        int ac = 0, bc = 0;
        for(int i: lia) {
            if(liaa.contains(i)) ac++;
        }
        bc = liaa.size()-ac;
        if(lia.size() == liaa.size() && lia.size() == ac) {
            System.out.println(0);
            return;
        }

        int nac = lia.size()-ac;
        int nbc = lib.size()-bc;

        long ansa = ac != 0 && (ac-1 == nbc)? Math.abs(ac-1+nbc): ima;
        long ansb = nac != 0 && (nac-1 == bc-1)? Math.abs(nac-1+bc): ima;


        if(ansa == ima && ansb == ima) {
            System.out.println(-1);
            return;
        }

        System.out.println(Math.min(ansa, ansb)+1);
    }

}
",1,Plagiarised
8f31b279,d2f74dfc,"import java.util.*;
import java.io.*;
public class JavaTract
{
	static class Pair implements Comparable<Pair>{
    	int first;
    	int second;
    	Pair(int x,int y){
        	this.first=x;
        	this.second=y;
    	}
    	
   	}	
    public static void main (String[] args) 
    {
        Scanner scan=new Scanner(System.in);
        int t=scan.nextInt();
        while(t-->0){
            int n=scan.nextInt();
            int m=scan.nextInt();
            int x=scan.nextInt();
            int[]arr=new int[n];
            for(int i=0;i<n;i++){
                arr[i]=scan.nextInt();
            }
            // TreeSet<Pair> set = new TreeSet<>(); 
            Queue<Pair> set = new PriorityQueue<>();
            for(int i=1;i<=m;i++){
               
               set.add(new Pair(0,i));
            }
            
            System.out.println(""YES"");
            for(int i=0;i<n;i++){
                Pair temp=set.poll();
                
                int first = temp.first;
                int second = temp.second;

                System.out.print(second+"" "");
                
                set.add(new Pair(first+arr[i],second));
                
            }
            System.out.println();


        }
    }

       
}
","import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t--!=0){
            int n=sc.nextInt();
            int m=sc.nextInt();
            int x=sc.nextInt();
            int[] a=new int[n];
            int[] c=new int[n];
            Map<Integer,Stack<Integer>> mp=new HashMap<>();
            for(int i=0;i<n;i++){
                a[i]=sc.nextInt();
                //c[i]=a[i];
                if(mp.containsKey(a[i])){
                    Stack<Integer> l=mp.get(a[i]);
                    l.push(i);
                    mp.put(a[i],l);
                }
                else{
                    Stack<Integer> l=new Stack<>();
                    l.push(i);
                    mp.put(a[i],l);
                }
            }
            Arrays.sort(a);
            int[] b=new int[n];
           
            int cn=1;
            for(int i=0;i<n;i++){
                cn=cn%m;
                Stack<Integer> li=mp.get(a[i]);
                if(!li.isEmpty()){
                    int val=li.peek();
                    b[val]=cn+1;
                    c[i]+=a[i];
                    li.pop();
                    mp.put(a[i],li);
                }
                cn++;
            }
            int mv=c[0]-c[n-1];
            if(Math.abs(mv)>x) System.out.println(""NO"");
            else {
                System.out.println(""YES"");
                for(int i=0;i<n;i++){
                    System.out.print(b[i]+"" "");
                }
                System.out.println();
            }
        }
    }
    
}
",0,Non-plagiarised
2120328e,464a03b8,"import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static int mod=10000007;
   static StringBuilder sb=new StringBuilder();
    /* start */
       public static void main(String [] args)
    {
            int t = i();
            while(t-->0)
            {
                int n = i();
                int a[] = input(n);
                char c[] = inputC();
                ArrayList<Integer> b = new ArrayList<>();
                ArrayList<Integer> r = new ArrayList<>();
                for(int i=0;i<n;i++)
                {
                    if(c[i]=='R')
                    r.add(a[i]);
                    else 
                    b.add(a[i]);
                }
                Collections.sort(b);
                Collections.sort(r,Collections.reverseOrder());
                boolean is = true;
                int cnt = 1;
                for(int i=0;i<b.size();i++)
                {
                    if(b.get(i)<cnt)
                    {
                        is = false;
                        break;
                    }
                    cnt++;
                }
                for(int i=0;i<r.size();i++)
                {
                    if(r.get(i)>n-i)
                    {
                        is = false;
                        break;
                    }
                }

                out.println(is==true?""YES"":""NO"");
            }
            out.close();
    }

    
    /* end */
     

    
    static int i() {
        return sc.nextInt();
    }

    static String s() {
        return sc.next();
    }

    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    static int[] input(int n) {
        int A[]=new int[n];
           for(int i=0;i<n;i++) {
               A[i]=sc.nextInt();
           }
        return A;
    }

    

    

    
      
     

      

     
    
     

     
    
    

    
    
    
    
    
    
    
    
    

    

    

    

    

    

    

     

      
        //pair class
        
}
","import java.util.*;

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
",1,Plagiarised
69b2fd22,d221162a,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","import java.util.*;
import java.io.*;

public class Main2 {
	
	static long mod = 998244353;
//	static Scanner sc = new Scanner(System.in);
	static FastReader sc = new FastReader();
	static PrintWriter out = new PrintWriter(System.out);
	public static void main (String[] args) {
		int t = 1;
//    	t = sc.nextInt();
	    z : while(t-->0) {
	    	int n = sc.nextInt();
	    	int a[] = new int[n];
	    	for(int i=0;i<n;i++) a[i] = sc.nextInt();
	    	List<Integer> a1 = new ArrayList<>();
	    	ArrayList<Integer> a2 = new ArrayList<>();
	    	for (int i = 0; i < n; i++) {
	    		if(a[i] == 0) a1.add(i);
	    		else a2.add(i);
			}
	    	long dp[][] = new long[n+1][n+1];
	    	for (int i = 0; i <= n; i++) {
	    		Arrays.fill(dp[i],-1);
			}
	    	out.write(find(0,0,a1,a2,dp)+""\n"");
	    }
		out.close();
	}
	private static long find(int i, int j, List<Integer> a1, ArrayList<Integer> a2, long[][] dp) {
		if(j == a2.size()) return 0;
		
		int req = a2.size()-j;
		int ava = a1.size()-i;
		
		if(ava<req) return Integer.MAX_VALUE/2;
		
		if(dp[i][j] != -1) return dp[i][j];
		
		long ans1 = find(i+1,j,a1,a2,dp);
		long ans2 = Math.abs(a1.get(i)-a2.get(j)) + find(i+1,j+1,a1,a2,dp);
		
		return dp[i][j] = Math.min(ans1, ans2);
	}
}
",0,Non-plagiarised
2e1109d7,e7000ac2,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DArmchairs solver = new DArmchairs();
        solver.solve(1, in, out);
        out.close();
    }

    static class DArmchairs {
        ArrayList<Integer>[] arr;
        long[][] dp;

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = in.readArray(n);

            int mx = 5001;
            dp = new long[mx][mx];
            for (int i = 0; i < mx; ++i) {
                Arrays.fill(dp[i], -1);
            }

            arr = new ArrayList[2];
            for (int i = 0; i < 2; ++i) {
                arr[i] = new ArrayList<>();
            }

            for (int i = 0; i < n; ++i) {
                arr[a[i]].add(i);
            }

            out.println(go(0, 0));
        }

        long go(int i, int j) {
            if (i == arr[1].size()) return 0;
            if (j == arr[0].size()) return (long) 1e9;
            if (dp[i][j] != -1) return dp[i][j];
            long pick = Math.abs(arr[0].get(j) - arr[1].get(i)) + go(i + 1, j + 1);
            long leave = go(i, j + 1);
            dp[i][j] = Math.min(leave, pick);
            return dp[i][j];
        }

    }

    
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DArmchairs solver = new DArmchairs();
        solver.solve(1, in, out);
        out.close();
    }

    static class DArmchairs {
        ArrayList<Integer>[] arr;
        long[][] dp;

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = in.readArray(n);

            int mx = 5001;
            dp = new long[mx][mx];
            for (int i = 0; i < mx; ++i) {
                Arrays.fill(dp[i], -1);
            }

            arr = new ArrayList[2];
            for (int i = 0; i < 2; ++i) {
                arr[i] = new ArrayList<>();
            }

            for (int i = 0; i < n; ++i) {
                arr[a[i]].add(i);
            }

            out.println(go(0, 0));
        }

        long go(int i, int j) {
            if (i == arr[1].size()) return 0;
            if (j == arr[0].size()) return (long) 1e9;
            if (dp[i][j] != -1) return dp[i][j];
            long pick = Math.abs(arr[0].get(j) - arr[1].get(i)) + go(i + 1, j + 1);
            long leave = go(i, j + 1);
            dp[i][j] = Math.min(leave, pick);
            return dp[i][j];
        }

    }

    
}
",1,Plagiarised
a8f7c8b7,c1638a45,"import java.util.Scanner;

public class Menorah {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            char initial[] = sc.next().toCharArray();
            char desired[] = sc.next().toCharArray();
            int lit1 = 0, lit2 = 0;
            int ans = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                if (initial[i] == '1') {
                    ++lit1;
                }
                if (desired[i] == '1') {
                    ++lit2;
                }
            }
            if (lit1 == lit2) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] != desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(count, ans);
            }
            if (lit2 == (n - lit1 + 1)) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] == desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(ans, count);
            }
            if (ans == Integer.MAX_VALUE) {
                System.out.println(-1);
            } else {
                System.out.println(ans);
            }
        }
    }
}
","import java.io.*;
import java.util.*;
public class qC {

	public static void main(String[] args)throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int T = Integer.parseInt(br.readLine());
		while(T-- > 0) {
			int N = Integer.parseInt(br.readLine());
			char[] curr = br.readLine().toCharArray();
			char[] sol = br.readLine().toCharArray();
//			int oddP = 0;
//			int evenP = 0;
//			int even1 = 0;
//			int odd1 = 0;
//			int even0 = 0;
//			int odd0 = 0;
//			boolean alreadySolved = true;
//			for(int i = 0;i < N;i++) {
//				if(curr[i] == sol[i]) {
//					evenP++;
//					if(curr[i] == '1') even1++;
//					else even0++;
//				}
//				else {
//					oddP++;
//					if(curr[i] == '1') odd1++;
//					else odd0++;
//					alreadySolved = false;
//				}
//			}
//			
//			if(alreadySolved) {
//				System.out.println(0);
//				continue;
//			}
//			int minSwaps = Integer.MAX_VALUE;
//			if(N % 2 == 1) {
//				if(evenP % 2 == 1 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
//					minSwaps = Math.min(minSwaps, oddP);
//				}
//				if(oddP % 2 == 0 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
//					minSwaps = Math.min(minSwaps, evenP);
//				}
//			}
//			else {
//				if(evenP % 2 == 0 && Math.abs(odd1 - odd0) <= 1 && odd1 > 0 && odd0 > 0) {
//					minSwaps = Math.min(minSwaps, oddP);
//				}
//				if(oddP % 2 == 1 && Math.abs(even1 - even0) <= 1 && even1 > 0 && even1 > 0) {
//					minSwaps = Math.min(minSwaps, evenP);
//				}
//			}
//			System.out.println((minSwaps == Integer.MAX_VALUE) ? -1: minSwaps);
			
			int curr1 = 0;
			int sol1 = 0;
			int mismatch = 0;
			for(int i = 0;i < N;i++) {
				if(curr[i] == '1') curr1++;
				if(sol[i] == '1') sol1++;
				if(curr[i] != sol[i]) mismatch++;
			}
			
			int minAns = Integer.MAX_VALUE;
			//even operations
			if(curr1 == sol1 && mismatch % 2 == 0) {
				minAns = Math.min(mismatch, minAns);
			}
			//odd operations
			for(int i = 0;i < N;i++) {
				if(curr[i] == '1') {
					int tempcurr1 = N - curr1 + 1;
					int tempmismatch;
					if(sol[i] == '0') {
						tempmismatch = N - mismatch;
					}
					else {
						tempmismatch = N - mismatch - 1;
					}
					if(tempcurr1 == sol1 && tempmismatch % 2 == 0) {
						minAns = Math.min(minAns, tempmismatch + 1);
					}
				}
			}
			
			System.out.println((minAns == Integer.MAX_VALUE) ? -1 : minAns);
		}

	}

}
",0,Non-plagiarised
7011024d,e6b7a899,"import java.util.*;

public class D {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayList<Integer> occupied = new ArrayList<>();
        ArrayList<Integer> vacant = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            if (x == 1)
                occupied.add(i);
            else
                vacant.add(i);
        }

        Solution Solution = new Solution(occupied, vacant);

//        System.out.println(Solution.tabulation());
        System.out.println(Solution.memoization());
    }
}

class Solution {

    ArrayList<Integer> occupied, vacant;
    int x, y;

    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
        this.occupied = occupied;
        this.vacant = vacant;
        x = occupied.size(); y = vacant.size();
    }

    

    

    int memoization() {
        int[][] dp = new int[x][y];
        for (int i = 0; i < x; i++) {
            Arrays.fill(dp[i], -1);
        }
        return memoization(dp, x-1, y-1);
    }

    int memoization(int[][] dp, int n, int m) {
        if(n < 0) {
            return 0;
        }
        if(m < n) {
            return Integer.MAX_VALUE;
        }
        if(dp[n][m] != -1) {
            return dp[n][m];
        }
        int first = memoization(dp, n, m-1);
        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
        dp[n][m] = Math.min(first, second);
        return dp[n][m];
    }
}
","import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

public class Main {
	static final long MOD=1000000007;
	static final long MOD1=998244353;
	static long ans=0;
	//static ArrayList<Integer> ans=new ArrayList<>();
	public static void main(String[] args){
		PrintWriter out = new PrintWriter(System.out);
		InputReader sc=new InputReader(System.in);
		int N = sc.nextInt();
		int[] A = sc.nextIntArray(N);
		ArrayList<Integer> a1 = new ArrayList<Integer>();
		ArrayList<Integer> a2 = new ArrayList<Integer>();
		for (int i = 0; i < A.length; i++) {
			if (A[i]==0) {
				a1.add(i);
			}else {
				a2.add(i);
			}
		}
		int[][] dp = new int[a1.size()+1][a2.size()+1];
		for (int i = 0; i < dp.length; i++) {
			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
		}
		dp[0][0] = 0;
		for (int i = 1; i <= a1.size() ; i++) {
			int pos1 = a1.get(i-1);
			for (int j = 0; j <= a2.size(); j++) {
				dp[i][j] = dp[i-1][j];
				if (j-1>=0) {
					int pos2 = a2.get(j-1);
					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
				}
			}
		}
		System.out.println(dp[a1.size()][a2.size()]);
	}
	
}
",0,Non-plagiarised
7011024d,eea69e7f,"import java.util.*;

public class D {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        ArrayList<Integer> occupied = new ArrayList<>();
        ArrayList<Integer> vacant = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            if (x == 1)
                occupied.add(i);
            else
                vacant.add(i);
        }

        Solution Solution = new Solution(occupied, vacant);

//        System.out.println(Solution.tabulation());
        System.out.println(Solution.memoization());
    }
}

class Solution {

    ArrayList<Integer> occupied, vacant;
    int x, y;

    public Solution(ArrayList<Integer> occupied, ArrayList<Integer> vacant) {
        this.occupied = occupied;
        this.vacant = vacant;
        x = occupied.size(); y = vacant.size();
    }

    

    

    int memoization() {
        int[][] dp = new int[x][y];
        for (int i = 0; i < x; i++) {
            Arrays.fill(dp[i], -1);
        }
        return memoization(dp, x-1, y-1);
    }

    int memoization(int[][] dp, int n, int m) {
        if(n < 0) {
            return 0;
        }
        if(m < n) {
            return Integer.MAX_VALUE;
        }
        if(dp[n][m] != -1) {
            return dp[n][m];
        }
        int first = memoization(dp, n, m-1);
        int second = memoization(dp, n-1, m-1) + Math.abs(occupied.get(n) - vacant.get(m));
        dp[n][m] = Math.min(first, second);
        return dp[n][m];
    }
}
","import java.util.*;

public class Solution {
	
	public static int minMoves(int[] input) {
		List<Integer> people = new ArrayList<Integer>();
		List<Integer> chairs = new ArrayList<Integer>();
		
		for (int i = 0; i < input.length; i++) {
			if (input[i] == 1) {
				people.add(i);
			} else {
				chairs.add(i);
			}
		}
		
		int[] memo = new int[chairs.size() + 1];
		

		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
			int prev = memo[p];
			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
			for (int c = p + 1; c <= chairs.size(); c++) {
				int tmp = memo[c];
				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
				prev = tmp;
			}
		}
		return memo[memo.length - 1];
	}
	
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] input = new int[n];
		for (int i = 0; i < n; i++) {
			input[i] = sc.nextInt();
		}
		
		System.out.println(Solution.minMoves(input));
		
	}
}
",0,Non-plagiarised
1469697d,69c86b61,"import java.util.*;
import java.io.*;

public class Test {
    // global variables
    static final long INF = 1000000000000000000L;

    

    static FastReader s;

    public static void main(String[] args)
            throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {

            PrintStream ps = new PrintStream(new File(""output.txt""));
            InputStream is = new FileInputStream(""input.txt"");
            System.setIn(is);

            System.setOut(ps);
        }
        long t = 1;
        s = new FastReader();

        t = s.nextLong();

        for (int i = 1; i <= t; i++)
            solve();

    }

    public static void solve() throws IOException {
        long n = s.nextLong();
        ArrayList<Long> k = new ArrayList<Long>((int)n + 1);
        k.add(0L);
        ArrayList<Long> h = new ArrayList<Long>((int) n + 1);
        h.add(0L);
        ArrayList<Long> dp = new ArrayList<Long>((int) n + 1);
        dp.add(0L);
        for (int i = 1; i <= n; i++) {
            long k_ = s.nextLong();
            k.add(k_);
        }
        for (int i = 1; i <= n; i++) {
            long h_ = s.nextLong();
            h.add(h_);
            dp.add(0L);
        }
        for (int i = 1; i <= n; i++) {
            long var = k.get(i) - h.get(i) + 1;
            for (int j = i - 1; (j > 0 && k.get(j) >= var); j--) {
                long var2 = k.get(j) - h.get(j) + 1;
                if (var2 <= var) {
                    var = var2;
                }
            }
            int j = i - 1;
            for (; j > 0; j--) {
                if (k.get(j) < var) {
                    break;
                }
            }
            long var3 = k.get(i) - var + 1;
            if (j != 0) {
                dp.set(i, (dp.get(j) + (var3 * (var3 + 1)) / 2));
            } else
            {
                dp.set(i, ((var3 * (var3 + 1)) / 2));
            }

        }
        System.out.println(dp.get((int) n));
    }
}
","import java.util.*;
import java.io.*;

public class Test {
    // global variables
    static final long INF = 1000000000000000000L;

    

    static FastReader s;

    public static void main(String[] args)
            throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {

            PrintStream ps = new PrintStream(new File(""output.txt""));
            InputStream is = new FileInputStream(""input.txt"");
            System.setIn(is);

            System.setOut(ps);
        }
        long t = 1;
        s = new FastReader();

        t = s.nextLong();

        for (int i = 1; i <= t; i++)
            solve();

    }

    public static void solve() throws IOException {
        long n = s.nextLong();
        ArrayList<Long> k = new ArrayList<Long>((int)n + 1);
        k.add(0L);
        ArrayList<Long> h = new ArrayList<Long>((int) n + 1);
        h.add(0L);
        ArrayList<Long> dp = new ArrayList<Long>((int) n + 1);
        dp.add(0L);
        for (int i = 1; i <= n; i++) {
            long k_ = s.nextLong();
            k.add(k_);
        }
        for (int i = 1; i <= n; i++) {
            long h_ = s.nextLong();
            h.add(h_);
            dp.add(0L);
        }
        for (int i = 1; i <= n; i++) {
            long var = k.get(i) - h.get(i) + 1;
            for (int j = i - 1; (j > 0 && k.get(j) >= var); j--) {
                long var2 = k.get(j) - h.get(j) + 1;
                if (var2 <= var) {
                    var = var2;
                }
            }
            int j = i - 1;
            for (; j > 0; j--) {
                if (k.get(j) < var) {
                    break;
                }
            }
            long var3 = k.get(i) - var + 1;
            if (j != 0) {
                dp.set(i, (dp.get(j) + (var3 * (var3 + 1)) / 2));
            } else
            {
                dp.set(i, ((var3 * (var3 + 1)) / 2));
            }

        }
        System.out.println(dp.get((int) n));
    }
}
",1,Plagiarised
1ea771ea,b9219544,"import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
","import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class x1547E
{
    public static void main(String hi[]) throws Exception
    {
        FastScanner infile = new FastScanner();
        StringBuilder sb = new StringBuilder();
        int T = infile.nextInt();
        while(T-->0)
        {
            int N = infile.nextInt();
            int K = infile.nextInt();
            int[] locs = infile.nextInts(K);
            int[] temps = infile.nextInts(K);
            long[] arr = new long[N];
            Arrays.fill(arr, Long.MAX_VALUE/2);
            for(int i=0; i < K; i++)
                arr[locs[i]-1] = temps[i];
            long[] suffix = new long[N];
            suffix[N-1] = arr[N-1];
            for(int i=N-2; i >= 0; i--)
                suffix[i] = min(arr[i], suffix[i+1]+1);
            long[] prefix = new long[N];
            prefix[0] = arr[0];
            for(int i=1; i < N; i++)
                prefix[i] = min(arr[i], prefix[i-1]+1);
            for(int i=0; i < N; i++)
            {
                long res = min(prefix[i], suffix[i]);
                sb.append(res+"" "");
            }
            sb.append(""\n"");
        }
        System.out.print(sb);
    }
}

",0,Non-plagiarised
8a729537,abd16ff0,"import java.io.*;
import java.util.*;

public class test3 {

	public static void main(String[] args) throws  IOException {
		FastReader f = new FastReader();
		int t = f.nextInt();
		while(t-->0) {
			 int n = f.nextInt();
			 int C[] = new int[n];
			 long ans=Long.MAX_VALUE,pre = 0;
			 PriorityQueue<Integer> epq = new PriorityQueue<Integer>();
			 PriorityQueue<Integer> opq = new PriorityQueue<Integer>();
			 for(int i = 0;i<n;i++) {
				 C[i] = f.nextInt();
				 if(i%2==0)epq.add(C[i]);
				 else opq.add(C[i]);
				 pre+=C[i];
				 if(i>0) {
					 ans  = Math.min(ans,pre+ ((long)n-(long)epq.size())*(long)epq.peek()
							 		+ ((long)n-(long)opq.size())*(long)opq.peek());
				 }
			 }
			 System.out.println(ans);
			}
    }
	
	
	
	

	
	
	
    
	  
		
	 
	 

 }
","import java.util.*;

public class Solve{

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
       
       
        while(t-->0){
            int n=sc.nextInt();
           long ans=Long.MAX_VALUE;
           long pre=0;
           PriorityQueue<Long> epq=new PriorityQueue<>();
           PriorityQueue<Long> opq=new PriorityQueue<>();
           for(int i=0;i<n;i++){
               long a=sc.nextInt();
               if(i%2==0)opq.add(a);
               else epq.add(a);
               pre+=a;
              if(i>0) ans=Math.min(ans,pre+opq.peek()*(n-opq.size())+epq.peek()*(n-epq.size()));
               
           }
          System.out.println(ans);
        }
    }
}
",1,Plagiarised
21c9b214,d5a20936,"import java.util.*;
import java.io.*;
 
public class AiseHi {
	static Scanner sc = new Scanner(System.in);
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		z : while(t-->0) {
			int n = sc.nextInt();
			char sadsasa[] = sc.next().toCharArray();
			char sadsdsdsasa[] = sc.next().toCharArray();
			
			if(sadsdscds(sadsasa, sadsdsdsasa)) {
				System.out.print(""0\n"");
				continue;
			}
			
			int sadsdscdhggs = 0, sadsdscdiyuihggs = 0, sadsdscdiyhtruihggs = 0, poinhnhgs = 0;
			
			for(int i=0;i<n;i++) {
				if(sadsasa[i]!=sadsdsdsasa[i]) {
					if(sadsasa[i] == '0') poinhnhgs++;
					else sadsdscdiyhtruihggs++;
				}
				else {
					if(sadsasa[i] == '0') sadsdscdiyuihggs++;
					else sadsdscdhggs++;
				}
			}
			
			int rtenymu = 0;
			
		    rtenymu = uiuyfdsfrinhgw(sadsdscdhggs, sadsdscdiyuihggs, sadsdscdiyhtruihggs, poinhnhgs);

			rtenymu = Math.min(rtenymu, uiuyfdsfrinhgwdss(sadsdscdhggs, sadsdscdiyuihggs, sadsdscdiyhtruihggs, poinhnhgs));
			
			
			if(rtenymu == Integer.MAX_VALUE) {
				rtenymu = -1;
			}
			
			System.out.print(rtenymu+""\n"");
		}
	}
	private static int uiuyfdsfrinhgwdss(int sadsdscdhggs, int sadsdscdiyuihggs, int sadsdscdiyhtruihggs, int poinhnhgs) {
		boolean rtenymuefwefw = false;
		int uiuyinhgw = 0;
		while(true) {
			if(sadsdscdiyhtruihggs == 0 && poinhnhgs == 0) return uiuyinhgw;
			if((rtenymuefwefw && sadsdscdhggs == 0) || (!rtenymuefwefw && sadsdscdiyhtruihggs == 0)) return Integer.MAX_VALUE;
			
			if(rtenymuefwefw) {
				int td1 = sadsdscdiyuihggs;
				int td0 = sadsdscdhggs - 1;
				int te1 = poinhnhgs + 1;
				int te0 = sadsdscdiyhtruihggs;
				
				sadsdscdiyhtruihggs = td1;
				poinhnhgs = td0;
				sadsdscdhggs = te1;
				sadsdscdiyuihggs = te0;
			}
			else {
				int td1 = 1 + sadsdscdiyuihggs;
				int td0 = sadsdscdhggs;
				int te1 = poinhnhgs;
				int te0 = sadsdscdiyhtruihggs-1;
				
				sadsdscdiyhtruihggs = td1;
				poinhnhgs = td0;
				sadsdscdhggs = te1;
				sadsdscdiyuihggs = te0;
			}
			
			rtenymuefwefw = !rtenymuefwefw;
			uiuyinhgw++;
		}
	}
	private static int uiuyfdsfrinhgw(int sadsdscdhggs, int sadsdscdiyuihggs, int sadsdscdiyhtruihggs, int poinhnhgs) {
		boolean rtenymuefwefw = true;
		int uiuyinhgw = 0;
		while(true) {
			if(sadsdscdiyhtruihggs == 0 && poinhnhgs == 0) return uiuyinhgw;
			if((rtenymuefwefw && sadsdscdhggs == 0) || (!rtenymuefwefw && sadsdscdiyhtruihggs == 0)) return Integer.MAX_VALUE;
			
			if(rtenymuefwefw) {
				int td1 = sadsdscdiyuihggs;
				int td0 = sadsdscdhggs - 1;
				int te1 = poinhnhgs + 1;
				int te0 = sadsdscdiyhtruihggs;
				
				sadsdscdiyhtruihggs = td1;
				poinhnhgs = td0;
				sadsdscdhggs = te1;
				sadsdscdiyuihggs = te0;
			}
			else {
				int td1 = 1 + sadsdscdiyuihggs;
				int td0 = sadsdscdhggs;
				int te1 = poinhnhgs;
				int te0 = sadsdscdiyhtruihggs-1;
				
				sadsdscdiyhtruihggs = td1;
				poinhnhgs = td0;
				sadsdscdhggs = te1;
				sadsdscdiyuihggs = te0;
			}
			
			rtenymuefwefw = !rtenymuefwefw;
			uiuyinhgw++;
		}
	}
	private static boolean sadsdscds(char[] sadsasa, char[] sadsdsdsasa) {
		for(int i=0;i<sadsasa.length;i++) {
			if(sadsasa[i]!=sadsdsdsasa[i]) return false;
		}
		return true;
	}
	
	
	
	
	
	
	 
	
	
	
	
  
    
//	private static boolean check(long n,long val) {
//		if(n == 0) return true;
//		
//		while(val<=n) {
////			if(check(n-val,))
//		}
//	}
	
	
	
	
//	static int ceil(int sadsasa,int sadsdsdsasa) {
//		return sadsasa/sadsdsdsasa + (sadsasa%sadsdsdsasa==0?0:1);
//	}
//	static int fac[] = new int[2000009];
	
	
//	static long gcd(long sadsasa,long sadsdsdsasa) { if(sadsdsdsasa==0) return sadsasa; return gcd(sadsdsdsasa,sadsasa%sadsdsdsasa); }
}
 



","import java.util.*;
import java.io.*; 
  
public class Main {
	 
	static long mod = (long)(1e9+7); 
//	 static long mod = 998244353; 
//	 static Scanner sc = new Scanner(System.in); 
	static FastReader sc = new FastReader(); 
	static PrintWriter out = new PrintWriter(System.out);
	static int ans;
	public static void main (String[] args) {
		int ttt = 1;
		ttt = sc.nextInt();
		z :for(int tc=1;tc<=ttt;tc++){
			int n = sc.nextInt();
			char a[] = sc.next().toCharArray();
			char b[] = sc.next().toCharArray();
			
			if(same(a, b)) {
				out.write(""0\n"");
				continue;
			}
			
			int e1 = 0, e0 = 0, d1 = 0, d0 = 0;
			
			for(int i=0;i<n;i++) {
				if(a[i]!=b[i]) {
					if(a[i] == '0') d0++;
					else d1++;
				}
				else {
					if(a[i] == '0') e0++;
					else e1++;
				}
			}
			
			int ans = 0;
			
//			if(e1 + e0 <= d1 + d0) {
				ans = solveByFirstD(e1, e0, d1, d0);
//			}
//			else {
				ans = Math.min(ans, solveByFirstE(e1, e0, d1, d0));
//			}
			
			if(ans == Integer.MAX_VALUE) {
				ans = -1;
			}
			
			out.write(ans+""\n"");
		}
		out.close();
	}
	private static int solveByFirstD(int e1, int e0, int d1, int d0) {
		boolean is = false;
		int cnt = 0;
		while(true) {
			if(d1 == 0 && d0 == 0) return cnt;
			if((is && e1 == 0) || (!is && d1 == 0)) return Integer.MAX_VALUE;
			
			if(is) {
				int td1 = e0;
				int td0 = e1 - 1;
				int te1 = d0 + 1;
				int te0 = d1;
				
				d1 = td1;
				d0 = td0;
				e1 = te1;
				e0 = te0;
			}
			else {
				int td1 = 1 + e0;
				int td0 = e1;
				int te1 = d0;
				int te0 = d1-1;
				
				d1 = td1;
				d0 = td0;
				e1 = te1;
				e0 = te0;
			}
			
			is = !is;
			cnt++;
		}
	}
	private static int solveByFirstE(int e1, int e0, int d1, int d0) {
		boolean is = true;
		int cnt = 0;
		while(true) {
			if(d1 == 0 && d0 == 0) return cnt;
			if((is && e1 == 0) || (!is && d1 == 0)) return Integer.MAX_VALUE;
			
			if(is) {
				int td1 = e0;
				int td0 = e1 - 1;
				int te1 = d0 + 1;
				int te0 = d1;
				
				d1 = td1;
				d0 = td0;
				e1 = te1;
				e0 = te0;
			}
			else {
				int td1 = 1 + e0;
				int td0 = e1;
				int te1 = d0;
				int te0 = d1-1;
				
				d1 = td1;
				d0 = td0;
				e1 = te1;
				e0 = te0;
			}
			
			is = !is;
			cnt++;
		}
	}
	private static boolean same(char[] a, char[] b) {
		for(int i=0;i<a.length;i++) {
			if(a[i]!=b[i]) return false;
		}
		return true;
	}
	
	 
	 
	 
	 
	 
}
",1,Plagiarised
0fd5b95a,6490bbe8,"import java.io.PrintWriter;
import java.util.*;
public class codeforces {
	static int dp[][]=new int[5001][5001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);  
		PrintWriter out=new PrintWriter(System.out);
        int t=1;
        for(int tt=0;tt<t;tt++) {
        	int n=s.nextInt();
        	int a[]=new int[n];
        	ArrayList<Integer> z=new ArrayList<>();
        	ArrayList<Integer> o=new ArrayList<>();
        	for(int i=0;i<n;i++) {
        		a[i]=s.nextInt();
        		if(a[i]==1) {
        			o.add(i);
        		}else {
        			z.add(i);
        		}
        	}
        	for(int i=0;i<5001;i++) {
        		Arrays.fill(dp[i], -1);
        	}
        	System.out.println(sol(0,0,z,o));
        }
        out.close();
	    s.close();
	}
	
	
	
	
	public static int sol(int i,int j,ArrayList<Integer> z,ArrayList<Integer> o) {
		if(j==o.size()) {
			return 0;
		}
		int h=z.size()-i;
		int l=o.size()-j;
		if(i==z.size()) {
			return 10000000;
		}
		if(dp[i][j]!=-1) {
			//System.out.println(i+"" ""+j);
			return dp[i][j];
		}
		int ans1=sol(i+1,j,z,o);
		int ans2=sol(i+1,j+1,z,o)+Math.abs(z.get(i)-o.get(j));
		dp[i][j]=Math.min(ans1, ans2);
		return dp[i][j];
	}
}
","import java.util.*;
// import java.lang.*;
import java.io.*;

//           THIS TEMPLATE MADE BY AKSH BANSAL.

public class Solution {
    
    private static boolean[] isPrime;
    
    
    
    // static ArrayList<Integer>[] adj;
    // static void getAdj(int n,int q, FastReader sc){
    //     adj = new ArrayList[n+1];
    //     for(int i=1;i<=n;i++){
    //         adj[i] = new ArrayList<>();
    //     }
    //     for(int i=0;i<q;i++){
    //         int a = sc.nextInt();
    //         int b = sc.nextInt();

    //         adj[a].add(b);
    //         adj[b].add(a);
    //     }
    // }
    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        // primes();
        // ________________________________

        // int t = sc.nextInt();
        // StringBuilder output = new StringBuilder();

        // while (t-- > 0) {

        //     output.append(solver()).append(""\n"");
        // }

        // out.println(output);
        // _______________________________

        int n = sc.nextInt();
        int arr[] = new int[n];
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        out.println(solver(n, arr));
        // ________________________________
        out.flush();
    }

    public static long solver(int n, int[] arr) {
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for(int i=0;i<n;i++){
            if(arr[i] ==1){
                a.add(i);
            }
            else{
                b.add(i);
            }
        }
        // System.out.println(""__""+ a);
        // System.out.println(""__""+ b);
        long inf = (long)1e10;
        int aLen = a.size(), bLen = b.size();
        long[][] dp = new long[bLen+1][aLen+1];
        for(int i=0;i<bLen+1;i++)Arrays.fill(dp[i],inf);
        // dp[0][0] = 0;
        for(int i=0;i<=bLen;i++){
            dp[i][0] = 0;
        }
        for(int i=1;i<=bLen;i++){
            for(int j=1;j<=i && j<=aLen;j++){
                int aa = a.get(j-1);
                int bb = b.get(i-1);
                // System.out.println((i-1)+"" ""+(j-1)+""__""+ aa+"" ""+bb);
                dp[i][j] = Math.min(
                    Math.abs(aa-bb)+dp[i-1][j-1],
                    dp[i-1][j]
                );
                // System.out.println((i-1)+"" ""+(j-1)+""__""+ dp[i][j]);
            }
        }
        // for(int i=0;i<=bLen;i++){
        //     for(int j=0;j<=aLen;j++){
        //         System.out.print(dp[i][j]+"" "");
        //     }
        //     System.out.println(""__"" );
        // }
        return dp[bLen][aLen]==inf?0:dp[bLen][aLen];
    }
}
",0,Non-plagiarised
1d43139f,fdd41565,"import java.util.*;
import java.io.*;
public class experiment {
	 
	
		 public static void main(String[] args) throws IOException  {
			FastReader sc = new FastReader();
			PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
			int t = sc.nextInt();
			while( t-- > 0) {
				char arr[] = new char[5];
				for( int i = 0 ;i< 5 ;i++) {
					arr[i] = (char)(i + 97);
				}
				int n =sc.nextInt();
				ArrayList<String> input = new ArrayList<>();
				for( int i = 0 ;i< n;i++) {
					input.add( sc.next());
				}
				int max = 0;
				for( int i = 0 ; i< 5 ;i++) {
					int test = 0;
					int sum = 0;
					char now = arr[i];
					ArrayList<Integer> temp = new ArrayList<>();
					for( int j = 0 ; j < input.size(); j++) {
						int local = 0;
						for( int k = 0 ; k < input.get(j).length(); k++) {
							if( input.get(j).charAt(k) == now) {
								local++;
							}
						}
						temp.add( local - (input.get(j).length() - local));
					}
					Collections.sort(temp , Collections.reverseOrder());
					//out.println( temp);
					for( int j = 0 ; j < n ; j++) {
						sum+=temp.get(j);
						if( sum<=0) {
							break;
						}
						test++;
					}
					max = Math.max(max, test);
				}
				out.println( max);
			}
			out.flush();
				
		 }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
     FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0)
     {
      Solve solve=new Solve();
      t--;
      int n=s.nextInt();
      String str[]=new String[n];
      for(int i=0;i<n;i++)
      str[i]=s.nextLine();
      char array[]=new char[]{'a','b','c','d','e'};
      int arr[]=new int[n];
      int ans=0;
      for(int i=0;i<5;i++)
      {
        Arrays.fill(arr,0);
          for(int j=0;j<n;j++)
          {
                 for(int k=0;k<str[j].length();k++)
                 {
                     if(str[j].charAt(k)==array[i])
                     arr[j]++;
                     else
                     arr[j]--;
                 }
          }
          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
      }
      System.out.println(ans);
     }
    }
}
class Solve{
    public int solve(int arr[],int n)
    {
        int ans=0;
        int sum=0;
        Arrays.sort(arr);
        for(int i=n-1;i>=0;i--)
        {
            if(sum+arr[i]>0)
            {
                sum+=arr[i];
                ans++;
            }
            else
            break;
        }
        return ans;
    }
}

",0,Non-plagiarised
6bcc5afd,cb87df79,"import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner s=new Scanner(System.in);
     int n=s.nextInt();
     int a[]=new int[n];
     ArrayList<Integer> lt1=new ArrayList<>();
     ArrayList<Integer> lt0=new ArrayList<>();
     for(int i=0;i<n;i++)
     {
         int l=s.nextInt();
         if(l==0)
         lt0.add(i+1);
         else
         lt1.add(i+1);
     }
     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
     for(int i=1;i<=lt1.size();i++)
     {
         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
         for(int j=i+1;j<=lt0.size();j++)
         {
             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
         }
     }
     System.out.println(dp[lt1.size()][lt0.size()]);
     
    }
}
","import java.util.*;

public class Longjumps {
	 public static void main(String[] args){
		 Scanner sc=new Scanner(System.in);
			ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
			int n = sc.nextInt();
			for(int i=1;i<=n;i++){
				int x=sc.nextInt();
				if(x==1)o.add(i);
				else e.add(i);
			}
			int dp[][]=new int[o.size()+1][e.size()+1];
			for(int i=1;i<=o.size();i++){
				dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
				for(int j=i+1;j<=e.size();j++)
					dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
			}
			System.out.println(dp[o.size()][e.size()]);
	 }
}
",1,Plagiarised
0b91922c,71a4f6d2,"import java.util.*;
import java.lang.*;
import java.io.*;   
import java.math.*;
public class Prac{     
    
    
    
    
    
    //static long lcm(long a,long b){return (a/gcd(a,b))*b;}
    static PrintWriter w = new PrintWriter(System.out);
    //static int r[]={0,1,0,-1}, c[]={1,0,-1,0};
    static int[] nextG(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ng[] = new int[n];
        for(int i = 0 ; i < n ; i++){
            while(!s.isEmpty() && arr[s.peek()] <= arr[i]){
                ng[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ng[s.pop()] = n;
        }
        return ng;
    }
    static int[] nextS(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ns[] = new int[n];
        for(int i = 0 ; i < n ; i++){
            while(!s.isEmpty() && arr[s.peek()] >= arr[i]){
                ns[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ns[s.pop()] = n;
        }
        return ns;
    }
    static int[] prevG(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int pg[] = new int[n];
        for(int i = n-1 ; i >= 0 ; i--){
            while(!s.isEmpty() && arr[s.peek()] <= arr[i]){
                pg[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            pg[s.pop()] = -1;
        }
        return pg;
    }
    static int[] prevS(int arr[]){
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int ps[] = new int[n];
        for(int i = n-1 ; i >= 0 ; i--){
            while(!s.isEmpty() && arr[s.peek()] >= arr[i]){
                ps[s.pop()] = i;
            }
            s.add(i);
        }
        while(!s.isEmpty()){
            ps[s.pop()] = -1;
        }
        return ps;
    }
    public static void main(String [] args){
        InputReader sc=new InputReader(System.in); 
        
        int n = sc.ni();
        int arr [] = sc.nia(n);
        int ng[] = nextG(arr);
        int ns [] = nextS(arr);
        int pg[] = prevG(arr);
        int ps[] = prevS(arr);
        int ans[]=new int[n];
        
        Arrays.fill(ans,10000000);
        ans[n-1] = 0;
        for(int i = n -1 ; i >= 0 ; i --){
            if(ns[i] != n){
                ans[i] = Math.min(ans[i] , ans[ns[i]]+1);
            }
            if(ng[i] != n){
                ans[i] = Math.min(ans[i] , ans[ng[i]]+1);
            }
            if(pg[i] != -1){
                ans[pg[i]] = Math.min(ans[pg[i]] , ans[i]+1);
            }
            if(ps[i] != -1){
                ans[ps[i]] = Math.min(ans[ps[i]] , ans[i]+1);
            }
        }
        
        w.println(ans[0]);
        w.close();
    }
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Vector;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Stack;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DDiscreteCentrifugalJumps solver = new DDiscreteCentrifugalJumps();
        solver.solve(1, in, out);
        out.close();
    }

    static class DDiscreteCentrifugalJumps {
        public void solve(int testNumber, InputReader s, PrintWriter w) {
            int n = s.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = s.nextInt();
            int[] dp = new int[n];
            for (int i = 0; i < n; i++)
                dp[i] = i;
            Stack<Integer> dec = new Stack<>();
            dec.push(0);
            Stack<Integer> inc = new Stack<>();
            inc.push(0);
            for (int i = 1; i < n; i++) {
                while (!dec.isEmpty() && a[dec.peek()] < a[i]) {
                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
                    dec.pop();
                }
                if (!dec.isEmpty()) {
                    dp[i] = Math.min(dp[i], dp[dec.peek()] + 1);
                    if (a[dec.peek()] == a[i])
                        dec.pop();
                }
                dec.push(i);
                while (!inc.isEmpty() && a[inc.peek()] > a[i]) {
                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
                    inc.pop();
                }
                if (!inc.isEmpty()) {
                    dp[i] = Math.min(dp[i], dp[inc.peek()] + 1);
                    if (a[inc.peek()] == a[i])
                        inc.pop();
                }
                inc.push(i);
            }
            w.println(dp[n - 1]);
        }

    }

    
}
",0,Non-plagiarised
08b9908d,f5fb1b62,"import java.util.*;
import java.io.*;
import java.math.*;


public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];

	   static PrintWriter out=new PrintWriter(System.out);
	  public static void main(String[] args)
{
		    //CHECK FOR N=1
	       	//CHECK FOR N=1
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		      ttt =i();
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int k=i();
	        	int P[]=input(k);
	        	int Q[]=input(k);
	        	long A[]=new long[n+1];
	        	Arrays.fill(A, Integer.MAX_VALUE);
	        	for(int i=0;i<k;i++) {
	        		A[P[i]]=Q[i];
	        	}
	        	long B[]=new long[n+1];
	        	long C[]=new long[n+1];
	        	Arrays.fill(B, Integer.MAX_VALUE);
	        	Arrays.fill(C, Integer.MAX_VALUE);
	        	for(int i=n;i>0;i--) {
	        		if(i+1<=n) {
	        			B[i]=Math.min(A[i],B[i+1]+1);
	        		}
	        		else {
	        			B[i]=A[i];
	        		}
	        	}
	        	for(int i=1;i<=n;i++) {
	        		if(i-1>0) {
	        			C[i]=Math.min(A[i],C[i-1]+1);
	        		}
	        		else {
	        			C[i]=A[i];
	        		}
	        	}
	        	for(int i=1;i<=n;i++) {
	        		out.print(Math.min(B[i],C[i])+"" "");
	        	}
	        	out.println();
	        	
	        	
	        	
	        	
	        	
	        }
	        //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	
		        
		     
    }
	  
	  
	  
	  
	  

//FENWICK TREE



//END
//static void add(int v) {
//	if(!map.containsKey(v)) {
//		map.put(v, 1);
//	}
//	else {
//		map.put(v, map.get(v)+1);
//	}
//}
//static void remove(int v) {
//	if(map.containsKey(v)) {
//		map.put(v, map.get(v)-1);
//		if(map.get(v)==0)
//			map.remove(v);
//	}
//}




static int[] input(int n) {
	int A[]=new int[n];
	   for(int i=0;i<n;i++) {
		   A[i]=sc.nextInt();
	   }
	   return A;
   }






















     static int i() {
    	 return sc.nextInt();
     }
     
       
     
     
  
  
  
      
      
      
      
     
        
     
}
","import java.util.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

//import graphs.Segment_Trees.FastReader;

public class PW {
	
	//private static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
	
	public static int memo[][];
	public static FastReader s = new FastReader();
	public static List<Long> primes;
	public static int sz= 1000000;
	//public static int arr[];
	public static int MOD=1000000007;
	public static List<List<Integer>> adj;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	 
		//FastScanner sc=new FastScanner();
		 
		int t=s.nextInt();
		
		while(t-- >0)
		{
			
			//int n=0,a=0,b=0;
			int n=s.nextInt();
			int k=s.nextInt();
	
			  long arr[]=new long[n];
			  Arrays.fill(arr,Long.MAX_VALUE/10);
			  int ac[]=new int[k];
			  long tmp[]=new long[k];
			  for(int i = 0 ; i < k ; i++){
			    ac[i]=s.nextInt();
			    ac[i]--;
			  }
			  for(int i = 0 ; i < k ; i++){
			    tmp[i]=s.nextLong();
			    arr[ac[i]] = tmp[i];
			  }
			  long P[] = getP(arr, n);
			  
			  int i=0,j=arr.length-1;
			  while(i<=j)
			  {
				  long temp=arr[i];
				  arr[i]=arr[j];
				  arr[j]=temp;
				  i++;
				  j--;
			  }
			  //reverse(all(arr));
			  long[] S = getP(arr, n);
			  //reverse(all(S));
			  i=0;j=S.length-1;
			  while(i<=j)
			  {
				  long temp=S[i];
				  S[i]=S[j];
				  S[j]=temp;
				  i++;
				  j--;
			  }
			  for(i = 0 ; i < n ; i++){
			    System.out.print(Math.min(P[i], S[i])+"" "");
			  }
			  System.out.println();
			
		}
		
	}
	
	public static long[] getP(long []arr, int n){
		  long mn = Long.MAX_VALUE/10;
		  long P[]=new long[n];
		  Arrays.fill(P, Long.MAX_VALUE/10);
		  int cnt = 0;
		  for(int i = 0 ; i < n ; i++){
		    long curr = arr[i];
		    if(mn + cnt < curr){
		      P[i] = mn + cnt;
		    }else{
		      mn = arr[i];
		      P[i] = arr[i];
		      cnt  = 0;
		    }
		    cnt++;
		  }
		  return  P;
		}
		
	
		
	
	
	
	
	
	

	
	
	
	
	
//	public static long fastExpo(long a, long n, long mod) {
//		  long result = 1;
//		  while (n > 0) {
//		    if ((n & 1)>0)
//		      result = (result * a) % mod;
//		    a = (a * a) % mod;
//		    n >>= 1;
//		  }
//		  return result;
//		}
//	1  4   8
	
	
	 
	
	 
	
	
	
	
	
	
	
	
	    public static String largestNumber( List<String> ab) {
	        
	       // List<String> ab= new ArrayList<>();
	       // for(int i=0;i<A.size();i++)
	       // {
	       //     ab.add(String.valueOf(A.get(i)));
	       // }
	        
	        Collections.sort(ab, new Comparator<String>(){ 
	            
	            
	            
	            
	            
	        });
	        StringBuilder abc= new StringBuilder();
	        
	        
	        for(int i=0;i<ab.size();i++)
	        {
	           abc.append(ab.get(i));
	            
	        }
	        if(abc.length()==0)
	            return abc.toString();
	        
	        if(abc.charAt(0)=='0')
	        return ""0"";
	        else
	        return abc.toString();
	        
	    }
	
	
	
	
	
	
	

	
	
	
	
	
	
	
	
	
	
}

 
",0,Non-plagiarised
00c0b82a,1ea771ea,"import java.util.*;
public class E1547 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        for(int i = 0; i < q; i++){
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[][] t = new int[k][2];
            for(int j = 0; j < k; j++){
                t[j][0] = sc.nextInt();//room
            }
            for(int j = 0; j < k; j++){
                t[j][1] = sc.nextInt();//air
            }
            long[] left = new long[n];
            long[] right = new long[n];
            long tmp = Integer.MAX_VALUE;
            long[] max =new long[n];
            for(int j = 0; j < n; j++){
                max[j] = Integer.MAX_VALUE;
            }
            for (int j = 0; j < k; j++) {
                max[t[j][0]-1] = t[j][1];
            }
            for (int j = 1; j <= n; j++) {
                tmp = Math.min(tmp+1, max[j-1]);
                left[j-1] = tmp;
            }
            for(int j = n; j >= 1; j--){
                tmp = Math.min(tmp+1, max[j-1]);
                right[j-1] = tmp;
            }
            for(int j = 0; j < n; j++){
                System.out.print(Math.min(left[j], right[j]) + "" "");
            }
            System.out.println();
        }
    }
}
","import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
",0,Non-plagiarised
73f57af1,9a20c823,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	static PrintWriter out;
	static FastReader scan;

    /*-------- I/O usaing short named function ---------*/
	
	public static int ni(){return scan.nextInt();}
	public static long nl(){return scan.nextLong();}
	
	
	
	
	public static void pn(Object o){out.println(o);}
    /*-------- for output of an array ---------------------*/
     
	
	
	
    /*-------------- for input in an array ---------------------*/
	
	
	
	
	/*------------ 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
	 

    static long[] l, r;
	public static void main (String[] args) throws java.lang.Exception
	{
		OutputStream outputStream =System.out;
        out =new PrintWriter(outputStream);
        scan =new FastReader();
		//for fast output sometimes
		StringBuilder sb = new StringBuilder();
		int t = ni();
		while(t-->0){
			int n = ni();
			l = new long[n];
			r = new long[n];

			for(int i=0; i<n; i++){
				l[i] = nl();
				r[i] = nl();
			}

			//lPA(l);
			//lPA(r);

			ArrayList<Integer> adj[] = new ArrayList[n];
			for(int i=0; i<n; i++)
				adj[i] = new ArrayList<Integer>();

			for(int i=0; i<n-1; i++){
				int u = ni()-1, v = ni()-1;
				adj[u].add(v);
				adj[v].add(u);
			}

			dp = new Long[n][2];
			visited = new boolean[n];
			long ans = Math.max(solve(adj, 0, 0, visited), solve(adj, 0, 1, visited));
			pn(ans);
        }
        out.flush();
		out.close();
	}

	static Long dp[][];
	static boolean visited[];
	static long solve(ArrayList<Integer> adj[], int vertex, int prev, boolean visited[]){

		visited[vertex] = true;
		if(dp[vertex][prev] != null)
			return dp[vertex][prev];
		long ans = 0;
		for(int x : adj[vertex]){
			if(!visited[x]){
				if(prev == 0){
					ans += Math.max(Math.abs(l[vertex] - l[x]) + solve(adj, x, 0, visited),
						Math.abs(l[vertex] - r[x]) + solve(adj, x, 1, visited));
					//pn(vertex + "" "" + x + "" "" + ans);
				}else{
					ans += Math.max(Math.abs(r[vertex] - l[x]) + solve(adj, x, 0, visited),
						Math.abs(r[vertex] - r[x]) + solve(adj, x, 1, visited));
					//pn(vertex + "" "" + x + "" "" + ans);
				}
			}
		}
		visited[vertex] = false;
		//pn(ans);
		return dp[vertex][prev] = ans;	
	}
	
	
}
","import java.util.*;
import java.io.*;

public class Parsas_Humongous_Tree {

	

	

	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader t = new FastReader();
		PrintWriter o = new PrintWriter(System.out);
		int test = t.nextInt();

		while (test-- > 0) {
			int n = t.nextInt();
			long[][] cost = new long[n][2];
			List<Integer>[] graph = new ArrayList[n];
			dp = new long[n][2];

			for (int i = 0; i < n; ++i) {
				cost[i][0] = t.nextLong();
				cost[i][1] = t.nextLong();
				graph[i] = new ArrayList<>();
			}

			for (int i = 0; i < n - 1; ++i) {
				int x = t.nextInt() - 1;
				int y = t.nextInt() - 1;

				graph[x].add(y);
				graph[y].add(x);
			}

			o.println(Math.max(dfs(graph, cost, 0, 0, -1), dfs(graph, cost, 0, 1, -1)));
		}

		o.flush();
		o.close();
	}

	private static long[][] dp;

	private static long dfs(List<Integer>[] graph, long[][] cost, int u, int j, int par) {
		if (dp[u][j] != 0)
			return dp[u][j];

		for (int v : graph[u])
			if (v != par) {
				long c1 = Math.abs(cost[u][j] - cost[v][0]) + dfs(graph, cost, v, 0, u);
				long c2 = Math.abs(cost[u][j] - cost[v][1]) + dfs(graph, cost, v, 1, u);
				dp[u][j] += Math.max(c1, c2);
			}

		return dp[u][j];
	}
}
",0,Non-plagiarised
680ba922,6e207cbf,"import java.util.*;
import java.io.*;

public class Solution
{
    
    
   
  
  
  
  
  
  
  
 
  
    // 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.*;
import java.lang.*;
import java.io.*;

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        int sm, n;
        while(t > 0) {
            t--;
            n = sc.nextInt();
            String s1,s2;
            s1 = sc.next();
            s2 = sc.next();
            int a[] = new int[4];
            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
            for(int i = 0 ; i < n ; i++) {
                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
                else a[3]++;
            }
            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
            
            if (a[0] == a[1]) {
                n1 = 2*a[0];
            }
            if((a[2] - 1) == a[3]) {
                // System.out.println(a[3] + 1);
                n2 = 2*a[3] + 1;
            } 
            if((a[3] + 1) == a[2]) {
                // System.out.println(a[2] + 1);
                n3 = 2*a[2] + 1;
            } 
            int ans = Math.min(n1, Math.min(n2,n3));
            if(ans == Integer.MAX_VALUE) {
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
	}
}
",0,Non-plagiarised
169e34bf,2bbf754b,"import java.util.*;
public class D{
  static Scanner sc;
  public static void solve(){
    int n=sc.nextInt();
    Integer a[]=new Integer[n];
    int flag;
    for(int i=0;i<n;i++) a[i]=sc.nextInt();
    String s=sc.next();
    ArrayList<Integer> x=new ArrayList<>();
    ArrayList<Integer> y=new ArrayList<>();
    for(int i=0;i<n;i++){
      if(s.charAt(i)=='B') x.add(a[i]);
      else y.add(a[i]);
    }
    Collections.sort(x);
    Collections.sort(y);
    int p=n;
    int q=1;
    for(int i=y.size()-1;i>=0;i--){
      if(y.get(i)>p){System.out.println(""NO""); return;}
      p-=1;
    }
    for(int i=0;i<x.size();i++){
      if(x.get(i)<q){System.out.println(""NO""); return;}
      q+=1;
    }
    System.out.println(""YES"");
  }
  public static void main(String args[]){
      sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0) solve();
  }
}
","import java.util.*;

/** 
__                  __
( _)                ( _)
/ / \\              / /\_\_
/ /   \\            / / | \ \
/ /     \\          / /  |\ \ \
/  /   ,  \ ,       / /   /|  \ \
/  /    |\_ /|      / /   / \   \_\
/  /  |\/ _ '_| \   / /   /   \    \\
|  /   |/  0 \0\    / |    |    \    \\
|    |\|      \_\_ /  /    |     \    \\
|  | |/    \.\ o\o)  /      \     |    \\
\    |     /\\`v-v  /        |    |     \\
| \/    /_| \\_|  /         |    | \    \\
| |    /__/_ `-` /   _____  |    |  \    \\
\|    [__]  \_/  |_________  \   |   \    ()
/    [___] (    \         \  |\ |   |   //
|    [___]                  |\| \|   /  |/
/|    [____]                  \  |/\ / / ||
(  \   [____ /     ) _\      \  \    \| | ||
\  \  [_____|    / /     __/    \   / / //
|   \ [_____/   / /        \    |   \/ //
|   /  '----|   /=\____   _/    |   / //
__ /  /        |  /   ___/  _/\    \  | ||
(/-(/-\)       /   \  (/\/\)/  |    /  | /
(/\/\)           /   /   //
_________/   /    /
\____________/    (



*/

public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int  t=sc.nextInt();
		while(t-- >0) {
			int n=sc.nextInt();
			int[] arr=new int[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextInt();
			}
			String str=sc.next();
			
			ArrayList<Pair> plist=new ArrayList<>();
			for(int i=0;i<n;i++) {
				char ch=str.charAt(i);
				plist.add(new Pair(arr[i],ch));
			}
			
			//B-reduce
			//R-increse
			Collections.sort(plist);
			
			int counter=1;
			boolean flag=false;
			for(int i=0;i<plist.size();i++) {
				int val=plist.get(i).number;
				int clr=plist.get(i).color;
				
				if(clr=='B') {
					if(val<counter) {
						flag=true;
						break;
					}
				}
				else {
					if(val>counter) {
						flag=true;
						break;
					}
					
				}
				counter++;
			}
			System.out.println(flag?""NO"":""YES"");
			
			
		}
	}
	public static class Pair implements Comparable<Pair>{
		int number;
		char color;
		
		Pair(int number,char color){
			this.number=number;
			this.color=color;
		}
		
		
		
		
	}
}
",0,Non-plagiarised
4da08761,6f393cfe,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Solution {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Main solver = new Main();
        boolean multipleTC = true;
        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
        for (int i = 1; i <= testCount; i++)
            solver.solve(in, out, i);
        out.close();
    }
    static class Main {
        PrintWriter out;
        InputReader in;

        public void solve(InputReader in, PrintWriter out, int test) {
            this.out = out;
            this.in = in;
            int n = ni();
            String[] arr = new String[n];
            int[][] freq = new int[n][5];
            int[][] rem = new int[n][5];
            for(int i = 0; i < n; i++){
                arr[i] = n();
                for(int j = 0; j < arr[i].length(); j++)
                    freq[i][arr[i].charAt(j) - 'a']++;
                for(int j = 0; j < 5; j++)
                    rem[i][j] = arr[i].length() - freq[i][j];
            }
            int ans = 0;
            for(int i = 0; i < 5; i++){
                int[] vals = new int[n];
                for(int j = 0; j < n; j++)
                    vals[j] = freq[j][i] - rem[j][i];
                Arrays.sort(vals);
                int sum = 0, x = 0;
                for(int j = n - 1; j >= 0; j--){
                    if(sum + vals[j] > 0){
                        x++;
                        sum += vals[j];
                    } else {
                        break;
                    }
                }
                if(x > ans) {
                    ans = x;
                }
            }
            System.out.println(ans);
        }

        


        String n(){
            return in.next();
        }

        int ni() {
            return in.nextInt();
        }

        


        

    }

    
}
","import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
",0,Non-plagiarised
317a209c,6b97058e,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	
	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
3666e0e8,ac7187d8,"import java.io.*;
import java.lang.*;
import java.util.*;

public class C1499 {
    public static void main(String[] args) throws IOException{
        StringBuffer ans = new StringBuffer();
        StringTokenizer st;
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer(f.readLine());
        int t = Integer.parseInt(st.nextToken());
        for(int i = 0; i < t; i++){
            st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            long op = Long.MAX_VALUE;
            long[] arr = new long[n];
            st = new StringTokenizer(f.readLine());
            for(int x = 0; x < n; x++){
                arr[x] = Integer.parseInt(st.nextToken());
            }
            long sum = arr[0];
            long min = arr[0];
            long min1 = arr[1];
            long howMany = 1;
            long howMany1 = 0;
            long osum = sum;
            for(int x = 1; x < n; x++){
                osum+=arr[x];
                if(x % 2 != 0){
                    sum+= (n - howMany1) *arr[x];
                    sum+=( min *(n-howMany));
                    min1 = Math.min(arr[x], min1);
                    howMany1++;
                }else{
                    sum+= (n - howMany) *arr[x];
                    sum+=( min1 *(n-howMany1));
                    min = Math.min(arr[x], min);
                    howMany++;
                }
                //System.out.println(min1 + "" "" + min1);
                //System.out.println(sum);
                op = Math.min(op, sum);
                sum = osum;
            }

            ans.append(op);
            ans.append(""\n"");

        }
        f.close();



        System.out.println(ans);
    }
    
}
","import java.io.*;
import java.util.*;
public class C {
    public static void main (String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int t = Integer.parseInt(st.nextToken());
        while (t-->0) {
            st = new StringTokenizer(f.readLine());
            int n = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(f.readLine());
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Long.parseLong(st.nextToken());
            }
            solve(n, arr);
        }
    }
    static void solve(long n, long[] arr) {
        long minEven = Integer.MAX_VALUE;
        long minOdd = arr[0];
        long evenSum = 0;
        long oddSum = arr[0];
        long finans = Long.MAX_VALUE;
        long oddAns, evenAns;
        long oddcount=1;
        long evencount=0;
        for (int k = 1; k < n; k++) {
            if (k%2==1) {
                evenSum+=arr[k];
                evencount++;
                minEven = Math.min(minEven, arr[k]);
            } else {
                oddSum+=arr[k];
                oddcount++;
                minOdd = Math.min(minOdd, arr[k]);
            }
            oddAns = oddSum+(n-oddcount)*minOdd;
            evenAns = evenSum+(n-evencount)*minEven;
            finans = Math.min(finans, oddAns+evenAns);
        }
        System.out.println(finans);
    }
}
",0,Non-plagiarised
23cb8587,a5f41b95,"import java.io.*;
import java.util.*;

public class C {

	static long mod = (long) (1e9 + 7);

	public static void main(String[] args) throws IOException {
		Scanner scn = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		StringBuilder sb = new StringBuilder();
		int T = scn.ni(), tcs = 0;
		C: while (tcs++ < T) {
			int n = scn.ni();
			tree = new ArrayList[n + 1];
			range = new long[n + 1][2];
			for (int i = 0; i <= n; i++)
				tree[i] = new ArrayList<>();
			for (int i = 1; i <= n; i++) {
				range[i][0] = scn.nl();
				range[i][1] = scn.nl();
			}
			for (int i = 0; i < n - 1; i++) {
				int x = scn.ni();
				int y = scn.ni();
				tree[x].add(y);
				tree[y].add(x);
			}
			strg = new long[n + 1][2];
			for (long a1[] : strg)
				Arrays.fill(a1, -1L);
			sb.append(Math.max(DFS(1, -1, 0), DFS(1, -1, 1)));
			sb.append(""\n"");
		}
		out.print(sb);
		out.close();
	}

	static ArrayList<Integer> tree[];
	static long range[][], strg[][];

	static long DFS(int u, int pa, int ok) {
		if (strg[u][ok] != -1)
			return strg[u][ok];
		long tg = 0;
		for (int ch : tree[u]) {
			if (ch == pa)
				continue;
			long sg = 0;
			if (ok == 0) {
				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][0] - range[ch][0]),
						DFS(ch, u, 1) + Math.abs(range[u][0] - range[ch][1]));
			} else {
				sg = Math.max(DFS(ch, u, 0) + Math.abs(range[u][1] - range[ch][0]),
						DFS(ch, u, 1) + Math.abs(range[u][1] - range[ch][1]));
			}
			tg += sg;
		}
		return strg[u][ok] = tg;
	}

	
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class First {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        int t;
        t = in.nextInt();
        //t = 1;
        while (t > 0) {
            solver.call(in,out);
            t--;
        }
        out.close();
    }

    static class TaskA {
        Map<Integer, ArrayList<Integer>> map;
        long[][] arr;
        long[][] dp = new long[2][100005];
        public void call(InputReader in, PrintWriter out) {
            int n;
            n = in.nextInt();

            map = new HashMap<>();
            arr = new long[n][2];

            for (int i = 0; i < n; i++) {
                arr[i][0] = in.nextLong();
                arr[i][1] = in.nextLong();
            }

            int u, v;

            for (int i = 0; i < 2; i++) {
                for (int j = 0; j <= n; j++) {
                    dp[i][j] = -1;
                }
            }

            for (int i = 0; i < n-1; i++) {
                u = in.nextInt()-1;
                v = in.nextInt()-1;

                if(map.getOrDefault(u,null)==null){
                    map.put(u, new ArrayList<>());
                }
                map.get(u).add(v);

                if(map.getOrDefault(v,null)==null){
                    map.put(v, new ArrayList<>());
                }
                map.get(v).add(u);
            }

            out.println(Math.max(ans(0, -1,0), ans(0,-1,1)));

        }
        public long ans (int child, int par, int choice){
            if(dp[choice][child]!=-1){
                return dp[choice][child];
            }
            long opt = 0;
            
            for (Integer i : map.get(child)) {
                if(i!=par) {
                    opt += Math.max(Math.abs(arr[i][0] - arr[child][choice]) + ans(i, child, 0), Math.abs(arr[child][choice] - arr[i][1]) + ans(i, child, 1));
                }
            }
            
            return dp[choice][child] = opt;
        }
    }

    

    

    

    

    

    

    static final Random random=new Random();

    

    
}
",0,Non-plagiarised
1c8bb204,4b7646f4,"import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class BST {

    

    public static void main(String[] args) throws IOException{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-->0){

            int n = Integer.parseInt(br.readLine());
            long [] arr = new long[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                long tmp = Long.parseLong(st.nextToken());
                arr[i] = tmp;

            }

            int h = 1;
            int v = 1;
            long minHor = arr[0];
            long minVir = arr[1];
            long sum0 = arr[0];
            long sum1 = arr[1];
            long total = (arr[0] + arr[1])*n;


            for (int i = 2; i < n; i++) {

                if(i%2==0){
                    h++;
                    sum0 += arr[i];
                    minHor = Math.min(arr[i] , minHor);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }else {
                    v++;
                    sum1 += arr[i];
                    minVir = Math.min(arr[i] , minVir);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }

            }


            System.out.println(total);

        }



    }




}
","import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
public class BST {
 
    
 
    public static void main(String[] args) throws IOException{
 
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-->0){
 
            int n = Integer.parseInt(br.readLine());
            long [] arr = new long[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int i = 0; i < n; i++) {
                long tmp = Long.parseLong(st.nextToken());
                arr[i] = tmp;
 
            }
 
            int h = 1;
            int v = 1;
            long minHor = arr[0];
            long minVir = arr[1];
            long sum0 = arr[0];
            long sum1 = arr[1];
            long total = (arr[0] + arr[1])*n;
 
 
            for (int i = 2; i < n; i++) {
 
                if(i%2==0){
                    h++;
                    sum0 += arr[i];
                    minHor = Math.min(arr[i] , minHor);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }else {
                    v++;
                    sum1 += arr[i];
                    minVir = Math.min(arr[i] , minVir);
                    total = Math.min(total , minHor*(n-h+1)+(sum0-minHor)+minVir*(n-v+1)+(sum1-minVir));
                }
 
            }
 
 
            System.out.println(total);
 
        }
 
 
 
    }
 
 
 
 
}
",1,Plagiarised
464a03b8,ff1fc018,"import java.util.*;

public class Soltion{
 
     public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        
        while(t-->0){
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for(int i=0;i<n;i++){
                arr[i] = sc.nextInt();
            }
            String s = sc.next();
            
            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)=='B'){
                    blue.add(arr[i]);
                }
                else{
                    red.add(arr[i]);
                }
            }
            
            Collections.sort(blue);
            Collections.sort(red);
            int p=1,q=n;
            
            boolean flag = true;
            for(int i=red.size()-1;i>=0;i--){
                if(red.get(i)>q){
                    flag = false;
                    break;
                }
                q--;
            }
            
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<p){
                    flag = false;
                    break;
                }
                p++;
            }
            
            System.out.println(flag? ""Yes"" : ""No"");
        }
     }
}
","import java.util.*;

public class mentor1 {
    public static boolean solve(int n, String color, int[] arr){
        List<Integer> Barr = new ArrayList<Integer>();
        List<Integer> Rarr = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            if(color.charAt(i) == 'B')Barr.add(arr[i]);
            else Rarr.add(arr[i]);
        }
        Barr.sort(Comparator.naturalOrder());
        Rarr.sort(Comparator.reverseOrder());
        for (int i = 0; i < Barr.size(); i++) {
            if(Barr.get(i)< i + 1)return false;
        }
        for (int i = 0; i < Rarr.size(); i++) {
            int expect = n-i;
            if(Rarr.get(i) > expect)return false;
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        for (int i = 0; i < n; i++) {
            int m = input.nextInt();
            int[] arr = new int[m];
            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
            String color = input.next();
            if(solve(m,color,arr)) System.out.println(""YES"");
            else System.out.println(""NO"");
        }
    }
}
",0,Non-plagiarised
4552d8a0,d3a96420,"import java.util.*;
import java.io.*;

////***************************************************************************
 /* public class E_Gardener_and_Tree implements Runnable{

       public static void main(String[] args) throws Exception {
        new Thread(null, new E_Gardener_and_Tree(), ""E_Gardener_and_Tree"", 1<<28).start();
       }
    public void run(){
         WRITE YOUR CODE HERE!!!!
         JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
       }

  }
*/
/////**************************************************************************


public class D_Blue_Red_Permutation{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
      //  PrintWriter out=new PrintWriter(System.out);
        //end of program
        //out.println(answer);
        //out.close();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        long array[]= new long[n];
        for(int i=0;i<n;i++){
            array[i]=s.nextLong();
        }
        String str=s.nextToken();
        ArrayList<Long> red = new  ArrayList<Long>();
        ArrayList<Long> blue = new  ArrayList<Long>();
        for(int i=0;i<n;i++){
            if(str.charAt(i)=='R'){
                red.add(array[i]);
            }
            else{
                blue.add(array[i]);
            }
        }
        Collections.sort(blue);
        int check1=0;
        for(int i=0;i<blue.size();i++){
            int yo=i+1;
            if(blue.get(i)<yo){
                check1=1;
                break;
            }
        }
        Collections.sort(red,Collections.reverseOrder());
        int number=n;
        int check2=0;
        for(int i=0;i<red.size();i++){
             if(red.get(i)>number){
                 check2=1;
                 break;
             }
             number--;
        }
        if(check1==0 && check2==0){
            res.append(""YES\n"");
        }
        else{
            res.append(""NO\n"");
        }
        p++;
    }
    System.out.println(res);
    }
    




}
","import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc= new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0;i<n;i++)a[i]=sc.nextInt();
      String x=sc.next();
      Vector<Integer> R=new Vector<>();
      Vector<Integer> B=new Vector<>();
      for(int i=0;i<n;i++){
        if(x.charAt(i)=='B') R.add(a[i]);
        else B.add(a[i]);
      }
      Collections.sort(R);
      Collections.sort(B);
      boolean yes=true;
      for(int i=0;i<R.size();i++){
        if(R.get(i)-i<1){System.out.println(""NO"");yes=false;break;}
      }
      if(yes)
        {
          int s=B.size();
          for(int j=0;j<s;j++){
            if(B.get(j)+s-j>n+1){System.out.println(""NO"");yes=false;break;}
          }
        }
        if(yes)System.out.println(""YES"");
    }
    sc.close();
  }
}
",0,Non-plagiarised
aa4b840f,e99c14b9,"import java.io.*;
import java.util.*;
 
public class Contest1615C
{
    
    static InputReader r = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static long mod = 1000000007;
    public static void main(String[] args)
    {
    	int t = r.nextInt();
    	
    	while (t > 0)
    	{
    		t--;
    		int n = r.nextInt();
    		String a = r.next();
    		String b = r.next();
    		int sum1 = 0; int sum2 = 0;
    		for (int i = 0; i < n; i ++)
    		{
    			sum1 += (a.charAt(i) == '1'?1:0);
    			sum2 += (b.charAt(i) == '1'?1:0);
    		}
    		if (sum1!=sum2 && sum1+sum2 != n+1)
    		{
    			pw.println(-1);
    			continue;
    		}
    		int[][] count = new int[2][2];
    		for (int i = 0; i < n; i ++)
    		{
    			count[(int)a.charAt(i)-(int)'0'][(int)b.charAt(i)-(int)'0']++;
    		}
    		int min = 10000000;
    		if (count[0][1] == count[1][0])
    		{
    			min = Math.min(min, count[0][1]*2);
    		}
    		if (count[1][1] == count[0][0] + 1)
    		{
    			min = Math.min(min, count[1][1] + count[0][0]);
    		}
    		pw.println(min == 10000000 ? -1:min);
    	}
        pw.close();
    }
}
","import java.io.*;

import java.util.*;
/*




*/

 
 public class A{
	static FastReader sc=null;
	
	public static void main(String[] args) {
		sc=new FastReader();
		int t=sc.nextInt();
		
		for(int tt=0;tt<t;tt++) {
			int n=sc.nextInt();
			char a[]=sc.next().toCharArray(),b[]=sc.next().toCharArray();
			
			int fa=0,fb=0,da=0,db=0,sum=0;
			boolean dif=false;
			for(int i=0;i<n;i++) {
				sum+=a[i]-'0';
				if(a[i]!=b[i]) {
					dif=true;
					if(a[i]=='1')fa++;
					else fb++;
				}
				else {
					if(a[i]=='1')da++;
					else db++;
				}
			}
			
			if(sum==0) {
				System.out.println(dif?-1:0);
				continue;
			}
			
			int ans=n+1;
			
			if(fa==fb) ans=(fa+fb);
			if(da==db+1) ans=Math.min(da+db, ans);
			
			System.out.println(ans==(n+1)?-1:ans);
		}
	}
	
	
	
	
	
	
	
	
}
",0,Non-plagiarised
752ea9a5,b2ec0eff,"import java.io.*;
import java.util.*;

public class PheonixAndTowers
{
	public static void main(String[] args)throws Exception{ new PheonixAndTowers().run();} 
	long mod=1000000000+7;
//	int[][] ar;
	void solve() throws Exception
	{
		
		
		for(int tt=ni();tt>0;tt--){

			//int n = ni();
			
			
			int n = ni();
			int m =ni();
			int x =ni();
			
			int[] a = new int[n];
			for(int i=0;i<n;i++){
				a[i] =ni();
			}
			PriorityQueue<Pair> pq = new PriorityQueue<>();
			
			for(int i=1;i<=m;i++) pq.add(new Pair(i));
			out.println(""YES"");
			for(int i:a){
				
				Pair r = pq.remove();
				r.sum+=i;
				pq.add(r);
				out.print(r.id+"" "");
				
			}
			out.println();
			
			
			
			
			
			
			
		}
		
	}
	
	class Pair implements Comparable<Pair>{
		int id;
		long sum=0;
		public Pair(int i){
			this.id=i;
		}
		
		
		
	}
	
	
	 

	
	/*FAST INPUT OUTPUT & METHODS BELOW*/
	
	private byte[] buf=new byte[1024];
	private int index;
	private InputStream in;
	private int total;
	private SpaceCharFilter filter;
	PrintWriter out;
	
	
	
	
	
	
	
	
	
	 
	
	/* for (1/a)%mod = ( a^(mod-2) )%mod  ----> use expo to calc -->(a^(mod-2)) */
	
	void run()throws Exception
	{
		in=System.in; out = new PrintWriter(System.out);
		solve();
		out.flush();
	}
	private int scan()throws IOException
	{
		if(total<0)
			throw new InputMismatchException();
		if(index>=total)
		{
			index=0;
			total=in.read(buf);
			if(total<=0)
				return -1;
		}
		return buf[index++];
	}
	private int ni() throws IOException 
	{
		int c = scan();
		while (isSpaceChar(c))
			c = scan();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = scan();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = scan();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	
	
	
	
	
	private boolean isWhiteSpace(int n)
	{
		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
	private boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhiteSpace(c);
	}
	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}
","import java.io.*;
import java.util.*;

public class ques3
{
	public static void main(String[] args)throws Exception{ new ques3().run();} 
	long mod=1000000000+7;
	
	void solve() throws Exception
	{
		for(int ii=ni();ii>0;ii--)
		{
			int n=ni();
			int m=ni();
			int x=ni();
			long h[]=new long[n];
			for (int i = 0; i <n; i++) 
				h[i]=nl();
			int dp[]=new int[n];
			
			PriorityQueue<long[]> pq=new PriorityQueue<long[]>(new Comparator<long[]>() {
				
			});
			for (int i = 1; i <=m; i++) 
				pq.add(new long[] {i,0});
			
			for(int i=0;i<n;i++)
			{
				long tem[]=pq.poll();
				tem[1]+=h[i];
				dp[i]=(int)tem[0];
				pq.add(tem);
			}
			long min=Integer.MAX_VALUE;
			long max=Integer.MIN_VALUE;
			while(!pq.isEmpty())
			{
				long tem[]=pq.poll();
				min=Math.min(min,tem[1]);
				max=Math.max(max,tem[1]);
			}
			if(max-min>x)
			{
				out.println(""NO"");
			}
			else
			{
				out.println(""YES"");
				for (int i = 0; i < dp.length; i++) {
					out.print(dp[i]+"" "");
				}
				out.println();
			}
		}
	}
	
	
	/*FAST INPUT OUTPUT & METHODS BELOW*/
	
	private byte[] buf=new byte[1024];
	private int index;
	private InputStream in;
	private int total;
	private SpaceCharFilter filter;
	PrintWriter out;
	
	
	
	
	
	
	
	 
	
	/* for (1/a)%mod = ( a^(mod-2) )%mod  ----> use expo to calc -->(a^(mod-2)) */
	
	void run()throws Exception
	{
		in=System.in; out = new PrintWriter(System.out);
		solve();
		out.flush();
	}
	private int scan()throws IOException
	{
		if(total<0)
			throw new InputMismatchException();
		if(index>=total)
		{
			index=0;
			total=in.read(buf);
			if(total<=0)
				return -1;
		}
		return buf[index++];
	}
	private int ni() throws IOException 
	{
		int c = scan();
		while (isSpaceChar(c))
			c = scan();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = scan();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = scan();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	private long nl() throws IOException 
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = scan()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = scan();
		}
		
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = scan();
		}
	}
	
	
	
	
	private boolean isWhiteSpace(int n)
	{
		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
	private boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhiteSpace(c);
	}
	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}
",0,Non-plagiarised
b9595381,d6fb3b9e,"import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
    
static int dest1;
static int dest2;
public static void main(String args[]){
       	FastScanner in = new FastScanner();
		int test=in.nextInt();
                while(test-->0){
                    int n=in.nextInt();
                    int count[][]=new int[n][5];
                    int total[]=new int[n];
                    String words[]=new String[n];
                    for(int i=0;i<n;i++){
                        words[i]=in.next();
                        for(int j=0;j<words[i].length();j++)
                            count[i][words[i].charAt(j)-'a']++;
                        
                        total[i]=words[i].length();
                    }
                    int max=Integer.MIN_VALUE;
                   for(int i=0;i<5;i++){
                       
                      Integer ans[]=new Integer[n];
                      for(int j=0;j<n;j++){
                          ans[j]=count[j][i]-(total[j]-count[j][i]);
                      }
                      Arrays.sort(ans,Collections.reverseOrder());
                      int j=0;
                      int r=0;
                      while(j<n && r+ans[j]>0){
                          r+=ans[j];
                          j++;
                      }
                      max=Math.max(j,max);
                      
                   }
                   System.out.println(max);
                   
                    
                }
}

       



}


","import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
",1,Plagiarised
079ad09e,20012377,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        EAirConditioners solver = new EAirConditioners();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }
 
    static class EAirConditioners {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), q = in.nextInt();
            int[] a = in.readArray(q);
            long[] t = in.readLongArray(q);
            long[] pref = new long[n + 2];
            long[] suff = new long[n + 2];
 
            Arrays.fill(pref, (long) 1e14);
            Arrays.fill(suff, (long) 1e14);
 
            for (int i = 0; i < q; ++i) {
                pref[a[i]] = t[i] - a[i];
                suff[a[i]] = t[i] + a[i];
            }
 
            for (int i = 1; i <= n; ++i) {
                pref[i] = Math.min(pref[i], pref[i - 1]);
            }
 
            for (int i = n; i >= 1; --i) {
                suff[i] = Math.min(suff[i], suff[i + 1]);
            }
 
            for (int i = 1; i <= n; ++i) {
                out.print(Math.min(pref[i] + i, suff[i] - i) + "" "");
            }
            out.println();
        }
 
    }
 
    
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        EAirConditioners solver = new EAirConditioners();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class EAirConditioners {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), q = in.nextInt();
            int[] a = in.readArray(q);
            long[] t = in.readLongArray(q);
            long[] pref = new long[n + 2];
            long[] suff = new long[n + 2];

            Arrays.fill(pref, (long) 1e14);
            Arrays.fill(suff, (long) 1e14);

            for (int i = 0; i < q; ++i) {
                pref[a[i]] = t[i] - a[i];
                suff[a[i]] = t[i] + a[i];
            }

            for (int i = 1; i <= n; ++i) {
                pref[i] = Math.min(pref[i], pref[i - 1]);
            }

            for (int i = n; i >= 1; --i) {
                suff[i] = Math.min(suff[i], suff[i + 1]);
            }

            for (int i = 1; i <= n; ++i) {
                out.print(Math.min(pref[i] + i, suff[i] - i) + "" "");
            }
            out.println();
        }

    }

    
}
",1,Plagiarised
141effef,9cea10af,"import java.util.*;

public class ArmChairs {
	static int[]arr;
	static ArrayList<Integer>a;
	static ArrayList<Integer>b;
	static int dp[][];
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		arr=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=scn.nextInt();
		}
		dp=new int[n+1][n+1];
		a =new ArrayList<>();
		b =new ArrayList<>();
		for(int i=0;i<n;i++) {
			if(arr[i]==0) {
				a.add(i);
			}else{
				b.add(i);
			}
		}
		System.out.println(solve(0,0));	
	}
	
	public static int solve(int i,int j) {
		if(i==b.size()) {
			return 0;
		}
		if(j==a.size()) {
			return 100000000;
		}

		if(dp[i][j]!=0) {
			return dp[i][j];
		}
		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
		int y=solve(i,j+1);
		return dp[i][j]=Math.min(x, y);
	}
	

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class P4 {
	static int dp[][]=new int[5000+1][5000+1];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader sc=new FastReader();
		int t=1;
		//t=sc.nextInt();
		StringBuilder s=new StringBuilder();
		while(t--!=0) {
			int n=sc.nextInt();
			int a[]=new int[n];
			
			for(int i=0;i<=n;i++) {
				for(int j=0;j<=n;j++) {
					P4.dp[i][j]=-1;
				}
			}
			ArrayList<Integer> one=new ArrayList<>();
			ArrayList<Integer> zero=new ArrayList<>();
			for(int i=0;i<n;i++) {
				a[i]=sc.nextInt();
				if(a[i]==0) {
					zero.add(i);
				}else {
					one.add(i);
				}
			}
			Collections.sort(zero);
			Collections.sort(one);
			long ans=sol(0,0,zero.size(),one.size(),a,zero,one);
			System.out.println(ans);
		}
		//System.out.println(s);
	}
	private static long sol(int i, int j, int n, int m,int a[], ArrayList<Integer> zero, ArrayList<Integer> one) {
		//System.out.println(i+"" ""+j);
		// TODO Auto-generated method stub
		if(j==m) {
			return 0;
		}
		int av=n-i;
		int rem=m-j;
		if(av<rem) {
			return Integer.MAX_VALUE-1;
		}
		if(dp[i][j]!=-1) {
			return dp[i][j];
		}
		long ans1=sol(i+1,j,n,m,a, zero, one);
		long ans2=Math.abs(zero.get(i)-one.get(j))+sol(i+1,j+1,n,m,a, zero, one);
		dp[i][j]=(int) Math.min(ans1, ans2);
		return dp[i][j];
	}
	 
}
",0,Non-plagiarised
018c9543,d1dbc56a,"import java.io.*;
import java.util.*;

public class Main {
    public static int n;
    public static int a[] = new int[12];
    public static int b[] = new int[12];

    public static boolean f(int p) {
        if (p > n) return false;

        for (int i = 0; i < p; i++) {
            b[p] = a[p] + b[i];
            for (int j = 0; j < p; j++) {
                if (b[j] == b[p])
                    return true;
            }
            if (f(p + 1)) {
                return true;
            }


//            b[p] = b[i] - a[p];
//            for (int j = 0; j < p; j++) {
//                if (b[j] == b[p])
//                    return true;
//            }
//            if (f(p + 1)) {
//                return true;
//            }
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        int T = r.readInt();
        for (int t = 0; t < T; t++) {
            n = r.readInt();
            for (int i = 1; i <= n; i++) {
                a[i] = r.readInt();
            }

            boolean ans = false;
            if (n == 1) {
                ans = a[1] == 0;
            } else {
                b[0] = 1;
                ans = f(1);
            }

            if (ans) {
                System.out.println(""YES"");
            } else {
                System.out.println(""NO"");
            }
        }
    }

    static public InputReader r = new InputReader(System.in);
    static public OutputWriter w = new OutputWriter(System.out);

    

    
}
","import java.util.*;
import java.io.*;
public class D {
	static ArrayList<Integer> set = new ArrayList<Integer>();
	static int[] a;
	static int test;
	public static void main(String[] args) throws IOException{
		Scanner in = new Scanner(System.in);
		int t = in.nextInt();
		for(int q=0;q<t;q++) {
			int n = in.nextInt();
			a = new int[n];
			for(int i=0;i<n;i++) {
				a[i] = Math.abs(in.nextInt());
			}
			boolean yes = false;
			for(int i=0;i<n;i++) {
				if(a[i]==0) yes = true;
				int[] b = new int[n-1];
				int index=0;
				for(int j=0;j<n;j++) {
					if(j!=i) {
						b[index] = a[j];
						index++;
					}
				}
				test = a[i];
				set = new ArrayList<Integer>();
				if(b.length!=0) {
					if(subset(b,0)) yes = true;					
				}
			}
			if(yes) {
				System.out.println(""YES"");
			}else {
				System.out.println(""NO"");
			}
		}
	}
	
	static boolean subset(int[] a,int i) {
//		System.out.println(set);
		if(i>=a.length) {
			if(binary(new int[set.size()],0)) return true;
			return false;
		}
		set.add(a[i]);
		if(subset(a,i+1))return true;
		set.remove(set.size()-1);
		if(subset(a,i+1))return true;
		return false;
	}
	
	static boolean binary(int[] b,int i) {
		if(i==b.length) {
			int sum=0;
			for(int j=0;j<b.length;j++) {
				if(b[j]==0) {
					sum+= set.get(j);
				}else {
					sum-= set.get(j);
				}
			}
//			System.out.println(sum+"" ""+test);
			if(sum==test) {
				return true;
			}else {
				return false;
			}
		}
		b[i] = 0;
		if(binary(b,i+1))return true;
		b[i] = 1;
		if(binary(b,i+1))return true;
		return false;
	}
	
}
",0,Non-plagiarised
2f8c3bf3,3c667d4f,"import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0){
		    int n=sc.nextInt();
		    int k=sc.nextInt();
		    
		    int idx[]=new int[k];
		    
		    for(int i=0;i<k;i++){
		        idx[i]=sc.nextInt();
		    }
		    
		    long arr[]=new long[n];
		    Arrays.fill(arr,Integer.MAX_VALUE);
		    for(int i=0;i<k;i++){
		        long temp=sc.nextLong();
		        arr[idx[i]-1]=temp;
		    }
		    
		    long left[]=new long[n];
		    long right[]=new long[n];
		    
		    Arrays.fill(left,Integer.MAX_VALUE);
		    Arrays.fill(right,Integer.MAX_VALUE);
		    
		    
		    left[0]=arr[0];
		    
		    for(int i=1;i<n;i++){
		       left[i]=Math.min(left[i-1]+1,arr[i]);
		    }
		    
		    right[arr.length-1]=arr[arr.length-1];
		    
		    for(int i=n-2;i>=0;i--){
		        right[i]=Math.min(right[i+1]+1,arr[i]);
		    }
		    
		    for(int i=0;i<n;i++){
		      //  System.out.print(left[i]+""--""+right[i]+""\\"");
		       
		       
		       System.out.print(Math.min(left[i],right[i])+"" "");
		    }
		    System.out.println();
		  
		}
	}
}
","import java.util.*;
public class j
{
  public static void main(String args[])
  {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0)
    {
      int len=in.nextInt();
      int t=in.nextInt();
      int pos[]=new int[t];
      int temp[]=new int[t];
      for(int i=0;i<t;i++)
      pos[i]=in.nextInt();
      for(int i=0;i<t;i++)
      temp[i]=in.nextInt();
      long range[]=new long[len];
      Arrays.fill(range,Long.MAX_VALUE-10000);
      for(int i=0;i<t;i++)
      range[pos[i]-1]=temp[i];
      for(int i=1;i<len;i++)
      {
        range[i]=Math.min(range[i],1+range[i-1]);
      }
      for(int i=len-2;i>=0;i--)
      {
      range[i]=Math.min(range[i+1]+1,range[i]);
      }
      for(int i=0;i<len;i++)
      {
        System.out.print(range[i]+"" "");
      }System.out.println();
    }
  }
}
",0,Non-plagiarised
3e6def38,e7dce35b,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	static void shuffleArray(int[] a) {
		Random rnd = new Random();
		for (int i = a.length-1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			int tmp = a[index];
			a[index] = a[i];
			a[i] = tmp;
		}
	}
	
	public static int inv(int a) {
		return pow(a, MOD-2);
	}
	
	public void doIt() throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		StringTokenizer tok = new StringTokenizer(in.readLine());
		int n = Integer.parseInt(tok.nextToken());
		int k = Integer.parseInt(tok.nextToken());
		
		f = new int[n+42];
		rf = new int[n+42];
		f[0] = rf[0] = 1;
		for (int i = 1; i < f.length; ++i) {
			f[i] = mul(f[i-1], i);
			rf[i] = mul(rf[i-1], inv(i));
		}
		
		int[] events = new int[2*n];
		for (int i = 0; i < n; ++i) {
			tok = new StringTokenizer(in.readLine());
			int le = Integer.parseInt(tok.nextToken());
			int ri = Integer.parseInt(tok.nextToken());
			events[i] = le*2;
			events[i + n] = ri*2 + 1;
		}
		shuffleArray(events);
		Arrays.sort(events);
		
		int ans = 0;
		int balance = 0;
		for (int r = 0; r < 2*n;) {
			int l = r;
			while (r < 2*n && events[l] == events[r]) {
				++r;
			}
			int added = r - l;
			if (events[l] % 2 == 0) {
				// Open event
				ans += C(balance + added, k);
				if (ans >= MOD) ans -= MOD;
				ans += MOD - C(balance, k);
				if (ans >= MOD) ans -= MOD;
				balance += added;
			} else {
				// Close event
				balance -= added;
			}
		}
		
		in.close();
		System.out.println(ans);
	}
	
	public static void main(String[] args) throws IOException {
		(new D_Java()).doIt();
	}
}
","import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int n = nextInt();
        int k = nextInt();

        f = new int[n + 42];
        rf = new int[n + 42];
        f[0] = 1;
        rf[0] = 1;
        for (int i = 1; i < f.length; i++) {
            f[i] = mul(f[i - 1], i);
            rf[i] = mul(rf[i - 1], inv(i));
        }

        int[] a = new int[n * 2];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt() * 2;
            a[i + n] = nextInt() * 2 + 1;
        }
        Arrays.sort(a);

        int ans = 0;
        int curOpen = 0;
        for (int r = 0; r < 2 * n;) {
            int l = r;
            while (r < 2 * n && a[l] == a[r]) r++;
            int intersections = r - l;
            if (a[l] % 2 == 0) {
                ans += C(curOpen + intersections, k);
                if (ans >= mod) ans -= mod;
                ans += mod - C(curOpen, k);
                if (ans >= mod) ans -= mod;
                curOpen += intersections;
            } else {
                curOpen -= intersections;
            }
        }

        pw.println(ans);
        pw.close();
    }

    static int mod = 998244353;

    static int mul(int a, int b) {
        return (int) ((long) a * (long) b % mod);
    }

    static int[] f;
    static int[] rf;

    static int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
    }

    static int pow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1) {
                res = mul(res, a);
            }
            a = mul(a, a);
            n >>= 1;
        }
        return res;
    }

    static int inv(int a) {
        return pow(a, mod - 2);
    }

    static StringTokenizer st = new StringTokenizer("""");
    static BufferedReader br;

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    

    
}




",1,Plagiarised
4da08761,c4ca2ff3,"import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Solution {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Main solver = new Main();
        boolean multipleTC = true;
        int testCount = multipleTC ? Integer.parseInt(in.next()) : 1;
        for (int i = 1; i <= testCount; i++)
            solver.solve(in, out, i);
        out.close();
    }
    static class Main {
        PrintWriter out;
        InputReader in;

        public void solve(InputReader in, PrintWriter out, int test) {
            this.out = out;
            this.in = in;
            int n = ni();
            String[] arr = new String[n];
            int[][] freq = new int[n][5];
            int[][] rem = new int[n][5];
            for(int i = 0; i < n; i++){
                arr[i] = n();
                for(int j = 0; j < arr[i].length(); j++)
                    freq[i][arr[i].charAt(j) - 'a']++;
                for(int j = 0; j < 5; j++)
                    rem[i][j] = arr[i].length() - freq[i][j];
            }
            int ans = 0;
            for(int i = 0; i < 5; i++){
                int[] vals = new int[n];
                for(int j = 0; j < n; j++)
                    vals[j] = freq[j][i] - rem[j][i];
                Arrays.sort(vals);
                int sum = 0, x = 0;
                for(int j = n - 1; j >= 0; j--){
                    if(sum + vals[j] > 0){
                        x++;
                        sum += vals[j];
                    } else {
                        break;
                    }
                }
                if(x > ans) {
                    ans = x;
                }
            }
            System.out.println(ans);
        }

        


        String n(){
            return in.next();
        }

        int ni() {
            return in.nextInt();
        }

        


        

    }

    
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		while(t-->0) {
		    int n=sc.nextInt();
		    int freq[][]=new int[n][5];
		    int rem[][]=new int[n][5];
		    for(int i=0;i<n;i++) {
		        String str=sc.next();
		        
		        for(int j=0;j<str.length();j++) {
		            freq[i][str.charAt(j)-'a']++;
		        }
		        for(int k=0;k<5;k++) {
		            rem[i][k]=str.length()-freq[i][k];
		        }
		    }
		    
		    int ans=0;
		    for(int i=0;i<5;i++) {
		        int arr[]=new int[n];
		        for(int j=0;j<n;j++)
		        arr[j]=freq[j][i]-rem[j][i];
		        
		        Arrays.sort(arr);
		        int total=0;
		        int sum=0;
		        for(int k=n-1;k>=0;k--) {
		            if(sum+arr[k]>0) {
		                sum=sum+arr[k];
		                total++;
		            }
		            else {
		                break;
		            }
		        }
		        ans=Math.max(ans,total);
		    }
		    out.println(ans);
		    
		}
		out.flush();
		out.close();
	}
}
",1,Plagiarised
04ed33a5,0c173033,"import java.util.Scanner;

public class Subsequence {
	private static Scanner sc = new Scanner(System.in);
	
	public static void main(String args[]) {
		int t = sc.nextInt();
		
		while(t-->0) {
			int n = sc.nextInt();
			
			int a[] = new int[n];
			int b[] =  new int[n];
			
			for(int i=0;i<n;i++) {
				a[i]= sc.nextInt();
				
			}
			
			if(n%2==0) {
				calculateB(a,b,n);
			}
			else {
				calculateB(a,b,n-3);
				if (a[n - 2] + a[n - 3] != 0) {
					b[n - 3] = -a[n - 1];
					b[n - 2] = -a[n - 1];
					b[n - 1] = a[n - 2] + a[n - 3];
				} else if (a[n - 2] + a[n - 1] != 0) {
					b[n - 3] = a[n - 2] + a[n - 1];
					b[n - 2] = -a[n - 3];
					b[n - 1] = -a[n - 3];
				} else {
					b[n - 3] = -a[n - 2];
					b[n - 2] = a[n - 3] + a[n - 1];
					b[n - 1] = -a[n - 2];
				}
			}
			
			for(int i=0;i<n;i++) {
				System.out.print(b[i] + "" "");
			}
			System.out.println();
		}

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
","import java.io.*;
import java.util.*;


public class M {
	static Scanner scanner=new Scanner(System.in);
	public static void main(String[] args) {
		int t=scanner.nextInt();
		while(t-->0) {
			int n=scanner.nextInt();
			int a[]=new int [n];
			int b[]=new int [n];
			for(int i=0;i<n;i++)a[i]=scanner.nextInt();
			for(int i=0;i+1<n;i+=2) {
				b[i]=-a[i+1];
				b[i+1]=a[i];
			}
			if(n%2==1) {
				int x=a[n-1],y=a[n-2],z=a[n-3];
				if(x+y!=0) {
					b[n-3]=x+y;
					b[n-2]=-z;
					b[n-1]=-z;
				}else if(y+z!=0) {
					b[n-1]=y+z;
					b[n-2]=-x;
					b[n-3]=-x;
				}else {
					b[n-2]=x+z;
					b[n-1]=-y;
					b[n-3]=-y;
				}
			}
			StringBuilder sb=new StringBuilder();
			for(int i=0;i<n;i++)sb.append(b[i]+"" "");
			System.out.println(sb);
		}
	}
}
",1,Plagiarised
0ee2f8f1,c2b7b017,"import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
     int n=sc.nextInt();
     int arr[]=new int[n];
     int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;
     for(int i=0;i<n;i++){
      arr[i]=sc.nextInt();
      min=Math.min(arr[i],min);
      max=Math.max(arr[i],max);
     }
     while(min<=max){
      int mid=min+(max-min)/2;
      if(helper(arr,mid))
       min=mid+1;
       else max=mid-1;
     }
     System.out.println(min-1);
    }
  }
  public static boolean helper(int arr[],int min){
   int tmp[]=Arrays.copyOf(arr,arr.length);
   for(int i=arr.length-1;i>=2;i--){
    if(tmp[i]<min)
     return false;
    int d=(Math.min(arr[i],tmp[i]-min))/3;
    tmp[i-1]+=d;
    tmp[i-2]+=d*2;
   }
   return tmp[1]>=min && tmp[0]>=min;
  }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

//
public class Example {
    

    public static void main(String[] args) {
        FastReader sc = new FastReader();

        int t= sc.nextInt();
        while(t>0){
            t--;
            int ans=Integer.MAX_VALUE;
            int n=sc.nextInt();
            int[] ar= new int[n];
            int l=Integer.MAX_VALUE;
            int h=Integer.MIN_VALUE;
            for(int i=0;i<n;i++){
                ar[i]=sc.nextInt();
                l=Math.min(l,ar[i]);
                h=Math.max(h,ar[i]);

            }
            int[] extra;
            while(l<=h){
                int mid=l+(h-l)/2;
                if(possibleans(ar,mid)){
                    ans=mid;
                    l=mid+1;
                }else{
                    h=mid-1;
                }
            }
            System.out.println(ans);


        }
    }

    private static boolean possibleans(int[] ar, int mid) {
int[] extra=new int[ar.length];
        for(int i=ar.length-1;i>=2;i--){
            if((ar[i]+extra[i]-mid)<0){
                return false;
            }
            int d=Math.min(ar[i],extra[i]+ar[i]-mid);
            extra[i-1]=extra[i-1]+d/3;
            extra[i-2]+=2*(d/3);

        }
        int a=ar[0]+extra[0];
        int b=ar[1]+extra[1];
        return (a>=mid && b>=mid);

    }

    
}
",1,Plagiarised
49e94e7e,f3d7ce08,"import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	
	
	

	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
			
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   
			
			
			
			
			
			
			   
				
		   
		   
		
			   /*
			    * 
			    * >=         <=
			   0 1 2 3 4 5 6 7  
			   5 5 5 6 6 6 7 7
			   lower_bound for 6 at index 3 (>=)
			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
			   */

		   
		   
			
			
			
			
			
	
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out); 
		
		int tt = sc.nextInt();
		while(tt-- > 0)
		{
	       int n = sc.nextInt();
	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
	       
	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
	       for(int i = 0;i<n;i++)
	       {
	    	   if(a[i] == '0' && b[i] == '0')
	    	   {
	    		   c00++;
	    	   }
	    	   else if(a[i] == '0' && b[i] == '1')
	    	   {
	    		   c01++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '0')
	    	   {
	    		   c10++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '1')
	    	   {
	    		   c11++;
	    	   }
	       }
	       
	       int ans = mod;
	       if(c01 == c10) ans = min(ans, c01 + c10);
	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
	       
	       fout.println((ans == mod) ? -1 : ans);
		}
		
		fout.close();
	}
}
","import javax.swing.plaf.IconUIResource;
import java.lang.reflect.Array;
import java.text.CollationElementIterator;
import java.util.*;
import java.io.*;
 
//Timus judge id- 323935JJ
 
 
public class Main {
 
 
 
 
    //----------------------------------------------------------------------------------------------
    
 
 
    public static int mod = (int) (1e9 + 7);
    static int ans = Integer.MAX_VALUE;
 
    public static void main(String hi[]) throws Exception {
        FastReader sc = new FastReader();
        int t =sc.nextInt();
        while(t-->0)
        {
            int n =sc.nextInt();
            String a = sc.nextLine(),b=sc.nextLine();
 
            int count1=0,count2=0,count3=0,count4=0;
 
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
                    count1++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
                    count2++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
                    count3++;
                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
                    count4++;
            }
            int ans=Integer.MAX_VALUE;
 
            if(count3==count4)
                ans=Math.min(count3*2,ans);
 
            if(count2==count1+1)
                ans=Math.min(ans,2*count1+1);
 
           
            if(ans==Integer.MAX_VALUE)
                System.out.println(-1);
            else System.out.println(ans);
 
        }
 
    }
 
    
 
 
 
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
}
",0,Non-plagiarised
1f748faf,851fafb6,"import java.util.*;

import javax.swing.text.html.HTMLDocument.HTMLReader.PreAction;

import java.io.*;
import java.math.*;
import java.sql.Array;;



public class Main {
	  
	 
	  static long mod = (long)(1e9 + 7);
	 
	
	
	
	
	
	
	 
	 
	 
	 
	 
	   
	      

/* ***************************************************************************************************************************************************/	 
	 
	      static FR sc = new FR();
	 static StringBuilder sb = new StringBuilder();
	 public static void main(String args[]) {
		
		 int tc = 1;
		  tc = sc.nextInt();
		 
		 
		 while(tc-->0) {
			 TEST_CASE();
			 
		 }
		 
	    System.out.println(sb);
	 }


	 static void TEST_CASE() {
		 int n = sc.nextInt(); ;
		 int[] arr = new int[n];
		 for(int i =0 ; i<n;i++) {
			 arr[i] = sc.nextInt();
		 } 
		 boolean cond = false;
		
		 Set<Integer> set = new HashSet<>();
		 set.add(0);
		 for(int i =0 ; i<n ; i++) {
			 ArrayList<Integer> al = new ArrayList<>(set);
			 for(int e:al) {
				 int num = e+arr[i];
				 if(set.contains(num)) {
					 cond = true;
					 break;
				 }
				 set.add(num);
			 }
		 }
		 if(cond) System.out.println(""YES"");
		 else System.out.println(""NO"");
	 }

	 
}
","import java.io.PrintWriter;
import java.util.*;

public class D {
    //    MUST SEE BEFORE SUBMISSION
//    check whether int part would overflow or not, especially when it is a * b!!!!

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
//        int t = 1;
        for (int i = 0; i < t; i++) {
            solve(sc, pw);
        }
        pw.close();
    }

    static void solve(Scanner in, PrintWriter out){
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        Set<Integer> set = new HashSet<>();
        for(int x : arr) {
            if (x == 0){
                out.println(""YES"");
                return;
            }else if (set.contains(x) || set.contains(-x)){
                out.println(""YES"");
                return;
            }
            set.add(x);
        }
        for (int i = 0; i < n; i++) {
            if (dfs(0, i, arr, 0)){
                out.println(""YES"");
                return;
            }
        }
        out.println(""NO"");
    }
    static boolean dfs(int idx, int need, int[] arr, int cur){
        if (cur == arr[need]) return true;
        if (idx == arr.length) return false;
        if (idx == need) return dfs(idx + 1, need, arr, cur);
        return dfs(idx + 1, need, arr, cur + arr[idx]) |
                dfs(idx + 1, need, arr, cur - arr[idx]) |
                dfs(idx + 1, need, arr, cur);
    }
}
",0,Non-plagiarised
08cf0478,0f14b12d,"import java.util.*;
import java.io.*;

public class Main {

  

  public static void main(final String[] args) {
    FastScanner sc = new FastScanner();

	int t = sc.nextInt();
	while(t-- > 0) {
		int n = sc.nextInt();
		int[][] arr = new int[5][n];
		
		for(int i = 0; i < n; i++) {
			char[] s = sc.next().toCharArray();
			int[] cnt = new int[5];
			for(int j = 0; j < s.length; j++) {
				cnt[s[j]-'a']++;
			}
			for(int j = 0; j < 5; j++)
				arr[j][i] = cnt[j]-(s.length-cnt[j]);
		}
		
		int ans = 0;
		for(int i = 0; i < 5; i++) {
			Arrays.sort(arr[i]);
			int maxSum = 0;
			int words = 0;
			for(int j = arr[i].length-1; j >=0; j--) {
				maxSum += arr[i][j];
				if(maxSum > 0) words++;
			}
			
			ans = Math.max(ans, words);
		}
		
		System.out.println(ans);
	}

  } 

  
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.*;
import java.util.*;

import javax.management.Query;
public class Test{
    public static void main(String[] args) throws IOException, InterruptedException{
      Scanner sc = new Scanner(System.in);
     int t = sc.nextInt();
    
     while(t-->0){
      int n = sc.nextInt();
      String [] words = new String[n];
      int [] occ = new int[5];
      int [] occWord = new int [5];
      boolean []  found ;
      for(int i =0;i<n;i++){
        words[i] = sc.nextLine();
        found = new boolean[5];
        for(int j=0 ; j<words[i].length();j++){
          occ[words[i].charAt(j)-'a']++;
          if(!found[words[i].charAt(j)-'a']){
            found[words[i].charAt(j)-'a']=true;
            occWord[words[i].charAt(j)-'a'] ++;
          }
        }
      }
      int maxRes =0;
      for(int i =0;i<5;i++){
      int maxChar = 'a' +i;
      
      PriorityQueue<Pair> pq = new PriorityQueue<>();
      for (String word : words){
          pq.add(new Pair(word,occOfMaxChar(word, maxChar)-occOfOtherChar(word, maxChar)));
      }
      int res = 0;
      int curr = 0;
      int maxCharCount = 0;
      int otherCharCount =0;
      while(!pq.isEmpty()){
        String word = pq.poll().x;
        maxCharCount +=occOfMaxChar(word, maxChar);
         otherCharCount += occOfOtherChar(word, maxChar);
         curr ++;
         if(maxCharCount >otherCharCount){
           res = curr;
         }
          
      }
      maxRes = Math.max(maxRes, res);
    }
    System.out.println(maxRes);}
   
  }
  public static int occOfMaxChar (String s, int maxChar){
     int occ = 0;
     for(int i =0 ;i<s.length();i++){
       if(s.charAt(i)==maxChar){
         occ++;
       }
      }
      return occ;
  }
  public static int occOfOtherChar (String s, int maxChar){
    int occ = 0;
    for(int i =0 ;i<s.length();i++){
      if(s.charAt(i)!=maxChar){
        occ++;
      }
     }
     return occ;
 }

    static int w;
    static int n;
    static long [][] memo;
    static int [] depth ;
    static long[] values;
    static ArrayList<Pair> gold ;
    


    static class Pair implements Comparable {
      String x;
      int y;
      public Pair (String x, int y) {
        this.x = x;
        this.y = y;
      }
      
    }
    
     }
",0,Non-plagiarised
584b0e9e,d9199dfd,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;


public class D_Round_753_Div3 {
    public static int MOD = 1000000007;

    static int[][] dp;


    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // ""output.txt"")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int T = in.nextInt();
        for (int z = 0; z < T; z++) {
            int n = in.nextInt();
            int[] data = new int[n];
            for (int i = 0; i < n; i++) {
                data[i] = in.nextInt();
            }
            String line = in.next();
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (line.charAt(i) == 'B') {
                    blue.add(data[i]);
                } else {
                    red.add(data[i]);
                }
            }
            Collections.sort(blue);
            Collections.sort(red);
            int st = 1;
            boolean ok = true;
            for (int i : blue) {
                if (i < st) {
                    ok = false;
                    break;
                }
                st++;
            }
            if (ok) {
                for (int i : red) {
                    if (i > st) {
                        ok = false;
                        break;
                    }
                    st++;
                }
            }
            out.println(ok ? ""Yes"" : ""No"");
        }
        out.close();
    }

    


    


    

    

    

    

    

    

    

    

    
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",1,Plagiarised
0c173033,6b83b22e,"import java.io.*;
import java.util.*;


public class M {
	static Scanner scanner=new Scanner(System.in);
	public static void main(String[] args) {
		int t=scanner.nextInt();
		while(t-->0) {
			int n=scanner.nextInt();
			int a[]=new int [n];
			int b[]=new int [n];
			for(int i=0;i<n;i++)a[i]=scanner.nextInt();
			for(int i=0;i+1<n;i+=2) {
				b[i]=-a[i+1];
				b[i+1]=a[i];
			}
			if(n%2==1) {
				int x=a[n-1],y=a[n-2],z=a[n-3];
				if(x+y!=0) {
					b[n-3]=x+y;
					b[n-2]=-z;
					b[n-1]=-z;
				}else if(y+z!=0) {
					b[n-1]=y+z;
					b[n-2]=-x;
					b[n-3]=-x;
				}else {
					b[n-2]=x+z;
					b[n-1]=-y;
					b[n-3]=-y;
				}
			}
			StringBuilder sb=new StringBuilder();
			for(int i=0;i<n;i++)sb.append(b[i]+"" "");
			System.out.println(sb);
		}
	}
}
","import java.util.Scanner;

public class Subsequence {
	private static Scanner sc = new Scanner(System.in);
	
	public static void main(String args[]) {
		int t = sc.nextInt();
		
		while(t-->0) {
			int n = sc.nextInt();
			
			int a[] = new int[n];
			int b[] =  new int[n];
			
			for(int i=0;i<n;i++) {
				a[i]= sc.nextInt();
				
			}
			
			if(n%2==0) {
				calculateB(a,b,n);
			}
			else {
				calculateB(a,b,n-3);
				if (a[n - 2] + a[n - 3] != 0) {
					b[n - 3] = -a[n - 1];
					b[n - 2] = -a[n - 1];
					b[n - 1] = a[n - 2] + a[n - 3];
				} else if (a[n - 2] + a[n - 1] != 0) {
					b[n - 3] = a[n - 2] + a[n - 1];
					b[n - 2] = -a[n - 3];
					b[n - 1] = -a[n - 3];
				} else {
					b[n - 3] = -a[n - 2];
					b[n - 2] = a[n - 3] + a[n - 1];
					b[n - 1] = -a[n - 2];
				}
			}
			
			for(int i=0;i<n;i++) {
				System.out.print(b[i] + "" "");
			}
			System.out.println();
		}

	}

	private static void calculateB(int[] a, int[] b, int n) {
		
		for(int i=0;i<n-1;i=i+2) {
			b[i] = -a[i+1];
			b[i+1] = a[i];
		}
		
	}
}
",1,Plagiarised
43ca682a,baebdc56,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class D {
	
	static final int mod=998244353;
	
	static long[] facts, factInvs;

	public static void main(String[] args) {
		precomp();
		FastScanner fs=new FastScanner();
		int n=fs.nextInt(), k=fs.nextInt();
		Seg[] segs=new Seg[n];
		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
		Event[] events=new Event[n*2];
		for (int i=0; i<n; i++) {
			events[2*i]=new Event(segs[i], true);
			events[2*i+1]=new Event(segs[i], false);
		}
		long ans=0;

		Arrays.sort(events);
		int counter=0;
		for (Event e:events) {
			if (e.start) {
				counter++;
			}
			else {
				counter--;
				if (counter+1<k)
					continue;
				else
					ans=add(ans, nCk(counter, k-1));
			}
		}
		System.out.println(ans);
	}

	static final Random random=new Random();
	
	
	
	static long add(long a, long b) {
		return (a+b)%mod;
	}
	
	static long mul(long a, long b) {
		return a*b%mod;
	}
	
	static long exp(long base, long e) {
		if (e==0) return 1;
		long half=exp(base, e/2);
		if (e%2==0) return mul(half, half);
		return mul(half, mul(half, base));
	}
	
	static long modInv(long x) {
		return exp(x, mod-2);
	}
	
	static void precomp() {
		facts=new long[1_000_000];
		factInvs=new long[1_000_000];
		factInvs[0]=facts[0]=1;
		for (int i=1; i<facts.length; i++)
			facts[i]=mul(facts[i-1], i);
		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
		for (int i=facts.length-2; i>=0; i--)
			factInvs[i]=mul(factInvs[i+1], i+1);
	}
	
	static long nCk(int n, int k) {
		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
	}
	
	static class Seg {
		int l, r;
		public Seg(int l, int r) {
			this.l=l;
			this.r=r;
		}
	}
	
	static class Event implements Comparable<Event> {
		boolean start;
		Seg s;
		public Event(Seg s, boolean start) {
			this.s=s;
			this.start=start;
		}

		
		
		
	}
	
	

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class D {
	
	static final int mod=998244353;
	
	static long[] facts, factInvs;

	public static void main(String[] args) {
		precomp();
		FastScanner fs=new FastScanner();
		int n=fs.nextInt(), k=fs.nextInt();
		Seg[] segs=new Seg[n];
		for (int i=0; i<n; i++) segs[i]=new Seg(fs.nextInt(), fs.nextInt());
		Event[] events=new Event[n*2];
		for (int i=0; i<n; i++) {
			events[2*i]=new Event(segs[i], true);
			events[2*i+1]=new Event(segs[i], false);
		}
		long ans=0;

		Arrays.sort(events);
		int counter=0;
		for (Event e:events) {
			if (e.start) {
				counter++;
			}
			else {
				counter--;
				if (counter+1<k)
					continue;
				else
					ans=add(ans, nCk(counter, k-1));
			}
		}
		System.out.println(ans);
	}

	static final Random random=new Random();
	
	
	
	static long add(long a, long b) {
		return (a+b)%mod;
	}
	
	static long mul(long a, long b) {
		return a*b%mod;
	}
	
	static long exp(long base, long e) {
		if (e==0) return 1;
		long half=exp(base, e/2);
		if (e%2==0) return mul(half, half);
		return mul(half, mul(half, base));
	}
	
	static long modInv(long x) {
		return exp(x, mod-2);
	}
	
	static void precomp() {
		facts=new long[1_000_000];
		factInvs=new long[1_000_000];
		factInvs[0]=facts[0]=1;
		for (int i=1; i<facts.length; i++)
			facts[i]=mul(facts[i-1], i);
		factInvs[facts.length-1]=modInv(facts[facts.length-1]);
		for (int i=facts.length-2; i>=0; i--)
			factInvs[i]=mul(factInvs[i+1], i+1);
	}
	
	static long nCk(int n, int k) {
		return mul(facts[n], mul(factInvs[k], factInvs[n-k]));
	}
	
	static class Seg {
		int l, r;
		public Seg(int l, int r) {
			this.l=l;
			this.r=r;
		}
	}
	
	static class Event implements Comparable<Event> {
		boolean start;
		Seg s;
		public Event(Seg s, boolean start) {
			this.s=s;
			this.start=start;
		}

		
		
		
	}
	
	

	
}
",1,Plagiarised
968c1e7e,a4e1511a,"import java.util.*;
import java.io.*;

public class E_Air_Conditioners{
    public static void main(String[] args) {
        FastScanner s= new FastScanner();
        StringBuilder res = new StringBuilder();
        int t=s.nextInt();
        int p=0;
        while(p<t){
        int n=s.nextInt();
        int k=s.nextInt();
        int pos[]= new int[k];
        int temp[]= new int[k];
        int min=Integer.MAX_VALUE;
        int ans[]= new int[n];
        HashMap<Integer,ArrayList<Integer>> map = new HashMap<Integer,ArrayList<Integer>>();
            HashMap<Integer,Integer> count1 = new  HashMap<Integer,Integer> ();
        for(int i=0;i<k;i++){
            pos[i]=s.nextInt();
        }
        for(int i=0;i<k;i++){
            temp[i]=s.nextInt();
            ans[pos[i]-1]=temp[i];
            min=Math.min(temp[i],min);
            if(map.containsKey(temp[i])){
                map.get(temp[i]).add(pos[i]-1);
                int a=count1.get(temp[i]);
                a++;
                count1.remove(temp[i]);
                count1.put(temp[i],a);
            }
            else{
                ArrayList<Integer> obj = new ArrayList<Integer>();
                obj.add(pos[i]-1);
                map.put(temp[i],obj);
                count1.put(temp[i],1);
            }
        }
     
        int num=min;
       
        while(true){
           
        
           if(!map.containsKey(num)){
               break;
           }
          ArrayList<Integer> obj2 = map.get(num);
          
          for(int i=0;i<obj2.size();i++){
              int index=obj2.get(i);
              if(ans[index]!=0){
                  if(ans[index]<num){
                     
                    if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
                        ans[index+1]=num+1;
                       
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index+1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index+1);
                            map.put(num+1,object);
                        }
                    }

                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
                        ans[index-1]=num+1;
                     
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index-1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index-1);
                            map.put(num+1,object);
                        }
                    }

                  }
                  else if(ans[index]==num){
                   
                      if(index+1<n && (ans[index+1]>(num+1)|| ans[index+1]==0)){
                        ans[index+1]=num+1;
                   
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index+1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index+1);
                            map.put(num+1,object);
                        }
                    }

                    if(index-1>=0 && (ans[index-1]>(num+1)|| ans[index-1]==0)){
                        ans[index-1]=num+1;
                    
                        if(map.containsKey(num+1)){
                            map.get(num+1).add(index-1);
                        }
                        else{
                            ArrayList<Integer> object = new  ArrayList<Integer>();
                            object.add(index-1);
                            map.put(num+1,object);
                        }
                    }
                  }

              }
            
            }
           num++;
        }
        for(int i=0;i<ans.length;i++){
            res.append(ans[i]+"" "");
        }
        res.append(""\n"");
        p++;
    }
    System.out.println(res);


    }
    




}
","import java.io.*;
import java.util.*;


public class codefor
{
	
	public static void main(String[] args) 
	{
		FastReader sc=new FastReader();
		int T=sc.nextInt();
		while(T-->0)
		{
			int n=sc.nextInt(),k=sc.nextInt(),i=0;
			long t[]=new long[n];
			int a[]=new int[k];
			for(i=0;i<k;i++)
				a[i]=sc.nextInt()-1;
			for(i=0;i<k;i++)
				t[a[i]]=sc.nextLong();
			long ans[]=new long[n];
			PriorityQueue<Long> pq=new PriorityQueue<>();
			for(i=0;i<n;i++)
			{
				if(t[i]!=0)
					pq.add(t[i]-i);
				if(pq.size()!=0)
				{
					ans[i]=pq.peek()+i;
				}
			}
			pq.clear();
			for(i=n-1;i>=0;i--)
			{
				if(t[i]!=0)
					pq.add(t[i]+i);
				if(pq.size()!=0)
				{
					long val=pq.peek()-i;
					if(ans[i]==0)
						ans[i]=val;
					else 
						ans[i]=Math.min(val, ans[i]);
				}
				}
			pq.clear();
			for(i=0;i<n;i++)
				System.out.print(ans[i]+"" "");
			System.out.println();
		}
	}

}
",0,Non-plagiarised
69b2fd22,e6b7a899,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
","import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

public class Main {
	static final long MOD=1000000007;
	static final long MOD1=998244353;
	static long ans=0;
	//static ArrayList<Integer> ans=new ArrayList<>();
	public static void main(String[] args){
		PrintWriter out = new PrintWriter(System.out);
		InputReader sc=new InputReader(System.in);
		int N = sc.nextInt();
		int[] A = sc.nextIntArray(N);
		ArrayList<Integer> a1 = new ArrayList<Integer>();
		ArrayList<Integer> a2 = new ArrayList<Integer>();
		for (int i = 0; i < A.length; i++) {
			if (A[i]==0) {
				a1.add(i);
			}else {
				a2.add(i);
			}
		}
		int[][] dp = new int[a1.size()+1][a2.size()+1];
		for (int i = 0; i < dp.length; i++) {
			Arrays.fill(dp[i], Integer.MAX_VALUE/2);
		}
		dp[0][0] = 0;
		for (int i = 1; i <= a1.size() ; i++) {
			int pos1 = a1.get(i-1);
			for (int j = 0; j <= a2.size(); j++) {
				dp[i][j] = dp[i-1][j];
				if (j-1>=0) {
					int pos2 = a2.get(j-1);
					dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + Math.abs(pos1-pos2));
				}
			}
		}
		System.out.println(dp[a1.size()][a2.size()]);
	}
	
}
",0,Non-plagiarised
5dbd0a07,bdc08e6f,"import java.io.*;
import java.util.*;

import static java.lang.Double.parseDouble;
import static java.lang.Integer.compare;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.in;
import static java.lang.System.out;
import static java.util.Arrays.asList;
import static java.util.Collections.max;
import static java.util.Collections.min;

public class Main {
    private static final int MOD = (int) (1E9 + 7);
    private static final int INF = (int) (1E9);
    static FastScanner scanner = new FastScanner(in);

    public static void main(String[] args) throws IOException {
        // Write your solution here
        StringBuilder answer = new StringBuilder();
        int t = 1;
        t = parseInt(scanner.nextLine());
        while (t-- > 0) {
            answer.append(solve()).append(""\n"");
        }
//        out.println(answer);
    }

    private static Object solve() throws IOException {
       int n = scanner.nextInt();
       int m = scanner.nextInt();
       int x = scanner.nextInt();
       Integer[] h = new Integer[n];
       for (int i = 0; i < n; i++) {
          h[i] = scanner.nextInt();
       }
       TreeSet<Pair> q = new TreeSet<>();
       PriorityQueue<Pair> height = new PriorityQueue<>();
       for (int i = 0; i < m; i++) {
          q.add(new Pair(i + 1,0));
       }
       for (int i = 0; i < n; i++) {
          height.add(new Pair(i,h[i]));
       }
       boolean shift = false;
       int size = 0;
       while(!height.isEmpty()){
          Pair p = height.poll();
          Pair building  = (shift) ? q.pollLast() : q.pollFirst();
          h[p.index] = building.index;
          q.add(new Pair(building.index,building.value + p.value));
           //out.println(""q = "" + q);
          if(++size == n){
              size = 0;
              shift = !shift;
          }
       }
       if(safe(q,x)){
          out.println(""YES"");
          StringBuilder stringBuilder = new StringBuilder();
          for (Object o : h)
             stringBuilder.append(o).append("" "");
          out.println(stringBuilder);
       }
       else {
           out.println(""NO"");
       }
        return """";
    }

   private static boolean safe(TreeSet<Pair> q, int x) {
       int last = q.pollFirst().value;
       while (!q.isEmpty()){
          Pair p = q.pollFirst();
          if(p.value - last > x) return false;
          last = p.value;
       }
       return true;
   }

   private static class Pair implements Comparable<Pair> {
        int index, value;

        public Pair(int index, int value) {
            this.index = index;
            this.value = value;
        }

        

       
   }

    

    

    

    

    private static int add(int a, int b) {
        long res = ((long) (a + MOD) % MOD + (b + MOD) % MOD) % MOD;
        return (int) res;
    }

    


    

    

    
}
","import java.io.*;
import java.util.*;

import static java.lang.Double.parseDouble;
import static java.lang.Integer.compare;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.in;
import static java.lang.System.out;
import static java.util.Arrays.asList;
import static java.util.Collections.max;
import static java.util.Collections.min;

public class Main {
    private static final int MOD = (int) (1E9 + 7);
    private static final int INF = (int) (1E9);
    static FastScanner scanner = new FastScanner(in);

    public static void main(String[] args) throws IOException {
        // Write your solution here
        StringBuilder answer = new StringBuilder();
        int t = 1;
        t = parseInt(scanner.nextLine());
        while (t-- > 0) {
            answer.append(solve()).append(""\n"");
        }
//        out.println(answer);
    }

    private static Object solve() throws IOException {
       int n = scanner.nextInt();
       int m = scanner.nextInt();
       int x = scanner.nextInt();
       Integer[] h = new Integer[n];
       for (int i = 0; i < n; i++) {
          h[i] = scanner.nextInt();
       }
       TreeSet<Pair> q = new TreeSet<>();
       PriorityQueue<Pair> height = new PriorityQueue<>();
       for (int i = 0; i < m; i++) {
          q.add(new Pair(i + 1,0));
       }
       for (int i = 0; i < n; i++) {
          height.add(new Pair(i,h[i]));
       }
       boolean shift = false;
       int size = 0;
       while(!height.isEmpty()){
          Pair p = height.poll();
          Pair building  = (shift) ? q.pollLast() : q.pollFirst();
          h[p.index] = building.index;
          q.add(new Pair(building.index,building.value + p.value));
           //out.println(""q = "" + q);
          if(++size == n){
              size = 0;
              shift = !shift;
          }
       }
       if(safe(q,x)){
          out.println(""YES"");
          StringBuilder stringBuilder = new StringBuilder();
          for (Object o : h)
             stringBuilder.append(o).append("" "");
          out.println(stringBuilder);
       }
       else {
           out.println(""NO"");
       }
        return """";
    }

   private static boolean safe(TreeSet<Pair> q, int x) {
       int last = q.pollFirst().value;
       while (!q.isEmpty()){
          Pair p = q.pollFirst();
          if(p.value - last > x) return false;
          last = p.value;
       }
       return true;
   }

   private static class Pair implements Comparable<Pair> {
        int index, value;

        public Pair(int index, int value) {
            this.index = index;
            this.value = value;
        }

        

       
   }

    

    

    

    

    private static int add(int a, int b) {
        long res = ((long) (a + MOD) % MOD + (b + MOD) % MOD) % MOD;
        return (int) res;
    }

    

    

    

    

    
}
",1,Plagiarised
29bbcd8b,d4779c71,"import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Stack;
import java.util.StringTokenizer;

public class D {

   private static final String INPUT_FILE_PATH = """";

   void solve() {
      int n = in.nextInt();
      int[] h = new int[n];
      for (int i = 0; i < n; i++) h[i] = in.nextInt();

      Stack<Integer> increasing = new Stack();
      Stack<Integer> increasingIndices = new Stack();
      Stack<Integer> decreasing = new Stack();
      Stack<Integer> decreasingIndices = new Stack();
      increasing.push(h[0]);
      increasingIndices.push(0);
      decreasing.push(h[0]);
      decreasingIndices.push(0);

      int[] dp = new int[n];
      dp[0] = 0;

      for (int i = 1; i < n; i++) {
         dp[i] = dp[i - 1] + 1;

         while (!increasing.isEmpty() && increasing.peek() > h[i]) {
            dp[i] = Math.min(dp[i], 1 + dp[increasingIndices.peek()]);

            increasing.pop();
            increasingIndices.pop();
         }
         while (!decreasing.isEmpty() && decreasing.peek() < h[i]) {
            dp[i] = Math.min(dp[i], 1 + dp[decreasingIndices.peek()]);

            decreasing.pop();
            decreasingIndices.pop();
         }

         if (!increasing.isEmpty()) {
            dp[i] = Math.min(dp[i], 1 + dp[increasingIndices.peek()]);
         }
         if (!decreasing.isEmpty()) {
            dp[i] = Math.min(dp[i], 1 + dp[decreasingIndices.peek()]);
         }

         if (!increasing.isEmpty() && increasing.peek() == h[i]) {
            increasing.pop();
            increasingIndices.pop();
         }
         if (!decreasing.isEmpty() && decreasing.peek() == h[i]) {
            decreasing.pop();
            decreasingIndices.pop();
         }

         increasing.push(h[i]);
         increasingIndices.push(i);
         decreasing.push(h[i]);
         decreasingIndices.push(i);
      }
      out.println(dp[n - 1]);
   }

   private final InputReader in;
   private final PrintWriter out;

   private D(InputReader in, PrintWriter out) {
      this.in = in;
      this.out = out;
   }

   

   public static void main(String[] args) throws Exception {
      InputStream inputStream = INPUT_FILE_PATH.isEmpty()
         ? System.in
         : new FileInputStream(new File(INPUT_FILE_PATH));
      OutputStream outputStream = System.out;

      InputReader inputReader = new InputReader(inputStream);
      PrintWriter printWriter = new PrintWriter(outputStream);

      new D(inputReader, printWriter).solve();

      printWriter.close();
   }

}
","import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class D {
    static Scanner sc = new Scanner(System.in);
    static int[] height;
    static int[] dp;

    public static void main(String[] args) {
        int n = sc.nextInt();
        height = new int[n];
        dp = new int[n];
        dp[0] = 0;
        for (int i = 0; i < n; i++) {
            height[i] = sc.nextInt();
        }
        Stack<Integer> rise = new Stack<Integer>();
        Stack<Integer> fail = new Stack<Integer>();
        rise.push(0);
        fail.push(0);
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i-1]+1;

            if (rise.isEmpty()) {
                rise.push(i);
            } else if (height[rise.peek()] < height[i]) {
                rise.push(i);
            } else {
                while (!rise.isEmpty() && height[rise.peek()] > height[i]) {
                    rise.pop();
                    if (!rise.isEmpty()) {
                        dp[i] = Math.min(dp[i], dp[rise.peek()] + 1);
                    }
                }
                while (!rise.isEmpty() && height[rise.peek()] == height[i]) {
                    rise.pop();
                }
                rise.push(i);
            }


            if (fail.isEmpty()) {
                fail.push(i);
            } else if (height[fail.peek()] > height[i]) {
                fail.push(i);
            } else {
                while (!fail.isEmpty() && height[fail.peek()] < height[i]) {
                    fail.pop();
                    if (!fail.isEmpty()){
                        dp[i] = Math.min(dp[i], dp[fail.peek()] + 1);
                    }
                }
                while (!fail.isEmpty() && height[fail.peek()] == height[i]) {
                    fail.pop();
                }
                fail.push(i);
            }
        }

        System.out.println(dp[n - 1]);

    }
}
",0,Non-plagiarised
24afd00e,279e274a,"import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
public class CP {
	  
	 static int mod  = 1000000007;
	 
	 
	 
	
	 

/* ***************************************************************************************************************************************************/	 
	 static FR sc = new FR();
	 static StringBuilder sb = new StringBuilder();
	 public static void main(String args[]) {
		 int tc = sc.nextInt();
	
		 while(tc-- > 0) {
			 TEST_CASE();
		 }
			System.out.println(sb);
		 }		

		static void TEST_CASE() {
		int n = sc.nextInt();
		 lr = new long[n][2];
		for(int  i =0 ; i < n ; i ++) {
			lr[i][0] = sc.nextLong();
			lr[i][1] = sc.nextLong();
		}
		 adj = new ArrayList<ArrayList<Integer>>();
		for(int i = 0 ; i <n ; i++) adj.add(new ArrayList<Integer>());
		
		for(int i = 0 ; i<n-1 ; i++) {
			int u = sc.nextInt()-1 , v = sc.nextInt()-1;
			adj.get(u).add(v);
			adj.get(v).add(u);
		}
		min = new long[n];
		max = new long[n];
		dfs(0,-1);
		sb.append(Math.max(min[0], max[0])).append(""\n"");
		
		}
		static long[] min , max , lr[];
		static ArrayList<ArrayList<Integer>> adj;
		static void dfs(int u , int p  ) {
			
			for(int child:adj.get(u)) {
				if(child == p) continue;
				dfs(child , u);
			}
			long left = lr[u][0] , right = lr[u][1];
			
			long ansl = 0 , ansr = 0;
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansl += Math.max( min[child] + Math.abs(left - leftc)  ,
						max[child] +Math.abs(left - rightc)      );
			}
			for(int child:adj.get(u)) {
				if(child == p) continue;
				long leftc = lr[child][0] , rightc = lr[child][1];
				ansr += Math.max( min[child] + Math.abs(right - leftc)  ,
						max[child] +Math.abs(right - rightc)      );
			}
			min[u] = ansl;
			max[u] = ansr;
			
		}
		
}
","import java.io.*;
import java.util.*;

public class C {
    

    static FastReader s = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    

    

    

    

    private static int ri() {
        return s.nextInt();
    }

    private static long rl() {
        return s.nextLong();
    }

    

    

    

    
    static int MOD=1000000007;

    

    static long[][] dp;
    static void dfs(List<Integer>[] list, long[] l, long[] r, boolean[] vis,int node)
    {
        vis[node] = true;

        for(int i:list[node])
        {
            if(!vis[i])
            {
                dfs(list,l,r,vis, i);
                dp[node][0] += Math.max(dp[i][0]+Math.abs(l[node]-l[i]), dp[i][1]+Math.abs(l[node]-r[i]));
                dp[node][1] += Math.max(dp[i][0]+Math.abs(r[node]-l[i]), dp[i][1]+Math.abs(r[node]-r[i]));
            }

        }
    }
    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
        int t = ri();
//        int t = 1;
        while (t-- > 0)
        {
            int n=ri();
            dp = new long[n][2];
            long[] l = new long[n];
            long[] r = new long[n];
            for(int i=0;i<n;i++)
            {
                l[i] = rl();
                r[i] = rl();

            }

            List<Integer>[] list=new ArrayList[n];
            for(int i=0;i<n;i++)
            {
                list[i] = new ArrayList<>();
            }

            for(int i=0;i<n-1;i++)
            {
                int a= ri();int b=ri();
                a--;b--;
                list[a].add(b);
                list[b].add(a);
            }

            boolean[] vis = new boolean[n];
            dfs(list,l,r,vis,0);

//            for(int i=0;i<n;i++)
//            {
//                System.out.println(Arrays.toString(dp[i]));
//            }

            ans.append(Math.max(dp[0][0],dp[0][1])).append(""\n"");

        }
        out.print(ans.toString());
        out.flush();
    }



}
",0,Non-plagiarised
949502c2,9fc811f7,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;

public class Template {

	static int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int yo = sc.nextInt();
		while (yo-- > 0) {
			int n = sc.nextInt();
            int a = sc.nextInt()-1;
            int b = sc.nextInt()-1;
            int da = sc.nextInt();
            int db = sc.nextInt();
            
            List<List<Integer>> list = new ArrayList<>();
            for(int i = 0; i < n; i++) list.add(new ArrayList<>());
            
            for(int i = 0; i < n-1; i++){
                int x = sc.nextInt()-1;
                int y = sc.nextInt()-1;
                list.get(x).add(y);
                list.get(y).add(x);
            }
            
            for(int i = 0; i <= n; i++) depth[i] = 0;
            diam = 0;
            dfs(a,-1,list);
            
            if(2 * da >= min(diam, db) || depth[b] <= da){
                out.println(""Alice"");
            }
            else {
                out.println(""Bob"");
            }
            
		}
	}
    
    static int[] depth = new int[200001];
    static int diam = 0;
    static int dfs(int x, int p, List<List<Integer>> list) {
        int len = 0;
        List<Integer> ne = list.get(x);
        for(int y : ne) {
            if(y != p) {
                depth[y] = depth[x] + 1;
                int cur = 1 + dfs(y, x,list);
                diam = max(diam, cur + len);
                len = max(len, cur);
            }
        }
        return len;
    }
   

	

	

	

	

	

	

	

	//	For Input.txt and Output.txt	
	//	FileInputStream in = new FileInputStream(""input.txt"");
	//	FileOutputStream out = new FileOutputStream(""output.txt"");
	//	PrintWriter pw = new PrintWriter(out);
	//	Scanner sc = new Scanner(in);
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DTreeTag solver = new DTreeTag();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class DTreeTag {
        int diam = 0;

        public int dfs(ArrayList<Integer> g[], int x, int depth[], int p) {
            int len = 0;
            for (int y : g[x]) {
                if (y != p) {
                    depth[y] = depth[x] + 1;
                    int cur = 1 + dfs(g, y, depth, x);
                    diam = Math.max(diam, cur + len);
                    len = Math.max(len, cur);
                }
            }
            return len;
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            int da = in.nextInt();
            int db = in.nextInt();
            int dis[] = new int[n];
            ArrayList<Integer> g[] = new ArrayList[n];
            for (int i = 0; i < n; i++) g[i] = new ArrayList<>();
            for (int i = 0; i < n - 1; i++) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;
                g[u].add(v);
                g[v].add(u);
            }
            diam = 0;
            dfs(g, a, dis, -1);
            int disb = dis[b];
            if (2 * da >= Math.min(diam, db) || disb <= da) {
                out.println(""Alice"");
            } else {
                out.println(""Bob"");
            }

        }

    }

    
}
",1,Plagiarised
929b98f0,bf85ab7b,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.*;

public class Main {

    public static long[] ans(List<List<Integer>> edges, long[][] range, int root, boolean[] visited, PrintStream out) {
        if (visited[root]) {
            return new long[2];
        }
        visited[root] = true;
        long[] ans = new long[2];
        for (int x : edges.get(root)) {
            if (!visited[x]) {
                long[] temp = ans(edges, range, x, visited, out);
                ans[0] += Math.max(Math.abs(range[root][0] - range[x][0]) + temp[0], Math.abs(range[root][0] - range[x][1]) + temp[1]);
                ans[1] += Math.max(Math.abs(range[root][1] - range[x][0]) + temp[0], Math.abs(range[root][1] - range[x][1]) + temp[1]);
            }
        }
        return ans;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintStream out = new PrintStream(System.out);
        int t = Integer.parseInt(reader.readLine());
        while (t-->0) {
            int n = Integer.parseInt(reader.readLine());
            long[][] range = new long[n][2];
            for (int i = 0; i < n; i++) {
                String[] input = reader.readLine().split("" "");
                range[i][0] = Integer.parseInt(input[0]);
                range[i][1] = Integer.parseInt(input[1]);
            }
            List<List<Integer>> edges = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                edges.add(new ArrayList<>());
            }
            for (int i = 0; i < n - 1; i++) {
                String[] input = reader.readLine().split("" "");
                int u = Integer.parseInt(input[0]) - 1, v = Integer.parseInt(input[1]) - 1;
                edges.get(u).add(v);
                edges.get(v).add(u);
            }
            int root = 0;
            for (int i = 0; i < n; i++) {
                if (edges.get(i).size() > 1) {
                    root = i;
                    break;
                }
                if (edges.get(i).size() == 1) {
                    root = i;
                }
            }
            long[] ans = ans(edges, range, root, new boolean[n], out);
            out.println(Math.max(ans[0], ans[1]));
        }
        out.close();
    }
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.io.DataInputStream;
import java.io.FileInputStream;

import java.io.IOException;

public class ParsasHumongousTree {

    public static void main(String args[]) throws IOException {
        Reader scan = new Reader();
        StringBuilder sb = new StringBuilder();

        int t = scan.nextInt();
        while (t-- > 0) {
            int n = scan.nextInt();
            int[] l = new int[n + 1];
            int[] r = new int[n + 1];
            for (int i = 1; i <= n; i++) {
                l[i] = scan.nextInt();
                r[i] = scan.nextInt();
            }
            Graph g = new Graph(n);
            for (int i = 0; i < n - 1; i++) {
                g.addEdge(scan.nextInt(), scan.nextInt());
            }
            sb.append(g.dfs(l, r) + ""\n"");
        }
        System.out.println(sb);
    }
}

class Graph {

    ArrayList<Integer>[] node;
    int n;
    int c = 0;
    boolean[] vis;

    Graph(int s) {
        n = s + 1;
        vis = new boolean[n + 1];
        node = new ArrayList[n + 1];
        for (int i = 0; i < n + 1; i++) {
            node[i] = new ArrayList<>();
        }
    }

    void addEdge(int u, int v) {

        node[u].add(v);
        node[v].add(u);
        if (node[u].size() == 1) {
            c = u;
        }
        if (node[v].size() == 1) {
            c = v;
        }
    }

    void cleanVisArray() {
        for (int i = 0; i < n + 1; i++) {
            vis[i] = false;
        }
    }

    long dfs(int[] l, int[] r) {
        cleanVisArray();

        long[][] dp = new long[n][2];
        dfsMain(1, dp, l, r);
        return Math.max(dp[1][0], dp[1][1]);
    }

    void dfsMain(int v, long[][] dp, int[] l, int[] r) {
        vis[v] = true;
        for (int i : node[v]) {
            if (!vis[i]) {
                dfsMain(i, dp, l, r);
                dp[v][0] += Math.max(Math.abs(l[v] - l[i]) + dp[i][0], Math.abs(l[v] - r[i]) + dp[i][1]);
                dp[v][1] += Math.max(Math.abs(r[v] - l[i]) + dp[i][0], Math.abs(r[v] - r[i]) + dp[i][1]);
            }
        }
    }

}


",0,Non-plagiarised
1be078c4,7ae0cb0d,"import java.util.*;
import java.io.*;

public class E_1547 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		
		int T = sc.nextInt();
		while(T-->0) {
			int n = sc.nextInt(), k = sc.nextInt();
			int[] a = sc.nextIntArray(k);
			int[] t = sc.nextIntArray(k);
			
			int[] array = new int[n];
			Arrays.fill(array, Integer.MAX_VALUE);
			for(int i = 0; i < k; i++)
				array[a[i] - 1] = t[i];
			
			int[] pre = new int[n];
			int[] post = new int[n];
			
			int prev = (int)2e9;
			for(int i = 0; i < n; i++)
				prev = pre[i] = Math.min(prev + 1, array[i]);
			
			prev = (int)2e9;
			for(int i = n - 1; i >= 0; i--)
				prev = post[i] = Math.min(prev + 1, array[i]);
			
			for(int i = 0; i < n; i++)
				array[i] = Math.min(pre[i], post[i]);
			
			for(int i = 0; i < n; i++)
				pw.print(array[i] + (i == n - 1 ? ""\n"" : "" ""));
		}
		
		pw.flush();
	}

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class AirConditioners {

    static FastReader read  =new FastReader();
    static int INF = (int)(2e9);
    static int mxn = (int)(3e5 + 10);
    public static void main(String[] args) {

        int t = read.nextInt();
        while (t-- > 0)
            solve();
    }

    private static void solve() {

        int n = read.nextInt(), k = read.nextInt();

        int[] a = new int[n];
        int[] t = new int[n];

        Arrays.fill(t, Integer.MAX_VALUE);

        for (int i=0;i<k;++i){
            a[i] = read.nextInt();
        }

        for (int i=0;i<k;++i){
            t[--a[i]] = read.nextInt();
        }

        int[] L = new int[n];
        int[] R = new int[n];

        int tmp = INF;
        for (int i=0;i<n;++i){
            tmp = Math.min(tmp+1, t[i]);
            L[i] = tmp;
        }

        tmp = INF;

        for (int i=n-1;i>=0;--i){
            tmp = Math.min(tmp+1, t[i]);
            R[i] = tmp;
        }


        for (int i=0;i<n;++i){
            int ans = Math.min(L[i], R[i]);
            System.out.print(ans + "" "");
        }

        System.out.println();

    }

    

}
",0,Non-plagiarised
1dab88fb,a6229ee9,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.util.*;
import java.io.*;

public class hmm {

	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
	 static boolean visited[];
	 static ArrayList<pair>arr[];
	 static HashMap<String,Integer>hm = new HashMap<>();
   public static void dfs(int start, int prime) {
	   visited[start]=true;
	   for(pair x: arr[start]) {
		   if(!visited[(int) x.x]) {
			   x.y = prime==2?3:2;
			   hm.put(start+"",""+x.x,x.y);
			   hm.put(x.x+"",""+start, x.y);
			   dfs(x.x,x.y);
		   }
	   }
	   
   }
   

	public static void main(String[] args) throws Exception {
		int t =sc.nextInt();
		while (t-- > 0) {
		         int n =sc.nextInt();
		         visited= new boolean [n];
		         arr=new ArrayList[n];
		         int[]color = new int[n];
		         ArrayList<pair>lol = new ArrayList<pair>();
		         
		         for(int i=0;i<n;i++)
		        	 arr[i]=new ArrayList<pair>();
		         for(int i=0;i<n-1;i++) {
		        	 int u = sc.nextInt()-1;
		        	 int v = sc.nextInt()-1;
		             lol.add(new pair(u,v));
		        	 arr[u].add(new pair(v,0));
		        	 arr[v].add(new pair(u,0));
		         }
		         boolean can = true;
		         for(int i=0;i<n;i++)
		        	 if(arr[i].size()>2){
		        		 can = false;
		        	 }
		         if(!can)
		        	 pw.println(-1);
		         
		         else {
		        	 int []hh = new int [] {2,3};
		        	 int i=0;
		        	 visited[0]= true;
		        	 for(pair x: arr[0]) {
		        		 hm.put(0+"",""+x.x,hh[i]);
		        		 dfs(x.x,hh[i++]);
		        	 }
		        	 //dfs(0,3);
		        	 for(pair a:lol) {
		        		 int u = a.x;
		        		 int y = a.y;
		        		 if(hm.containsKey(u+"",""+y))
		        				 pw.print(hm.get(u+"",""+y)+"" "");
		        		 else
		        			 pw.print(hm.get(y+"",""+u)+"" "");
		        	 }
		        	 pw.println();
		         }
			
		}

		pw.close();

	}

	// -------------- stuff ------------------------------
	static class pair {
		int x ;
		int y;
	
		
		public pair(int n,int c) {
			x= n;
			y = c;
		
			
		}
	
	
		
	}

	

}
",0,Non-plagiarised
6653a758,6bcc5afd,"import java.util.*;
public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner s=new Scanner(System.in);
     int n=s.nextInt();
     int a[]=new int[n];
     ArrayList<Integer> lt1=new ArrayList<>();
     ArrayList<Integer> lt0=new ArrayList<>();
     for(int i=0;i<n;i++)
     {
         int l=s.nextInt();
         if(l==0)
         lt0.add(i+1);
         else
         lt1.add(i+1);
     }
     int dp[][]=new int[lt1.size()+1][lt0.size()+1];
     for(int i=1;i<=lt1.size();i++)
     {
         dp[i][i]=dp[i-1][i-1]+Math.abs(lt0.get(i-1)-lt1.get(i-1));
         for(int j=i+1;j<=lt0.size();j++)
         {
             dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(lt1.get(i-1)-lt0.get(j-1)));
         }
     }
     System.out.println(dp[lt1.size()][lt0.size()]);
     
    }
}
",1,Plagiarised
312d9460,e7024f3e,"import java.util.*;
import java.io.*;
public class CF_1547_E{
	public static void main(String[] args) throws Exception{
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st, st1;

		int q = Integer.parseInt(br.readLine());
		while(q-->0){
			br.readLine();
			st = new StringTokenizer(br.readLine());
			int n = Integer.parseInt(st.nextToken());
			int k = Integer.parseInt(st.nextToken());

			PriorityQueue<Pair> right_side = new PriorityQueue<Pair>();

			int at[] = new int[n+1];
			st = new StringTokenizer(br.readLine());
			st1 = new StringTokenizer(br.readLine());

			for(int i=0;i<k;i++){
				int a = Integer.parseInt(st.nextToken());
				int t = Integer.parseInt(st1.nextToken());
				at[a] = t;
				right_side.add(new Pair(a, t));
			}

			long left= Integer.MAX_VALUE;

			for(int i=1;i<=n;i++){

				while(right_side.isEmpty()==false && right_side.peek().a<=i){
					Pair temp = right_side.poll();
					if(temp.t - temp.a <= left)
						left = temp.t - temp.a;
				}

				if(at[i]!=0){
					if(at[i]-i <=left)
						left = at[i] - i;
				}

				long ans = left+i;

				if(!right_side.isEmpty()){
					Pair right = right_side.peek();
					ans = Math.min(ans, right.t+right.a-i);
				}

				sb.append(ans+"" "");
			}
			sb.append(""\n"");
		}

		pw.print(sb);
		pw.flush();
		pw.close();
	}
}

class Pair implements Comparable<Pair>{
	int a, t;
	Pair(int a, int t){
		this.a = a;
		this.t = t;
	}
	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    static String solve(int n, int k, int[] a, int[] t) {
        Pair[] pairs = new Pair[k];
        for (int i = 0; i < k; i++) {
            pairs[i] = new Pair(a[i], t[i]);
        }
        Arrays.sort(pairs);
        int[] ret = new int[n + 1];
        Arrays.fill(ret, Integer.MAX_VALUE);

        int pIdx = 0;
        int ct = pairs[pIdx].t;
        ret[pairs[pIdx].a] = ct;
        for (int i = pairs[pIdx].a + 1; i <= n; i++) {
            ct++;
            if (pIdx + 1 < k && pairs[pIdx + 1].a == i) {
                if (ct > pairs[pIdx + 1].t) {
                    ct = pairs[pIdx + 1].t;
                }
                pIdx++;
            }
            ret[i] = ct;
            // System.out.println(Arrays.toString(ret));
        }
        // System.out.println();
        pIdx = k - 1;
        ct = pairs[pIdx].t;
        for (int i = pairs[pIdx].a - 1; i > 0; i--) {
            ct++;
            if (pIdx - 1 >= 0 && pairs[pIdx - 1].a == i) {
                if (ct > pairs[pIdx - 1].t) {
                    ct = pairs[pIdx - 1].t;
                }
                pIdx--;
            }
            if (ct < ret[i]) {
                ret[i] = ct;
            }
            // System.out.println(Arrays.toString(ret));
        }
        StringBuilder out = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            out.append(ret[i]).append("" "");
        }
        // System.out.println();
        // System.out.println();
        return out.toString();
    }

    static class Pair implements Comparable<Pair> {
        int a, t;

        public Pair(int a, int t) {
            this.a = a;
            this.t = t;
        }

        
    }


    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder out = new StringBuilder();
        int T = Integer.parseInt(st.nextToken());
        while (T-- > 0) {
            st = new StringTokenizer(br.readLine());
            st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());
            st = new StringTokenizer(br.readLine());
            int[] a = new int[k];
            for (int i = 0; i < k; i++) {
                a[i] = Integer.parseInt(st.nextToken());
            }
            st = new StringTokenizer(br.readLine());
            int[] t = new int[k];
            for (int i = 0; i < k; i++) {
                t[i] = Integer.parseInt(st.nextToken());
            }

            out.append(solve(n, k, a, t)).append(""\n"");
        }
        System.out.println(out);
    }
}
",0,Non-plagiarised
6e637812,aa8091b0,"import java.io.PrintWriter;
import java.util.*;
public class codeforces {
	public static void main(String[] args) {
		PrintWriter out=new PrintWriter(System.out);
    	Scanner s=new Scanner(System.in);  
    	int t=s.nextInt();
    	for(int tt=0;tt<t;tt++) {
    		int n=s.nextInt(),m=s.nextInt(),x=s.nextInt();
    		HashMap<Integer,ArrayList<Integer>> map=new HashMap<>();
    		int a[]=new int[n];
    		for(int i=0;i<n;i++) {
    			a[i]=s.nextInt();
    			if(map.containsKey(a[i])) {
    				ArrayList<Integer> c=map.get(a[i]);
    				c.add(i+1);
    				map.put(a[i], c);
    			}else {
    				ArrayList<Integer> c=new ArrayList<>();
    				c.add(i+1);
    				map.put(a[i], c);
    			}
    		}
    		sort(a);
    		long ans[]=new long[m];
    		int c=0;
    		boolean l=true;
    		for(int i=n-1;i>=0;i--) {
    			if(c==m && l) {
    				c=m-1;
    				l=false;
    			}else if(!l && c==-1){
    				l=true;
    				c=0;
    			}
    			ans[c]+=a[i];
    			if(l) {
    				c++;
    			}else {
    				c--;
    			}
    		}
    		long min=Integer.MAX_VALUE,max=Integer.MIN_VALUE;
    		for(int i=0;i<m;i++) {
    			min=Math.min(ans[i], min);
    			max=Math.max(ans[i], max);
    		}
    		if(max-min>x) {
    			System.out.println(""NO"");
    		}else {
    			System.out.println(""YES"");
    			int a1[]=new int[n];
    			c=0;
    			l=true;
    			for(int i=n-1;i>=0;i--) {
    				if(c==m && l) {
        				c=m-1;
        				l=false;
        			}else if(!l && c==-1){
        				l=true;
        				c=0;
        			}
    				a1[map.get(a[i]).get(0)-1]=c+1;
    				
    				map.get(a[i]).remove(0);
    				if(l) {
        				c++;
        			}else {
        				c--;
        			}
    				
    			}
    			for(int i=0;i<n;i++) {
    				System.out.print(a1[i]+"" "");
    			}
    			System.out.println();
    		}
    	}
    	out.close();
	    s.close();
	}
	
	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
	
}
","import java.util.*;
 
import java.io.*;
 
public class AiseHi {
	static Scanner sc = new Scanner(System.in);
	static int mod = (int)(1e9+7);
	public static void main (String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		int t = 1;
    	t = sc.nextInt();
    	z : while(t-->0) {
    		int n = sc.nextInt();
    		int m = sc.nextInt();
    		int x = sc.nextInt();
    		PriorityQueue<twoval> myQueue = new PriorityQueue<>();
    		for(int i=1;i<=m;i++) {
    			myQueue.add(new twoval(0,i));
    		}
    		List<twoval> arrayList = new ArrayList<>();
    		int myArray[] = new int[n];
    		for(int i=0;i<n;i++) {
    			int aasjd = sc.nextInt();
    			arrayList.add(new twoval(aasjd,i));
    			myArray[i] = aasjd;
    		}
    		Collections.sort(arrayList);
    		int ans[] = new int[n];
    		for(int i=n-1;i>=0;i--) {
    			twoval p = myQueue.poll();
    			long aasjd = p.myArray;
    			int idx = p.b;
    			aasjd += arrayList.get(i).myArray;
    			ans[arrayList.get(i).b] = idx;
    			myQueue.add(new twoval(aasjd,idx));
    		}
    		long dasdaknw[] = new long[m];
    		long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
    		for(int i=0;i<n;i++) {
    			dasdaknw[ans[i]-1] += myArray[i];
    		}
    		for(int i=0;i<m;i++) {
    			min = Math.min(min, dasdaknw[ans[i]-1]);
    			max = Math.max(max, dasdaknw[ans[i]-1]);
    		}
    		if(max-min>x) {
    			out.write(""NO\n"");
    			continue;
    		}
    		out.write(""YES\n"");
    		for(int aasjd : ans) out.write(aasjd+"" "");
    		out.write(""\n"");
    	}
		out.close();
	}
	
	static boolean prime[] = new boolean[2000009];
	static int fac[] = new int[2000009];
	
	
	
}
 
class twoval implements Comparable<twoval>{
	long myArray;
	int b;
	twoval(long aasjd,int r){
		this.myArray = aasjd;
		this.b = r;
	}
	
}
",0,Non-plagiarised
2b7b2d45,a0b406e6,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;



public class D_1552 {
	 
    public static void main(String args[])
    {
    	 FastReader fs = new FastReader();
        int tc = fs.nextInt();
        
        while(tc-- > 0)
        {   boolean flag=false;
        	int n=fs.nextInt();
            int[] ar=new int[n];
            for(int i=0;i<n;i++)
            {ar[i]=fs.nextInt();}
        	for(int i=1;i<Math.pow(3, n);i++)
        	{
        		int copy=i;
        		int sum=0;
        		for(int j=0;j<n;j++)
        		{
        			int rem=copy%3;
        			sum+=rem==0?0:rem==1?ar[j]:-ar[j];
        			copy=copy/3;
        		}
        		if(sum==0)
        			{System.out.println(""yes"");
        			flag=true;
        			break;}
        			}
        	       if(flag==false)
        			System.out.println(""no"");
        	}
        
        }
        
    
    
}
","import java.io.*;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();
		int tcCnt = in.nextInt();
		for (int tc = 1; tc <= tcCnt; tc++)
			solver.solve(tc, in, out);
		out.close();
	}

	static class Task {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i = 0; i < n; i++) {
				a[i] = in.nextInt();
			}
			for (int mask = 1; mask < (int)(Math.pow(3, n)); mask++) {
				int copy = mask;
				int sum = 0;
				for (int idx = 0; idx < n; idx++) {
					int digit = copy % 3;
					sum += digit == 0 ? 0 : digit == 1 ? a[idx] : -a[idx];
					copy = copy / 3;
				}
				if (sum == 0) {
					out.println(""YES"");
					return;
				}
			}
			out.println(""NO"");
		}

	}

	
}
",1,Plagiarised
26e699de,3dd65549,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

        Scanner sc= new Scanner(System.in);
        int numberTest=sc.nextInt();
        while(numberTest-->0){
            int n=sc.nextInt();
            char[] s=new char[n+5];
            char[] t=new char[n+5];
            String ss=sc.next();
            String tt=sc.next();
            s=ss.toCharArray();
            t=tt.toCharArray();
            int cntax = 0, cntbx = 0, same = 0;
            int ans=MOD9;
            for(int i=0; i<n; i++){
                if(s[i]=='1')cntax++;
                if(t[i]=='1')cntbx++;
                if(s[i]==t[i])same++;
            }
            if(same==n){
                System.out.println(0);
                continue;
            }
            else if (cntax==0){
                System.out.println(-1);
                continue;
            }
            if(cntax==cntbx){
                ans=Math.min(ans,n-same);
            }
            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
            if(ans<MOD9) System.out.println(ans);
            else System.out.println(-1);



        }

    }
}
","import java.util.*;
import java.io.*;

public class codeforces {
	public static void main(String[] args) throws Exception {
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt();
			char[] a=sc.next().toCharArray();
			char[] b=sc.next().toCharArray();
			int e0=0;
			int e1=0;
			int o0=0;
			int o1=0;
			for(int i=0;i<n;i++) {
				if(a[i]!=b[i]) {
					if(a[i]=='1') {
						e1++;
					}else {
						e0++;
					}
				}else {
					if(a[i]=='1') {
						o1++;
					}else {
						o0++;
					}
				}
			}
			int ans=Integer.MAX_VALUE;
			
			if(e1==e0) {
				ans=Math.min(ans, e1+e0);
			}
			if(o1==o0+1) {
				ans=Math.min(ans, o1+o0);
			}
//			pw.println(e0+"" ""+e1+"" ""+o0+"" ""+o1);
			pw.println(ans==Integer.MAX_VALUE?-1:ans);
		}
		pw.close();
	}

	

	

	

	static long mod = 1000000007;
	static Random rn = new Random();
	static Scanner sc = new Scanner(System.in);
	static PrintWriter pw = new PrintWriter(System.out);
}
",0,Non-plagiarised
16857116,6e207cbf,"import javax.swing.plaf.IconUIResource;
import java.lang.reflect.Array;
import java.text.CollationElementIterator;
import java.util.*;
import java.io.*;

//Timus judge id- 323935JJ


public class Main {




    //----------------------------------------------------------------------------------------------
    


    public static int mod = (int) (1e9 + 7);
    static int ans = Integer.MAX_VALUE;

    public static void main(String hi[]) throws Exception {
        FastReader sc = new FastReader();
        int t =sc.nextInt();
        while(t-->0)
        {
            int n =sc.nextInt();
            String a = sc.nextLine(),b=sc.nextLine();

            int count1=0,count2=0,count3=0,count4=0;

            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
                    count1++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
                    count2++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
                    count3++;
                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
                    count4++;
            }
            int ans=Integer.MAX_VALUE;

            if(count3==count4)
                ans=Math.min(count3*2,ans);

            if(count2==count1+1)
                ans=Math.min(ans,2*count1+1);

            if(count2==1&&count1==0)
                ans=1;
            if(count3==0&&count4==0)
                ans=0;
            if(ans==Integer.MAX_VALUE)
                System.out.println(-1);
            else System.out.println(ans);

        }

    }

    





    

    // method to return LCM of two numbers
    


    

    // method to return LCM of two numbers
    


    
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        int sm, n;
        while(t > 0) {
            t--;
            n = sc.nextInt();
            String s1,s2;
            s1 = sc.next();
            s2 = sc.next();
            int a[] = new int[4];
            a[0] = 0; a[1] = 0; a[2] = 0; a[3] = 0;
            for(int i = 0 ; i < n ; i++) {
                if(s1.charAt(i) == '0'&& s2.charAt(i) == '1') a[0]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '0') a[1]++;
                else if(s1.charAt(i) == '1'&& s2.charAt(i) == '1') a[2]++;
                else a[3]++;
            }
            // System.out.println(a[0] + "" "" + a[1] + "" "" + a[2] + "" "" + a[3]);
            int n1 = Integer.MAX_VALUE, n2 = Integer.MAX_VALUE, n3 = Integer.MAX_VALUE;
            
            if (a[0] == a[1]) {
                n1 = 2*a[0];
            }
            if((a[2] - 1) == a[3]) {
                // System.out.println(a[3] + 1);
                n2 = 2*a[3] + 1;
            } 
            if((a[3] + 1) == a[2]) {
                // System.out.println(a[2] + 1);
                n3 = 2*a[2] + 1;
            } 
            int ans = Math.min(n1, Math.min(n2,n3));
            if(ans == Integer.MAX_VALUE) {
                System.out.println(""-1"");
            } else {
                System.out.println(ans);
            }
        }
	}
}
",0,Non-plagiarised
0588b869,9028caf7,"import java.util.*;
import java.io.*;
public class Solution
{
    
    static final long mod=(long)1e9+7;
    
    
    /*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();
        int n=fs.nextInt();
        int a[]=new int[n];
        for(int i=0;i<n;i++)
        a[i]=fs.nextInt();
        ArrayList<Integer> o=new ArrayList<>();
        ArrayList<Integer> z=new ArrayList<>();
        for(int i=0;i<n;i++)
        {
            if(a[i]==1)o.add(i);
            else z.add(i);
        }
        int ans[][]=new int[o.size()+1][z.size()+1];
        for(int i=1;i<=o.size();i++)
        {
            for(int j=i;j<=z.size();j++)
            {
                if(i==j)ans[i][j]=ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1));
                else 
                ans[i][j]=Math.min(ans[i][j-1],ans[i-1][j-1]+(int)Math.abs(o.get(i-1)-z.get(j-1)));
            }
        }
        pw.println(ans[o.size()][z.size()]);
        pw.flush();
        pw.close();
    }
}
","import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int a[]=new int[n];
            ArrayList<Integer> list=new ArrayList<>();
            ArrayList<Integer> space=new ArrayList<>();
            for(int i=0;i<n;i++)
            {
                a[i]=input.nextInt();
                if(a[i]==1)
                {
                    list.add(i);
                }
                else
                {
                    space.add(i);
                }
            }
            int pre[]=new int[space.size()];
            for(int i=0;i<list.size();i++)
            {
                if(i==0)
                {
                    int min=Integer.MAX_VALUE;
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=Math.abs(list.get(i)-space.get(j));
                        min=Math.min(min,pre[j]);
                        pre[j]=min;
                    }
                }
                else
                {
                    int arr[]=new int[space.size()];
                    for(int j=0;j<i;j++)
                    {
                        arr[j]=Integer.MAX_VALUE;
                    }

                    int min=Integer.MAX_VALUE;
                    for(int j=i;j<space.size();j++)
                    {
                        int v=Math.abs(list.get(i)-space.get(j));
                        v+=pre[j-1];
                        arr[j]=v;
                        min=Math.min(min,v);
                        arr[j]=min;
                    }
                    for(int j=0;j<space.size();j++)
                    {
                        pre[j]=arr[j];
                    }
                }
            }
            out.println(pre[space.size()-1]);
        }
        out.close();
    }
    
}
",0,Non-plagiarised
1097b326,b45d28b2,"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.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MinimumGridPath {
	
	public static void main(String[] args) throws IOException {
		FastIO in = new FastIO(System.in);
		
		int t = in.nextInt();
		while (t-- > 0) {
			int n = in.nextInt();
			long[] c = new long[n];
			long[] sums = new long[n];
			long[] mins = new long[n];
			
			for (int i = 0; i < n; i++) c[i] = in.nextInt();
			
			sums[0] = mins[0] = c[0];
			sums[1] = mins[1] = c[1];
			for (int i = 2; i < n; i++) {
				sums[i] = sums[i-2] + c[i];
				mins[i] = Math.min(mins[i-2], c[i]);
			}
			
			long ans = Long.MAX_VALUE;
			for (int i = 1; i < n; i++) {
				ans = Math.min(ans, (n - (long) Math.ceil((double) (i+1) / 2)) * mins[i] + (n - (i+1) / 2) * mins[i-1] + sums[i] + sums[i-1]);
			}
			
			System.out.println(ans);
		}
		
		in.close();
	}
	
	
}
",0,Non-plagiarised
8d9871a9,eb6cfca7,"import java.util.*;

public class Main {
	static Scanner scan = new Scanner(System.in);

	static int[] readArray(int[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextInt();
		return x;
	}

	static long[] readArray(long[] x) {
		for(int i=0; i<x.length; ++i) x[i] = scan.nextLong();
		return x;
	}


	

	public static void main(String[] args) {
		int t = scan.nextInt();
		for(int it=0; it<t; ++it) {
			int n = scan.nextInt();
			long[] aa = readArray(new long[n]);

			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
		}
	}
}
","import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Main {

	public Main() throws FileNotFoundException {

//		File file = Paths.get(""input.txt"").toFile();
//		if (file.exists()) {
//			System.setIn(new FileInputStream(file));
//		}
		long t = System.currentTimeMillis();

		InputReader reader = new InputReader();

		int ttt = reader.nextInt();

		for (int tt = 0; tt < ttt; tt++) {
			int n=reader.nextInt();
			
			long[] s=new long[n];
			for(int i=0;i<n;i++) {
				s[i]=reader.nextLong();
			}
			
			long smallest1=s[0];
			long smallest2=s[1];
			long val=n*s[0]+n*s[1];
			
			int left1=n-1;
			int left2=n-1;
			long base=s[0]+s[1];
			for(int i=2;i<n;i++) {
				if(i%2==0) {
					//left1
					val=Math.min(val, base+left2*smallest2+left1*s[i]);
					base+=s[i];
					smallest1=Math.min(smallest1, s[i]);
					left1--;
				}else {
					val=Math.min(val, base+left1*smallest1+left2*s[i]);
					base+=s[i];
					smallest2=Math.min(smallest2, s[i]);
					left2--;
					//left2
				}
			}
			

			System.out.println(val);
		}

	}

	

	public static void main(String[] args) throws FileNotFoundException {
		new Main();
	}

}
",0,Non-plagiarised
11d91f31,eea69e7f,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;

public class ArmChairs {
    static final Random random = new Random();

    

    

    

    public static void main(String[] args) {
        FastReader fs = new FastReader();
        int t = 1;

        for (int z = 0; z < t; z++) {
            int n = fs.nextInt();
            List<Integer> empty = new ArrayList<>();
            List<Integer> chairs = new ArrayList<>();
            for(int i = 0; i < n; i++) {
                int status = fs.nextInt();
                if(status == 1) chairs.add(i+1);
                else empty.add(i+1);
            }
            int[][] dp = new int[empty.size() + 1][chairs.size() + 1];
            dp[0][0] = 0;
            for(int i = 1; i <= chairs.size(); i++) dp[0][i] = (int)3e+8;
            for(int i = 1; i <= empty.size(); i++) {
                for(int j = 1; j <= chairs.size(); j++) {
                    // Shift jth person to ith chair
                    dp[i][j] = dp[i-1][j-1] + Math.abs(empty.get(i-1) - chairs.get(j-1));
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j]);
                }
                //System.out.println(i + "" "" + Arrays.toString(dp[i]));
            }
            //System.out.println(empty.size() + "" "" + chairs.size());
            System.out.println(dp[empty.size()][chairs.size()]);
        }
    }
}
","import java.util.*;

public class Solution {
	
	public static int minMoves(int[] input) {
		List<Integer> people = new ArrayList<Integer>();
		List<Integer> chairs = new ArrayList<Integer>();
		
		for (int i = 0; i < input.length; i++) {
			if (input[i] == 1) {
				people.add(i);
			} else {
				chairs.add(i);
			}
		}
		
		int[] memo = new int[chairs.size() + 1];
		

		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
			int prev = memo[p];
			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
			for (int c = p + 1; c <= chairs.size(); c++) {
				int tmp = memo[c];
				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
				prev = tmp;
			}
		}
		return memo[memo.length - 1];
	}
	
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] input = new int[n];
		for (int i = 0; i < n; i++) {
			input[i] = sc.nextInt();
		}
		
		System.out.println(Solution.minMoves(input));
		
	}
}
",0,Non-plagiarised
bf0df1d5,ea899386,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import java.io.IOException;

public class C_Phoenix_and_Towers {
    

    public static class Pair implements Comparable<Pair> {
        int id, h;

        public Pair(int id, int h) {
            this.id = id;
            this.h = h;
        }

        
    }

    public static void main(String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        int t = sc.nextInt();

        while (t-- > 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int x = sc.nextInt();
            int tow[] = new int[n];
            int ans[] = new int[n];
            PriorityQueue<Pair> pq = new PriorityQueue<>();
            for (int i = 0; i < n; i++) {
                tow[i] = sc.nextInt();
            }
            for (int i = 0; i < m; i++) {
                ans[i] = i + 1;
                pq.add(new Pair(i + 1, tow[i]));
            }
            for (int i = m; i < n; i++) {
                Pair p = pq.poll();
                p.h = p.h + tow[i];
                ans[i] = p.id;
                pq.add(p);
            }
            System.out.println(""YES"");
            for (int i = 0; i < n; i++) {
                System.out.print(ans[i] + "" "");
            }
            System.out.println();
        }
    }
}
","import java.io.*;
import java.util.*;
 
public class Codeforces {
	public static class Tower implements Comparable<Tower>{
		int val;
		int index;
		public Tower(int ind, int v) {
			val = v;
			index = ind;
		}
		
	}
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int cases = Integer.parseInt(br.readLine());
		while(cases-- > 0) {
			String[] str = br.readLine().split("" "");
			int n = Integer.parseInt(str[0]);
			int m = Integer.parseInt(str[1]);
			int x = Integer.parseInt(str[2]);
			int[] h = new int[n];
			str = br.readLine().split("" "");
			for(int i=0; i<n; i++) {
				h[i] = Integer.parseInt(str[i]);
			}
			PriorityQueue<Tower> q = new PriorityQueue<>(m);
			int[] ans = new int[n];
			for(int i=0; i<m; i++) {
				q.add(new Tower(i, h[i]));
				ans[i] = i;
			}
			for(int i=m; i<n; i++) {
				Tower lowest = q.poll();
				lowest.val += h[i];
				ans[i] = lowest.index;
				q.add(lowest);
			}
			System.out.println(""YES"");
			for(int i=0; i<n; i++) {
				System.out.print((ans[i]+1) + "" "");
			}
			System.out.println();
		}
	}
}
",1,Plagiarised
1b372750,fdd41565,"import java.io.*;
import java.util.*;
import java.math.BigInteger;
import java.util.InputMismatchException;

public class Main {
	static PrintWriter out;
	static Reader in;
	public static void main(String[] args) throws IOException {
		input_output();
		Main solver = new Main();
		solver.solve();
		out.close();

		out.flush();
	} 

	static long INF = (long)1e18;
	static int MAXN = (int)1e5 + 5;
	static int MOD = (int)1e9 + 7;
	static int q, t, n, m, k;
	static double pi = Math.PI;

	void solve() throws IOException {
		t = in.nextInt();
		

		while (t --> 0) {
			n = in.nextInt();

			String[] arr = new String[n];
			for (int i = 0; i < n; i++) {
				arr[i] = in.next();
			}

			int ans = 0;
			for (int i = 0; i < 26; i++) {
				List<Integer> list = new ArrayList<>();
				for (int j = 0; j < n; j++) {
					int tmp = 0;
					for (int x = 0; x < arr[j].length(); x++) {
						if (arr[j].charAt(x)-'a' == i) tmp++;
						else tmp--;
					}

					list.add(tmp);
				}

				Collections.sort(list);
				int sum = 0, tmpAns = 0;
				for (int j = n-1; j >= 0; j--) {
					if (sum + list.get(j) > 0) {
						tmpAns++;
						sum += list.get(j);
					} else break;
				}
				ans = Math.max(ans, tmpAns);
			}

			out.println(ans);
		}	
	}


	
	static void input_output() throws IOException {
		File f = new File(""in.txt"");
		if (f.exists() && !f.isDirectory()) {
			in = new Reader(new FileInputStream(""in.txt""));
		} else in = new Reader();
		f = new File(""out.txt"");
		if (f.exists() && !f.isDirectory()) {
			out = new PrintWriter(new File(""out.txt""));
		} else out = new PrintWriter(System.out);
	}
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
     FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0)
     {
      Solve solve=new Solve();
      t--;
      int n=s.nextInt();
      String str[]=new String[n];
      for(int i=0;i<n;i++)
      str[i]=s.nextLine();
      char array[]=new char[]{'a','b','c','d','e'};
      int arr[]=new int[n];
      int ans=0;
      for(int i=0;i<5;i++)
      {
        Arrays.fill(arr,0);
          for(int j=0;j<n;j++)
          {
                 for(int k=0;k<str[j].length();k++)
                 {
                     if(str[j].charAt(k)==array[i])
                     arr[j]++;
                     else
                     arr[j]--;
                 }
          }
          ans=(ans>solve.solve(arr,n))?ans:solve.solve(arr,n);
      }
      System.out.println(ans);
     }
    }
}
class Solve{
    public int solve(int arr[],int n)
    {
        int ans=0;
        int sum=0;
        Arrays.sort(arr);
        for(int i=n-1;i>=0;i--)
        {
            if(sum+arr[i]>0)
            {
                sum+=arr[i];
                ans++;
            }
            else
            break;
        }
        return ans;
    }
}

",1,Plagiarised
46e9aed4,7011024d,"import java.util.*;

import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public final class Solution {
    

    public static void main(String[] args) throws Exception {
        
        Reader sc = new Reader();
        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
         
         int n=sc.nextInt();
          ArrayList<Integer> fill= new ArrayList<Integer>();
          ArrayList<Integer> unfilled= new ArrayList<>();
          for(int i=0;i<n;i++){
              int x =sc.nextInt();
              if(x==1){
                  fill.add(i);
              }else{
                  unfilled.add(i);
              }
          }
          Collections.sort(fill);
          Collections.sort(unfilled);
          
          
          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
           for(int i=0;i<fill.size()+1;i++){
              for(int j=0;j<unfilled.size()+1;j++){
                  dp[i][j]=Integer.MAX_VALUE;
              }
          }
          for(int i=0;i<unfilled.size()+1;i++){
              dp[0][i]=0;
          }
        //   for(int j=0;j<fill.size()+1;j++){
        //       dp[j][0]=0;
        //   }
         

          for(int i=1;i<fill.size()+1;i++){
              for(int j=1;j<unfilled.size()+1;j++){
                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
              }
          }
          System.out.println(dp[fill.size()][unfilled.size()]);
        //   for(int i=0;i<fill.size()+1;i++){
        //       for(int j=0;j<unfilled.size()+1;j++)
        //       {
        //           System.out.print(dp[i][j]+"" "");
        //       }
        //       System.out.println();
        //   }
         
    }




   
    }


","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
2120328e,52cd85f2,"import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static int mod=10000007;
   static StringBuilder sb=new StringBuilder();
    /* start */
       public static void main(String [] args)
    {
            int t = i();
            while(t-->0)
            {
                int n = i();
                int a[] = input(n);
                char c[] = inputC();
                ArrayList<Integer> b = new ArrayList<>();
                ArrayList<Integer> r = new ArrayList<>();
                for(int i=0;i<n;i++)
                {
                    if(c[i]=='R')
                    r.add(a[i]);
                    else 
                    b.add(a[i]);
                }
                Collections.sort(b);
                Collections.sort(r,Collections.reverseOrder());
                boolean is = true;
                int cnt = 1;
                for(int i=0;i<b.size();i++)
                {
                    if(b.get(i)<cnt)
                    {
                        is = false;
                        break;
                    }
                    cnt++;
                }
                for(int i=0;i<r.size();i++)
                {
                    if(r.get(i)>n-i)
                    {
                        is = false;
                        break;
                    }
                }

                out.println(is==true?""YES"":""NO"");
            }
            out.close();
    }

    
    /* end */
     

    
    static int i() {
        return sc.nextInt();
    }

    static String s() {
        return sc.next();
    }

    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    static int[] input(int n) {
        int A[]=new int[n];
           for(int i=0;i<n;i++) {
               A[i]=sc.nextInt();
           }
        return A;
    }

    

    

    
      
     

      

     
    
     

     
    
    

    
    
    
    
    
    
    
    
    

    

    

    

    

    

    

     

      
        //pair class
        
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class PC3C {
	static PrintWriter out = new PrintWriter(System.out);
	static MyFastReaderPC3C in = new MyFastReaderPC3C();
	static long mod = (long) (1e9 + 7);

	public static void main(String[] args) throws Exception {
		
		int test = i();
		while (test-- > 0) {
			 
             int n=i();
             int[] arr=arrI(n);
             String s=string();
             
             ArrayList<Integer> lR=new ArrayList<>();

             ArrayList<Integer> lB=new ArrayList<>();
             for(int i=0;i<n;i++) {
            	
            	if(s.charAt(i)=='R') lR.add(arr[i]);
            	else lB.add(arr[i]);
            	 
             }
             
             
             Collections.sort(lB);
             Collections.sort(lR,Collections.reverseOrder());
             
             
             int k=1;
             boolean st=true;
             for(int i=0;i<lB.size();i++) {
            	 
            	 if(lB.get(i)>=k) {
            		k+=1; 
            	 }
            	 else {
            		st=false;
            		break;
            	 }
            		 
             }
             boolean st2=true;
               k=n;
               for(int i=0;i<lR.size();i++) {
            	 
            	 if(lR.get(i)>k) {
            	   st2=false;
            	   break;
            	 }
            	 else {
            		k-=1; 
            	 }
            		 
             }
               
               if(st && st2) out.print(""YES"");
               else out.print(""NO"");
             
             
			out.print(""\n"");
			out.flush();
		}
		out.close();
	}

	

	static void sort(long[] a) // check for long
	{
		ArrayList<Long> l = new ArrayList<>();
		for (long i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

	static void sort(int[] a) {
		ArrayList<Integer> l = new ArrayList<>();
		for (int i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

	

	

	

	

	

	

	

	

	

	

	// Debugging Functions Starts

	static void print(char A[]) {
		for (char c : A)
			System.out.print(c + "" "");
		System.out.println();
	}

	static void print(boolean A[]) {
		for (boolean c : A)
			System.out.print(c + "" "");
		System.out.println();
	}

	static void print(int A[]) {
		for (int a : A)
			System.out.print(a + "" "");
		System.out.println();
	}

	static void print(long A[]) {
		for (long i : A)
			System.out.print(i + "" "");
		System.out.println();

	}

	static void print(ArrayList<Integer> A) {
		for (int a : A)
			System.out.print(a + "" "");
		System.out.println();
	}

	// Debugging Functions END
	// ----------------------
	// IO FUNCTIONS STARTS
	

	public static Map<Character, Integer> mapSortByValue(Map<Character, Integer> hm) {
		// Create a list from elements of HashMap
		List<Map.Entry<Character, Integer>> list = new LinkedList<Map.Entry<Character, Integer>>(hm.entrySet());

		// Sort the list
		Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
			
		});

		// put data from sorted list to hashmap
		Map<Character, Integer> temp = new LinkedHashMap<Character, Integer>();
		for (Map.Entry<Character, Integer> aa : list) {
			temp.put(aa.getKey(), aa.getValue());
		}
		return temp;
	}
	static String string() {
		return in.nextLine();
	}

	static int i() {
		return in.nextInt();
	}

	static long l() {
		return in.nextLong();
	}

	static int[] arrI(int N) {
		int A[] = new int[N];
		for (int i = 0; i < N; i++) {
			A[i] = in.nextInt();
		}
		return A;
	}

	

}


",0,Non-plagiarised
13441e8f,2ebeae13,"import java.util.*;

public class Armchairs {

	public static int findMinTime(List<Integer> zeros, List<Integer> ones) {
		if (ones.size() == 0)
			return 0;
		int oneSize = ones.size();
		int zeroSize = zeros.size();
		int [][] time = new int [oneSize + 1][zeroSize + 1];
		for (int i=1; i<=oneSize; i++) {
			time[i][i] = time[i - 1][i - 1] + Math.abs(ones.get(i - 1) - zeros.get(i - 1));
			for (int j=i+1; j<=zeroSize; j++) {
				time[i][j] = Math.min(time[i][j - 1], time[i - 1][j - 1] + 
					Math.abs(ones.get(i - 1) - zeros.get(j - 1)));
			}
		}
		return time[oneSize][zeroSize];
	}

	public static void main (String [] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		List<Integer> zeros = new ArrayList<>();
		List<Integer> ones = new ArrayList<>();
		for (int i=0; i<n; i++) {
			int number= sc.nextInt();
			if (number == 1)
				ones.add(i);
			else
				zeros.add(i);
		}
		System.out.println(findMinTime(zeros, ones));
	}
}
","import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer;
import java.util.*;
public class codeforcesD{
    
    public static long dp[][];
    public static List<Integer> list1,list0;
   public static void main(String args[]){
        FastReader sc=new FastReader();
        int n=sc.nextInt();
        list1=new ArrayList<>();
        list0=new ArrayList<>();
        for(int i=0;i<n;i++){
           int a=sc.nextInt();
           if(a==0){list0.add(i);}
           if(a==1){list1.add(i);}
        }
        dp=new long[list1.size()][list0.size()];
        for(int i=0;i<list1.size();i++){
          for(int j=0;j<list0.size();j++){
              dp[i][j]=-1;
            }
        }
        System.out.println(check(0,0));
       
   } 
   public static long check(int i,int j){
          if(i>=list1.size()){return 0;}
          if(j>=list0.size()){return Integer.MAX_VALUE;}
          if(dp[i][j]!=-1){return dp[i][j];}
          dp[i][j]=Math.min(check(i+1,j+1)+(long)Math.abs(list1.get(i)-list0.get(j)),check(i,j+1));
         return dp[i][j];
     }
}
",0,Non-plagiarised
1162c08f,eea69e7f,"import java.util.*;

public class CodeForces1525C{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.util.*;

public class Solution {
	
	public static int minMoves(int[] input) {
		List<Integer> people = new ArrayList<Integer>();
		List<Integer> chairs = new ArrayList<Integer>();
		
		for (int i = 0; i < input.length; i++) {
			if (input[i] == 1) {
				people.add(i);
			} else {
				chairs.add(i);
			}
		}
		
		int[] memo = new int[chairs.size() + 1];
		

		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
			int prev = memo[p];
			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
			for (int c = p + 1; c <= chairs.size(); c++) {
				int tmp = memo[c];
				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
				prev = tmp;
			}
		}
		return memo[memo.length - 1];
	}
	
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] input = new int[n];
		for (int i = 0; i < n; i++) {
			input[i] = sc.nextInt();
		}
		
		System.out.println(Solution.minMoves(input));
		
	}
}
",0,Non-plagiarised
c9da41af,f59d9b6e,"import java.util.*;
import java.lang.*;
import java.io.*;



public class Main {
	static {
		try {
			System.setIn(new FileInputStream(""input.txt""));
			System.setOut(new PrintStream(new FileOutputStream(""output.txt"")));
		} catch (Exception e) {}
	}
	void solve() {
		int n = in.nextInt();

		ArrayList<Edge>[] graph = new ArrayList[n + 1];
		for (int i = 0; i < n; i++) {
			graph[i] = new ArrayList<Edge>();
		}

		for (int i = 0; i < n - 1; i++) {
			int u = in.nextInt();
			int v = in.nextInt();
			v--; u--;
			graph[u].add(new Edge(v, i));
			graph[v].add(new Edge(u, i));
		}

		int[] res = new int[n - 1];

		for (int i = 0; i < n; i++) {
			if (graph[i].size() > 2) {
				out.append(""-1\n"");
				return;
			}
		}

		int start = -1;
		for (int i = 0; i < n; i++) {
			if (graph[i].size() == 1) {
				start  = i;
				break;
			}
		}

		int currNode = start;
		int prevNode = -1;
		int weight = 2;

		while (true) {
			ArrayList<Edge> edges = graph[currNode];
			Edge next = edges.get(0);
			if (next.node == prevNode) {
				if (edges.size() == 1) {
					break;
				}
				next = edges.get(1);
			}
			res[next.index] = weight;
			weight = 5 - weight;
			prevNode = currNode;
			currNode = next.node;
		}

		for (int i = 0; i < n - 1; i++) {
			out.append(res[i] + "" "");
		}
		out.append(""\n"");
	}

	public static void main (String[] args) {
		// Its Not Over Untill I Win - Syed Mizbahuddin
		Main sol = new Main();
		int t = 1;
		t = in.nextInt();
		while (t-- != 0) {
			sol.solve();
		}
		System.out.print(out);
	}

	

	

	void print(int s) {
		System.out.print(s);
	}

	

	

	

	


	static FastReader in;
	static StringBuffer out;
	final int MAX;
	final int MIN;
	int mod ;
	Main() {
		in = new FastReader();
		out = new StringBuffer();
		MAX = Integer.MAX_VALUE;
		MIN = Integer.MIN_VALUE;
		mod = (int)1e9 + 7;
	}
}


class Edge {
	int node, index;
	Edge(int node, int index) {
		this.node = node;
		this.index = index;
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef{
    public static class Edge{
        int node;
        int index;
        Edge(int node, int index){
            this.node = node;
            this.index = index;
        }
    }
    static Scanner scn = new Scanner(System.in);
	public static void main (String[] args) throws java.lang.Exception{
		int t = scn.nextInt();
		while(t-->0){
		    solve();
		}
	}
	public static void solve(){
	    int n = scn.nextInt();
	    ArrayList<Edge>[]graph = new ArrayList[n];
	    for(int i = 0; i < n; i++){
	        graph[i] = new ArrayList<>();
	    }
	    for(int i = 0; i < n - 1; i++){
	        int u = scn.nextInt() - 1;
	        int v = scn.nextInt() - 1;
	        graph[u].add(new Edge(v, i));
	        graph[v].add(new Edge(u, i));
	    }
	    int start = 0;
	    for(int i = 0; i < n; i++){
	        if(graph[i].size() > 2){
	            System.out.println(""-1"");
	            return;
	        }else if(graph[i].size() == 1){
	            start = i;
	        }
	    }
	    int[]weight = new int[n - 1];
	    int prevNode = -1, curNode = start, curWeight = 2;
	    while(true){
	        ArrayList<Edge>edges = graph[curNode];
	        Edge next = edges.get(0);
	        if(next.node == prevNode){
	            if(edges.size() == 1){
	                break;
	            }else{
	                next = edges.get(1);
	            }
	        }
	        weight[next.index] = curWeight;
	        prevNode = curNode;
	        curNode = next.node;
	        curWeight = 5 - curWeight;
	    }
	    for(int i = 0; i < n - 1; i++){
	        System.out.print(weight[i]);
	        System.out.print("" "");
	    }
	    System.out.println();
	}
}
",1,Plagiarised
d6fb3b9e,f7a0ea6d,"import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
","import java.util.*;

public class Solution {
	
	private static Scanner in = new Scanner(System.in);
	
	public static void main(String args[]) {
		
		int t = in.nextInt();
		
		while(t-->0) {
			solution();
		}
	}
	
	private static void solution() {
		
		int ans=0;
		int n = in.nextInt();
		String s[] = new String[n];
		int occurance[][] = new int[n][5];
		for(int i=0;i<n;i++) {
			s[i] = in.next();
			for(int j=0;j<s[i].length();j++) {
				occurance[i][s[i].charAt(j)-'a']++;
			}
		}
		
//		for(int i=0;i<n;i++)
//		{
//			for(int j=0;j<5;j++)
//				System.out.println(occurance[i][j]);
//			System.out.println();
//		}
		
		for(int i=0;i<5;i++) {
			int arr[] = new int[n];
			for(int j=0;j<n;j++) {
				arr[j] = s[j].length() - (2 * occurance[j][i]);
			}
			Arrays.sort(arr);
			
//			for(int j=0;j<n;j++)
//				System.out.println(arr[j]);
			
			int temp=0;
			int count=0;
			for(int j=0;j<n;j++) {
				if(temp+arr[j] < 0)
				{
					count++;
					temp += arr[j];
				}
				else 
					break;
			}
			ans = Math.max(ans, count);
		}
		System.out.println(ans);
	}
}
",0,Non-plagiarised
548ffb07,9ab3c0e1,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	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.util.*;

public class d {

    public static Scanner sc = new Scanner(System.in);
    public static final int MOD = 998244353;
    int []f; int [] lf;

    public static int mul(int a, int b) {
        return (int)((long)a * (long)b % MOD);
    }

    public static int ksm(int a, int n) {
        int ans = 1;
        while(n > 0) {
            if((n & 1) == 1)
                ans = mul(a, ans);
            a = mul(a, a);
            n >>= 1;
        }
        return ans;
    }

    public int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(lf[n - k], lf[k]));
    }

    public static int inv(int a) {
        return ksm(a, MOD - 2);
    }

    public void solve() {
        int n = sc.nextInt();
        int k = sc.nextInt();
        f = new int[n + 42];
        lf = new int[n + 42];
        f[0] = lf[0] = 1;
        for(int i = 1; i < f.length; i++) {
            f[i] = mul(f[i  - 1], i);
            lf[i] = mul(lf[i - 1], inv(i));
        }

        int[] events = new int[2 * n];
        for(int i = 0; i < n; i++) {
            int le = sc.nextInt();
            int ri = sc.nextInt();
            events[i] = le * 2;
            events[i + n] = ri * 2 + 1;
        }

        Arrays.sort(events);
        int ans = 0, balance = 0;
        for(int r = 0; r < 2 * n;) {
            int l = r;
            while(r < 2 * n && events[l] == events[r]) ++r;
            int added = r - l;
            if(events[l] % 2 == 0) {
                ans += C(balance + added, k);
                if(ans >= MOD) ans -= MOD;
                ans += MOD - C(balance, k);
                if(ans >= MOD) ans -= MOD;
                balance += added;
            }
            else balance -= added;
        }
        sc.close();
        System.out.println(ans);
    }

    public static void main(String[] args) {
        (new d()).solve();
    }
}
",1,Plagiarised
4a570de6,6c4ac8d3,"import java.io.*;
import java.lang.*;
import java.util.*;
public class c
{

 

public static int[] ia(int n)
{
    int ar[]=new int[n];
    return ar;
}


static class pair implements Comparable<pair>{
    int ht;
    int id;
    pair(int ht, int id)
{
    this.ht=ht;
    this.id=id;
}

}
public static void main(String args[]) throws java.lang.Exception
{
FastScanner sc=new FastScanner();
 int t=sc.ni();
while(t-->0)
{
    int n=sc.ni();
    int m=sc.ni();
    int x=sc.ni();
    int ar[]=ia(n);
for(int i=0;i<n;i++)
{
ar[i]=sc.ni();
}
System.out.println(""YES"");
PriorityQueue<pair> pq=new PriorityQueue<>();
 for(int i=0;i<m;i++)
 {
pq.add(new pair(0,i+1));
 }                     
 int i=0;
 while(i<n)
 {
     pair pp=pq.remove();
pp.ht+=ar[i];
System.out.print(pp.id+"" "");
pq.add(pp);
i++;
 }   
System.out.println();
}
}
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.io.*;


public class ieee1{

    
    public static void main(String[] args) {
           Scanner scn=new Scanner(System.in);
           int t=scn.nextInt();
           while(t-->0){
               HashMap<Integer,Integer> map=new HashMap<>();
              
               int b=scn.nextInt();
               int m=scn.nextInt();
               int x=scn.nextInt();
               int[] arr=new int[b];
               PriorityQueue<Node> pq=new PriorityQueue<>(new pqc());
               for(int i=0;i<b;i++){
                   int ele=scn.nextInt();
                   
                  
                   arr[i]=ele;
               }
               for(int i=1;i<=m;i++){
                   pq.add(new Node(i,0));
               }
               System.out.println(""YES"");
               for(int i=0;i<arr.length;i++){
                   int ele=arr[i];
                   Node n=pq.poll();
                   System.out.print(n.ind+"" "");
                   n.data+=ele;
                   pq.add(n);
               }
               System.out.println();
              
              
    }
}
    public static class Node{
        int ind;
        int data;
        Node(int ind,int data){
            this.ind=ind;
            this.data=data;
        }
    }
    public static class pqc implements Comparator<Node>{
        
        
    }

}
",0,Non-plagiarised
722e318f,ff1fc018,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class TaskB {

    static long mod = 1000000007;
    static FastScanner scanner;

    static final StringBuilder result = new StringBuilder();

    public static void main(String[] args) {
        // 2 : 1000000000
        scanner = new FastScanner();
        int T = scanner.nextInt();
        for (int t = 0; t < T; t++) {
            solve(t + 1);
            result.append(""\n"");
        }
        System.out.println(result);
    }

    static void solve(int t) {
        int n = scanner.nextInt();
        int[] a = scanner.nextIntArray(n);
        String s = scanner.nextToken();

        List<Integer> blue = new ArrayList<>();
        List<Integer> red = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'B') {
                blue.add(a[i]);
            } else {
                red.add(a[i]);
            }
        }
        Collections.sort(blue);
        Collections.sort(red);
        for (int i = 0; i < blue.size(); i++) {
            if (blue.get(i) < i + 1) {
                result.append(""NO"");
                return;
            }
        }
        for (int i = 0; i < red.size(); i++) {
            if (red.get(i) > i + 1 + blue.size()) {
                result.append(""NO"");
                return;
            }
        }
        result.append(""YES"");
    }

    

    

    

    

    
}
","import java.util.*;

public class mentor1 {
    public static boolean solve(int n, String color, int[] arr){
        List<Integer> Barr = new ArrayList<Integer>();
        List<Integer> Rarr = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            if(color.charAt(i) == 'B')Barr.add(arr[i]);
            else Rarr.add(arr[i]);
        }
        Barr.sort(Comparator.naturalOrder());
        Rarr.sort(Comparator.reverseOrder());
        for (int i = 0; i < Barr.size(); i++) {
            if(Barr.get(i)< i + 1)return false;
        }
        for (int i = 0; i < Rarr.size(); i++) {
            int expect = n-i;
            if(Rarr.get(i) > expect)return false;
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        for (int i = 0; i < n; i++) {
            int m = input.nextInt();
            int[] arr = new int[m];
            for(int j = 0;j<m; j++)arr[j] = input.nextInt();
            String color = input.next();
            if(solve(m,color,arr)) System.out.println(""YES"");
            else System.out.println(""NO"");
        }
    }
}
",0,Non-plagiarised
03b3c5af,d74028ea,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;


public class TaskA {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        int testCount = 1;
        testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Solver {
        
        public Pair[] pairs;
        ArrayList<ArrayList<Integer>> adj;
        long[][] dp;
        public void dfs(int vertex,int parent){
//            dp[0][vertex] = dp[1][vertex] = 0;
            for(int i=0;i<adj.get(vertex).size();i++){
                if((int)adj.get(vertex).get(i)!=parent){
                    int curVer = adj.get(vertex).get(i);
                    dfs(curVer,vertex);
                    dp[0][vertex] += Math.max( (dp[0][curVer] + Math.abs(pairs[curVer].f - pairs[vertex].f) )
                            , (dp[1][curVer] + Math.abs(pairs[curVer].s - pairs[vertex].f)) );
                    dp[1][vertex] += Math.max( (dp[0][curVer] + Math.abs(pairs[curVer].f - pairs[vertex].s) )
                            , (dp[1][curVer] + Math.abs(pairs[curVer].s - pairs[vertex].s)) );
                }
            }
        }
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt();
            pairs = new Pair[n];
            adj = new ArrayList<>();
            for(int i=0;i<n;i++){
                pairs[i] = new Pair(in.nextInt(),in.nextInt());
                adj.add(new ArrayList<>());
            }
            for(int i=0;i<n-1;i++){
                int u = in.nextInt(),v = in.nextInt();
                adj.get(u-1).add(v-1);
                adj.get(v-1).add(u-1);
            }
            dp = new long[2][n];
            dfs(0,-1);
//            out.println(Arrays.toString(dp[0]));
//            out.println(Arrays.toString(dp[1]));
            out.println(Math.max(dp[0][0],dp[1][0]));
        }
    }
    static class Pair implements Comparable<Pair>{
        int f;
        int s;
        public Pair(int a,int b){
            this.f = a;
            this.s = b;
        }
        
    }
    
}
","import java.io.*;
import java.util.*;
 
public class Main {
 
  static class Task {
 
    int NN = 200005;
    int MOD = 1000000007;
    int INF = 2000000000;
    long INFINITY = 2000000000000000000L;

	int [] a;
	int [] b;
	List<Integer> [] g;
	long [][] dp;

	long rec(int node, int prev, int index) {
		if(dp[node][index] != -1){
			return dp[node][index];
		}
		long ret = 0;
		int val = index==0?a[node]:b[node];
		for(int adj: g[node]) {
			if(adj == prev) {
				continue;
			}
			ret += Math.max((long)(rec(adj, node, 0) + (long)(Math.abs(val - a[adj]))), (long)(rec(adj, node, 1) + (long)(Math.abs(val - b[adj]))));
		}
		return dp[node][index] = ret;
	}
    
    public void solve(InputReader in, PrintWriter out) {
		int t = in.nextInt();
		while(t-->0) {
			int n = in.nextInt();
			a = new int[n + 1];
			b = new int[n + 1];
			g = new ArrayList[n + 1];
			dp = new long[n + 1][2];
			for(int i=1;i<=n;++i) {
				a[i] = in.nextInt();
				b[i] = in.nextInt();
				g[i] = new ArrayList<>();
				dp[i][0] = dp[i][1] = -1;
			}
			for(int i=1;i<n;++i) {
				int u = in.nextInt();
				int v = in.nextInt();
				g[u].add(v);
				g[v].add(u);
			}
			long ans = Math.max(rec(1, -1, 0), rec(1, -1, 1));
			out.println(ans);
		}
    }
  }
 
  static void prepareIO(boolean isFileIO) {
    // long t1 = System.currentTimeMillis();
    Task solver = new Task();
    // Standard IO
    if (!isFileIO) {
      InputStream inputStream = System.in;
      OutputStream outputStream = System.out;
      InputReader in = new InputReader(inputStream);
      PrintWriter out = new PrintWriter(outputStream);
      solver.solve(in, out);
      // out.println(""time(s): "" + (1.0*(System.currentTimeMillis()-t1))/1000.0);
      out.close();
    }
    // File IO
    else {
      String IPfilePath = System.getProperty(""user.home"") + ""/Downloads/ip.in"";
      String OPfilePath = System.getProperty(""user.home"") + ""/Downloads/op.out"";
      InputReader fin = new InputReader(IPfilePath);
      PrintWriter fout = null;
      try {
        fout = new PrintWriter(new File(OPfilePath));
      } catch (FileNotFoundException e) {
        e.printStackTrace();
      }
      solver.solve(fin, fout);
      // fout.println(""time(s): "" + (1.0*(System.currentTimeMillis()-t1))/1000.0);
      fout.close();
    }
  }
 
  public static void main(String[] args) {
    prepareIO(false);
  }
 
  
}
",0,Non-plagiarised
4fb09c5f,c57a973e,"import java.io.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;
import java.util.stream.Collectors;

public class Trial {
    public static void main(String[] args) throws IOException {

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int q = sc.nextInt();
        while (q-- > 0) {
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] arr = new int[k];
            int[] t = new int[k];
            HashMap<Integer, Integer> hm = new HashMap<>();
            for (int i = 0; i < k; i++) {
                arr[i] = sc.nextInt() - 1;
            }

            for (int i = 0; i < k; i++) {
                t[i] = sc.nextInt();
                hm.put(arr[i], t[i]);
            }

            int[] left = new int[n];
            int[] right = new int[n];
            left[0] = hm.getOrDefault(0, -1);
            right[n - 1] = hm.getOrDefault(n - 1, -1);
            for (int i = 1; i < n; i++) {
                if (hm.containsKey(i)) {
                    if (left[i - 1] < 0) {
                        left[i] = hm.get(i);
                    } else {
                        left[i] = Math.min(hm.get(i), left[i - 1] + 1);
                    }
                } else {
                    left[i] = left[i - 1] < 0 ? -1 : left[i - 1] + 1;
                }
            }
            for (int i = n - 2; i >= 0; i--) {
                if (hm.containsKey(i)) {
                    if (right[i + 1] < 0) {
                        right[i] = hm.get(i);
                    } else {
                        right[i] = Math.min(hm.get(i), right[i + 1] + 1);
                    }
                } else {
                    right[i] = right[i + 1] < 0 ? -1 : right[i + 1] + 1;
                }
            }
            for (int i = 0; i < n; i++) {
                if (left[i] < 0) {
                    pw.print(right[i] + "" "");
                } else if (right[i] < 0) {
                    pw.print(left[i] + "" "");
                } else {
                    pw.print(Math.min(left[i], right[i]) + "" "");
                }
            }
            pw.println();
        }
        pw.flush();
        pw.close();
    }

    // inclusive
    

    

    
}
","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();
		}

    }

    
}
",0,Non-plagiarised
9e7551da,f0e13442,"import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
// نورت الكود يا كبير اتفضل

// يا رب Accepted
public class InterestingStory {
    private static int[] freq;
    private static String[] strs;

    private static int[] countAlpha(char alpha) {

        int[] count = new int[strs.length];

        for (int i = 0; i < strs.length; i++)
            for (char c : strs[i].toCharArray())
                count[i] += c == alpha ? -1 : 1;

        return count;
    }

    private static int solve(char alpha) {
        int[] res = countAlpha(alpha);

        Arrays.sort(res);

        int freqSum = 0;
        for (int j : freq) freqSum += j;

        freqSum -= freq[alpha - 'a'];


        int k = res.length - 1;

        //System.out.println(freq[alpha - 'a'] + "" "" + freqSum);

        while (k >= 0 && freq[alpha - 'a'] <= freqSum) {
            //System.out.println(freq[alpha - 'a'] + "" "" + freqSum);
            freqSum -= res[k--];
        }
        return k + 1;
    }

    public static void main(String[] args) {
        FastReader in = new FastReader();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int t = in.nextInt();
        while (t-- > 0) {

            int n = in.nextInt();
            freq = new int[7];
            strs = new String[n];

            for (int i = 0; i < n; i++)
                strs[i] = in.nextLine();

            for (String str : strs)
                for (char c : str.toCharArray())
                    freq[c - 'a']++;

            int max = 0;

//            int x = solve('d');
//            out.println(x);

            for (char c = 'a'; c < 'f'; c++)
                max = Math.max(max, solve(c));

//            int[] arr = countAlpha('d');
//            Arrays.sort(arr);
//
//            for (int i : arr)
//                out.println(i);


            out.println(max);

        }

        out.close();
    }

    
}
","import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
// نورت الكود يا كبير اتفضل

// يا رب Accepted
public class InterestingStory {
    private static int[] freq;
    private static String[] strs;

    private static int[] countAlpha(char alpha) {

        int[] count = new int[strs.length];

        for (int i = 0; i < strs.length; i++)
            for (char c : strs[i].toCharArray())
                count[i] += c == alpha ? -1 : 1;

        return count;
    }

    private static int solve(char alpha) {
        int[] res = countAlpha(alpha);

        Arrays.sort(res);

        int freqSum = 0;
        for (int j : freq) freqSum += j;

        freqSum -= freq[alpha - 'a'];


        int k = res.length - 1;
        

        while (k >= 0 && freq[alpha - 'a'] <= freqSum)
            freqSum -= res[k--];
        
        return k + 1;
    }

    public static void main(String[] args) {
        FastReader in = new FastReader();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int t = in.nextInt();
        while (t-- > 0) {

            int n = in.nextInt();
            freq = new int[5];
            strs = new String[n];

            for (int i = 0; i < n; i++)
                strs[i] = in.nextLine();

            for (String str : strs)
                for (char c : str.toCharArray())
                    freq[c - 'a']++;

            int max = 0;

            for (char c = 'a'; c < 'f'; c++)
                max = Math.max(max, solve(c));


            out.println(max);

        }

        out.close();
    }

    
}
",1,Plagiarised
317baeaf,e17c5159,"import java.util.*;
import java.io.*;

public class Main {
  public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		StringTokenizer st;

		int t = Integer.parseInt(br.readLine());
		while (t --> 0) {
			int n = Integer.parseInt(br.readLine());
			String a = br.readLine();
			String b = br.readLine();
			int alit = 0;
			int blit = 0;

			int ans = Integer.MAX_VALUE;

			for (int i = 0; i < n; i++) {
				if (a.charAt(i) == '1') alit++;
				if (b.charAt(i) == '1') blit++;
			}

			if (alit == blit) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) != b.charAt(i)) count++;
				ans = Math.min(count, ans);
			}
			
			if (alit == n - blit + 1) {
				int count = 0;
				for (int i = 0; i < n; i++)
					if (a.charAt(i) == b.charAt(i)) count++;
				ans = Math.min(ans, count);
			}

			if (ans == Integer.MAX_VALUE) {
				pw.println(""-1"");
			} else {
				pw.println(ans);
			}
		}

		pw.close();
  }
}
","import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int t=Integer.valueOf(sc.nextLine());
        while (t-->0){
            int n=Integer.valueOf(sc.nextLine());
            int ans=100001;
            String a=sc.nextLine();
            String b=sc.nextLine();
            HashSet<Integer> listb=new HashSet<>();
            ArrayList<Integer> lista=new ArrayList<>();
            for (int i=0;i<n;i++){
                if(a.charAt(i)=='1') lista.add(i);
                if(b.charAt(i)=='1') listb.add(i);
            }
            int num=0;
            for (int i=0;i<lista.size();i++){
                if(listb.contains(lista.get(i))) num++;
            }
            //第一种情况
            if(lista.size()==listb.size()){
                ans=Math.min(ans,(listb.size()-num)*2);
            }
            //第二种情况 n-lista.size() listb.size()-num
            if(listb.size()-(n-lista.size())==1){
                ans=Math.min(ans,(num-1)*2+1);
            }
            System.out.println((ans==100001)?-1:ans);
        }
    }
}
",0,Non-plagiarised
6f393cfe,b185d034,"import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        try{
            int t = Integer.parseInt(br.readLine());
            while(t-->0){
                int n = Integer.parseInt(br.readLine());
                int lst[][] = new int[n][5];
                for(int i=0; i<n; i++){
                    String s = br.readLine();
                    for(int j=0; j<s.length(); j++){
                        lst[i][s.charAt(j)-'a']++;
                    }
                }
                int fans = Integer.MIN_VALUE;
                for(int i=0; i<5; i++){
                    int val[] = new int[n];
                    for(int k=0; k<n; k++){
                        int sum = 0;
                        for(int j=0; j<5; j++){
                            if(i==j){
                                sum += lst[k][j];
                            }else{
                                sum -= lst[k][j];
                            }
                        }
                        val[k] = sum;
                    }
                    Arrays.sort(val);
                    int sum = 0;
                    int ans = 0;
                    for(int x = n-1; x>=0; x--){
                        sum+=val[x];
                        if(sum>0){
                            ans++;
                        }else{
                            break;
                        }
                    }
                    fans = Math.max(fans, ans);
                }
                bw.write(fans+""\n"");
            }
            bw.flush();
        }catch(Exception e){
            return;
        }
    }
    
}
","import java.io.*;
import java.util.*;
public class A734C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        loop:while(t-->0){
            int n = scan.nextInt();
            String[] arr= new String[n];
            Integer[][] counts = new Integer[5][n];
            for(int i = 0;i<5;i++){
                for(int j = 0;j<n;j++){
                    counts[i][j] = 0;
                }
            }
            for(int i =0;i<n;i++){
                arr[i] = scan.next();
                int[] freq =new int[5];
                for(int j = 0;j<arr[i].length();j++){
                    freq[arr[i].charAt(j)-'a']++;
                }
                for(int j = 0;j<5;j++){
                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
                }
            }
            int best = 0;
            for(int i = 0;i<5;i++){
                Arrays.sort(counts[i]);
                int curr = 0;
                int extra = 0;
                for(int j = n-1;j>=0;j--){
                    extra+=counts[i][j];
                    if(extra>0)curr++;
                }
                best = Math.max(best,curr);
            }
            System.out.println(best);

        }
    }
    
}
",0,Non-plagiarised
9291ca83,d6fb3b9e,"import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Practice {
    static HashMap<String, Integer> map = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            int[][] occurances = new int[5][n];
            for(int i=0;i<n;i++){
                String s = sc.next();
                int[] count = new int[5];
                int len = s.length();
                for(int j=0;j<s.length();j++){
                    count[s.charAt(j)-'a']++;
                }
                for(int j=0;j<5;j++){
                    occurances[j][i] = count[j] - (len-count[j]);
                }
            }
            int ans = 0;
            for(int i=0;i<5;i++){
                Arrays.sort(occurances[i]);
                int tmpAns = 0; int tmpSum=0;
                for(int j=n-1;j>=0;j--){
                    tmpSum+=occurances[i][j];
                    if(tmpSum>0) tmpAns++;
                    else break;
                }
                ans = Math.max(ans, tmpAns);
            }
            System.out.println(ans);
        }
    }
}
","import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
",0,Non-plagiarised
b9595381,c4ca2ff3,"import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
    
static int dest1;
static int dest2;
public static void main(String args[]){
       	FastScanner in = new FastScanner();
		int test=in.nextInt();
                while(test-->0){
                    int n=in.nextInt();
                    int count[][]=new int[n][5];
                    int total[]=new int[n];
                    String words[]=new String[n];
                    for(int i=0;i<n;i++){
                        words[i]=in.next();
                        for(int j=0;j<words[i].length();j++)
                            count[i][words[i].charAt(j)-'a']++;
                        
                        total[i]=words[i].length();
                    }
                    int max=Integer.MIN_VALUE;
                   for(int i=0;i<5;i++){
                       
                      Integer ans[]=new Integer[n];
                      for(int j=0;j<n;j++){
                          ans[j]=count[j][i]-(total[j]-count[j][i]);
                      }
                      Arrays.sort(ans,Collections.reverseOrder());
                      int j=0;
                      int r=0;
                      while(j<n && r+ans[j]>0){
                          r+=ans[j];
                          j++;
                      }
                      max=Math.max(j,max);
                      
                   }
                   System.out.println(max);
                   
                    
                }
}

       



}


","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		while(t-->0) {
		    int n=sc.nextInt();
		    int freq[][]=new int[n][5];
		    int rem[][]=new int[n][5];
		    for(int i=0;i<n;i++) {
		        String str=sc.next();
		        
		        for(int j=0;j<str.length();j++) {
		            freq[i][str.charAt(j)-'a']++;
		        }
		        for(int k=0;k<5;k++) {
		            rem[i][k]=str.length()-freq[i][k];
		        }
		    }
		    
		    int ans=0;
		    for(int i=0;i<5;i++) {
		        int arr[]=new int[n];
		        for(int j=0;j<n;j++)
		        arr[j]=freq[j][i]-rem[j][i];
		        
		        Arrays.sort(arr);
		        int total=0;
		        int sum=0;
		        for(int k=n-1;k>=0;k--) {
		            if(sum+arr[k]>0) {
		                sum=sum+arr[k];
		                total++;
		            }
		            else {
		                break;
		            }
		        }
		        ans=Math.max(ans,total);
		    }
		    out.println(ans);
		    
		}
		out.flush();
		out.close();
	}
}
",0,Non-plagiarised
54e71b9b,fd16f5b0,"import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;

public class C {
	// PRIMARY VARIABLES
	private static int n, m, k, x, y;
	private static int[][] a, b;
	private static long ans;
	private static int[][] id;
	private static long[][] dp;
	private static int idf;
	private static String s, t;
	private static HashMap<Integer, ArrayList<Integer>> g;

	// CONSTANTS
	private static final int MOD = (int) 1e9 + 7;
	private static final int[] dx = { -1, 1, 0, 0 };
	private static final int[] dy = { 0, 0, -1, 1 };
	private static final int MAX = Integer.MAX_VALUE;
	private static final int MIN = Integer.MIN_VALUE;
	private static final long MAXLONG = (long) 1e18;
	private static final long MINLONG = -(long) 1e18;

	public static void main(String[] args) {
		int testCases = in.nextInt();

		id = new int[(int)1e5+10][2];
		dp = new long[(int)1e5+10][2];
		
		for (int z = 1; z <= testCases; z++) {
			initCase(z);

			n = ini();
			a = ina2d(n, 2);
			
			g = intree(n);
			
			println(Math.max(dfs(0, -1, 0), dfs(0, -1, 1)));
		}

		//Ax,  A*(B-x)

		out.flush();
		out.close();

	}
	
	private static long dfs(int u, int p, int f) {
		if (id[u][f]==idf) {
			return dp[u][f];
		}
		
		
		long ans = 0;
		
		for(int v: g.get(u)) {
			if (v==p) continue;
			
			ans += Math.max(Math.abs(a[v][1]-a[u][f])+dfs(v, u, 1), Math.abs(a[v][0]-a[u][f])+dfs(v, u, 0));
		}
		id[u][f] = idf;
		dp[u][f] = ans;
		
		return ans;
	}

	// INIT
	private static void initCase(int z) {
		idf = z;
		ans = 0;
	}

	// PRINT ANSWER
	

	

	

	// SORT SHORTCUTS - QUICK SORT TO MERGE SORT
	

	

	// INPUT SHORTCUTS

	private static int[] ina(int n) {
		int[] temp = new int[n];
		for (int i = 0; i < n; i++) {
			temp[i] = in.nextInt();
		}
		return temp;
	}

	private static int[][] ina2d(int n, int m) {
		int[][] temp = new int[n][m];
		for (int i = 0; i < n; i++) {
			temp[i] = ina(m);
		}
		return temp;
	}

	

	private static int ini() {
		return in.nextInt();
	}

	

	

	

	// PRINT SHORTCUTS
	private static void println(Object... o) {
		for (Object x : o) {
			out.write(x + """");
		}
		out.write(""\n"");
	}

	

	

	// GRAPH SHORTCUTS
	private static HashMap<Integer, ArrayList<Integer>> intree(int n) {

		HashMap<Integer, ArrayList<Integer>> g = new HashMap<>();
		for (int i = 0; i < n; i++) {
			g.put(i, new ArrayList<>());
		}

		for (int i = 0; i < n - 1; i++) {
			int u = ini() - 1;
			int v = ini() - 1;
			g.get(u).add(v);
			g.get(v).add(u);
		}

		return g;
	}

	

	

	

	

	

	

	

	// MATHS AND NUMBER THEORY SHORTCUTS
	

	

	

	// Segment Tree
	

	// DSU
	

	// KMP
	

	

	

	

	

	// LCA
	

	// Geometry
	

	// FAST INPUT OUTPUT LIBRARY
	private static InputReader in = new InputReader(System.in);
	private static PrintWriter out = new PrintWriter(System.out);

	
}
","import java.util.*;
import java.io.*;
import java.math.*;

public class Main

{ 
	 static FastReader sc=new FastReader(); 
	 static long dp[][];
	  public static void main(String[] args)
{
		   PrintWriter out=new PrintWriter(System.out);
		   //StringBuffer sb=new StringBuffer("""");
		  int ttt=1;
		  ttt =i();
	        outer :while (ttt-- > 0) 
			{
	        	int n=i();
	        	int B[][]=new int[n][2];
	        	for(int i=0;i<n;i++) {
	        		B[i][0]=i();
	        		B[i][1]=i();
	        	}
	        	ArrayList<Integer> A[]=new ArrayList[n+1];
	        	for(int i=0;i<A.length;i++) {
	        		A[i]=new ArrayList<Integer>();
	        	}
	        	int m=n-1;
	        	dp=new long[n+1][2];
	        	for(int i=0;i<=n;i++)
	        		Arrays.fill(dp[i],-1);
	        	for(int i=0;i<m;i++) {
	        		int a=i();
	        		int b=i();
	        		A[a].add(b);
	        		A[b].add(a);
	        	}
	        	System.out.println(Math.max(dfs(A, 1, -1, 0, B), dfs(A, 1, -1, 1, B)));

	        			
	        	
	        }
	        	
		
		  
		  

	     //System.out.println(sb.toString());
		     out.close();
	     
	     
	    //CHECK FOR N=1                    //CHECK FOR M=0
        //CHECK FOR N=1                    //CHECK FOR M=0
       	//CHECK FOR N=1
       	//CHECK FOR N=1
       	//CHECK FOR N=1
		        
		     
    }

	  private static long dfs(ArrayList<Integer> [] A, int i,int par,int pv,int B[][]) {
			long ans=0;
			long res=B[i-1][pv];
			if(dp[i][pv]!=-1)
				return dp[i][pv];
			for(int child : A[i]) {
				if(child!=par) {
					long op1=dfs(A, child, i, 0, B)+Math.abs(B[child-1][0]-res);
					long op2=dfs(A, child, i, 1, B)+Math.abs(B[child-1][1]-res);
					ans+=Math.max(op1, op2);
				}
			}
			return dp[i][pv]=ans;
			
		}
	 






















     static int i() {
    	 return sc.nextInt();
     }
     
       
     
     
  
  
  
      
      
      
      
     
        
     
}
",0,Non-plagiarised
2470b521,2da4b3fe,"import com.sun.security.jgss.GSSUtil;

import javax.swing.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

//ankit singh

public class Main {

   static int inf=Integer.MAX_VALUE/2;
    public static void main(String[] args) {
       Scanner input=new Scanner(System.in);
       int nn=input.nextInt();
        int a[]=new int[nn];
        ArrayList<Integer> one=new ArrayList<>();
        ArrayList<Integer> zero=new ArrayList<>();
        for (int i = 0; i <nn ; i++) {
            a[i]=input.nextInt();
            if(a[i]==1){
                one.add(i);
            }else zero.add(i);
        }
        if (one.size()==0) {
            System.out.println(0);
            return;
        }
        int n=one.size();
        int m=zero.size();
        int dp[][]=new int[n+1][m+1];
        int ans=0;
        for (int i = 1; i <=n ; i++) {
             dp[i][0]=inf;
            for (int j = 1; j <=m ; j++) {
                dp[i][j]=inf;

                //take the current
                dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]+Math.abs(one.get(i-1)-zero.get(j-1)));

                //take previos
                dp[i][j]=Math.min(dp[i][j],dp[i][j-1]);


            }
        }
        ans=inf;
        for (int i = 1; i <=m ; i++) {
            ans=Math.min(ans,dp[n][i]);
        }
        System.out.println(ans);



    }

}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class Codeforces {
	
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		FastReader sc=new FastReader();
		int n=sc.nextInt();
		int a[]=new int[n];
		ArrayList<Integer> arr0=new ArrayList<>();
		ArrayList<Integer> arr1=new ArrayList<>();
		for(int i=0;i<n;i++)
		{
		    a[i]=sc.nextInt();
		    if(a[i]==0)
		    arr0.add(i);
		    else
		    arr1.add(i);
		}
		n=arr0.size();
		int m=arr1.size();
		int dp[][]=new int[m+1][n+1];
		for(int i=0;i<=n;i++)
		{
		    dp[0][i]=0;
		}
		for(int i=1;i<=m;i++)
		{
		    dp[i][i]=dp[i-1][i-1]+Math.abs(arr0.get(i-1)-arr1.get(i-1));
		    for(int j=i+1;j<=n;j++)
		    {
		        dp[i][j]=Math.min(dp[i-1][j-1]+Math.abs(arr0.get(j-1)-arr1.get(i-1)),dp[i][j-1]);
		    }
		}
		System.out.println(dp[m][n]);
	}
}
",0,Non-plagiarised
18e2441c,24b20554,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map;
import java.util.HashMap;

public class cf1515 {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();
		solver.solve(in, out);
		out.close();
	}

	static class Task {
		public void solve(InputReader in, PrintWriter out) {
			int t = in.nextInt();
			while (t-- != 0) {
				int n = in.nextInt();
				int m = in.nextInt();
				int x = in.nextInt();
				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
				for (int i = 0; i < n; i++) {
					int j = in.nextInt();
					if (!map.containsKey(j)) {
						map.put(j, new ArrayList<Integer>());
					}
					map.get(j).add(i);
				}
				out.println(""YES"");
				int[] ans = new int[n];
				int sta = 0;
				for (int s : map.keySet()) {
					for (int i = 0; i < map.get(s).size(); i++) {
						ans[map.get(s).get(i)] = (sta++) % m + 1;
					}
				}
				for(int i=0;i<n;i++) {
					out.print(ans[i]+"" "");
				}
				out.println();
			}

		}
	}

	
}
","import java.util.*;
import java.lang.*;
public class Codeforces {
    static Scanner sr=new Scanner(System.in);
    public static void main(String[] args) throws java.lang.Exception {
        StringBuilder ans = new StringBuilder("""");
        int T = sr.nextInt();
        while (T-- > 0) {
            int n=sr.nextInt();
            int m=sr.nextInt();
            int x=sr.nextInt();
            TreeMap<Integer,ArrayList<Integer>>h=new TreeMap<>();
            for(int i=0;i<n;i++)
            {
                int a=sr.nextInt();
                if(!h.containsKey(a))
                    h.put(a,new ArrayList<>());
                h.get(a).add(i);
            }
            ans.append(""YES"");
            ans.append('\n');
            int an[]=new int[n];
            int q=0;
            for(int z:h.keySet())
            {
                for(int i=0;i<h.get(z).size();i++)
                {
                    an[h.get(z).get(i)]=(q++)%m+1;
                }
            }
            for(int i=0;i<n;i++)
                ans.append(an[i]+"" "");
            ans.append('\n');
        }
        System.out.println(ans);
    }
}
",1,Plagiarised
18e2441c,792863db,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Map;
import java.util.HashMap;

public class cf1515 {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();
		solver.solve(in, out);
		out.close();
	}

	static class Task {
		public void solve(InputReader in, PrintWriter out) {
			int t = in.nextInt();
			while (t-- != 0) {
				int n = in.nextInt();
				int m = in.nextInt();
				int x = in.nextInt();
				TreeMap<Integer, ArrayList<Integer>> map = new TreeMap<>();
				for (int i = 0; i < n; i++) {
					int j = in.nextInt();
					if (!map.containsKey(j)) {
						map.put(j, new ArrayList<Integer>());
					}
					map.get(j).add(i);
				}
				out.println(""YES"");
				int[] ans = new int[n];
				int sta = 0;
				for (int s : map.keySet()) {
					for (int i = 0; i < map.get(s).size(); i++) {
						ans[map.get(s).get(i)] = (sta++) % m + 1;
					}
				}
				for(int i=0;i<n;i++) {
					out.print(ans[i]+"" "");
				}
				out.println();
			}

		}
	}

	
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;


public class Main {

	
	 
	
	 
	 
	
	 
	 
	 static Set<Long> set=new HashSet<>();
	 
	
	      
	
	
	
	
	
	
	
	
	
	
	 
	 
	 
	 
	 
	 
	
	public static void main(String[] args) throws IOException {
      FastReader sc=new FastReader();
      int t=sc.nextInt();
      while(t-->0) {
    	  int n=sc.nextInt();
    	  int m=sc.nextInt();
    	  int x=sc.nextInt();
    	  int a[]=new int[n];
    	  int b[]=new int[n];
    	  int freq[]=new int[100002];
    	  Arrays.fill(freq, 0);
    	  for(int i=0;i<n;i++) {
    		  a[i]=b[i]=sc.nextInt();
    	  }
    	  Arrays.sort(b);
    	  int temp=1;
   
    	  Map<Integer,List<Integer>> map=new HashMap<>();
    	  for(int i=0;i<n;i++) {
    		  if(map.get(b[i])==null) {
    			  List<Integer> lis=new ArrayList<Integer>();
    			  lis.add(temp);
    			  map.put(b[i], lis);
    		  }
    		  else {
    			  List<Integer> lis=map.get(b[i]);
    			  lis.add(temp);
    			  map.put(b[i], lis);
    		  }
    		  temp++;
    		  if(temp==m+1) {
    			  temp=1;
    		  }
    	  }
//    	  for(Map.Entry<Integer,List<Integer>> set: map.entrySet()) {
//    		   System.out.println(set.getKey()+"" ""+set.getValue());
//    	  }
    	  StringBuilder sb=new StringBuilder();
     	  List<Integer> res=new ArrayList<Integer>();
    	  for(int i=0;i<n;i++) {
    		  List<Integer> lis=map.get(a[i]);
    		  res.add(lis.get(freq[a[i]]));
    		//  sb.append(lis.get(freq[a[i]])+"" "");
    		//  System.out.println(lis);
    		  freq[a[i]]++;
    	  }
    	  boolean flag=true;
    	  int arr[]=new int[m+1];
    	  for(int i=0;i<n;i++) {
    		  arr[res.get(i)] += a[i];
    	  }
    	  for(int i=1;i<=m-1;i++) {
    		
    			 long cal= Math.abs(arr[i+1]-arr[i]);
    			 if(cal >x) {
    				 flag=false;
    				 break;
    			 
    		 }
    		 if(!flag) break;
    	  }
    	  if(!flag) {
    		  System.out.println(""NO"");
    	  }
    	  else {
    		  System.out.println(""YES"");
    		  for(int i=0;i<res.size();i++) {
    			  System.out.print(res.get(i)+"" "");
    		  }
    		  System.out.println();
    	  }
    	  
      }
	}

}
",0,Non-plagiarised
3368f340,a8f7c8b7,"import java.io.*;
import java.util.*;

public class Menorah {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();
        StringBuilder sb = new StringBuilder();
        while (t-->0){
            int n = sc.nextInt();
            char[] a = sc.next().toCharArray();
            char[] b = sc.next().toCharArray();

            int a1=0, b1=0;
            for(int i=0;i<n;i++){
                if(a[i]=='1')
                    a1++;
                if(b[i]=='1')
                    b1++;
            }

            int min = 100000000;

            if(a1==b1){
                int c = 0;
                for(int i=0;i<n;i++){
                    if(a[i]!=b[i])
                        c++;
                }

                min = Math.min(min, c);
            }

            if(b1==(n-a1+1)){
                int ind = -1;
                for(int i=0;i<n;i++){
                    if(a[i]==b[i] && a[i]=='1'){
                        ind = i;
                        break;
                    }
                }

                int c = 0;
                for(int i=0;i<n;i++){
                    if(i==ind)
                        continue;

                    if(a[i]==b[i])
                        c++;
                }

                min = Math.min(min, c + 1);
            }

            if(min == 100000000)
                sb.append(""-1\n"");
            else sb.append(min).append(""\n"");
        }

        System.out.println(sb);

        sc.close();
    }
}
","import java.util.Scanner;

public class Menorah {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            char initial[] = sc.next().toCharArray();
            char desired[] = sc.next().toCharArray();
            int lit1 = 0, lit2 = 0;
            int ans = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                if (initial[i] == '1') {
                    ++lit1;
                }
                if (desired[i] == '1') {
                    ++lit2;
                }
            }
            if (lit1 == lit2) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] != desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(count, ans);
            }
            if (lit2 == (n - lit1 + 1)) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] == desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(ans, count);
            }
            if (ans == Integer.MAX_VALUE) {
                System.out.println(-1);
            } else {
                System.out.println(ans);
            }
        }
    }
}
",1,Plagiarised
bdfe8110,e6a6e318,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class E {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		for (int tt=0; tt<T; tt++) {
			int n=fs.nextInt(), k=fs.nextInt();
			int[] positions=fs.readArray(k), temps=fs.readArray(k);
			int[] forced=new int[n];
			Arrays.fill(forced, Integer.MAX_VALUE/2);
			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
			for (int i=1; i<n; i++)
				forced[i]=Math.min(forced[i], forced[i-1]+1);
			for (int i=n-2; i>=0; i--)
				forced[i]=Math.min(forced[i], forced[i+1]+1);
			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
			out.println();
			
		}
		out.close();
	}

	
	
	

	
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class solution { 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(), k=s.nextInt();
			int[] a=s.readArray(k), temp=s.readArray(k);
			long[] ans=new long[n];
			Arrays.fill(ans, Integer.MAX_VALUE);
			for (int i=0; i<k; i++) {
				ans[a[i]-1]=temp[i];
			}
			for (int i=1; i<n; i++) {
				ans[i]=Math.min(ans[i],ans[i-1]+1);
			}
			for (int i=n-2; i>=0; i--) {
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for (int i=0; i<n; i++) {
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
    
    
    
    
    
    
    
}
",1,Plagiarised
52cd85f2,ff34fab2,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class PC3C {
	static PrintWriter out = new PrintWriter(System.out);
	static MyFastReaderPC3C in = new MyFastReaderPC3C();
	static long mod = (long) (1e9 + 7);

	public static void main(String[] args) throws Exception {
		
		int test = i();
		while (test-- > 0) {
			 
             int n=i();
             int[] arr=arrI(n);
             String s=string();
             
             ArrayList<Integer> lR=new ArrayList<>();

             ArrayList<Integer> lB=new ArrayList<>();
             for(int i=0;i<n;i++) {
            	
            	if(s.charAt(i)=='R') lR.add(arr[i]);
            	else lB.add(arr[i]);
            	 
             }
             
             
             Collections.sort(lB);
             Collections.sort(lR,Collections.reverseOrder());
             
             
             int k=1;
             boolean st=true;
             for(int i=0;i<lB.size();i++) {
            	 
            	 if(lB.get(i)>=k) {
            		k+=1; 
            	 }
            	 else {
            		st=false;
            		break;
            	 }
            		 
             }
             boolean st2=true;
               k=n;
               for(int i=0;i<lR.size();i++) {
            	 
            	 if(lR.get(i)>k) {
            	   st2=false;
            	   break;
            	 }
            	 else {
            		k-=1; 
            	 }
            		 
             }
               
               if(st && st2) out.print(""YES"");
               else out.print(""NO"");
             
             
			out.print(""\n"");
			out.flush();
		}
		out.close();
	}

	

	static void sort(long[] a) // check for long
	{
		ArrayList<Long> l = new ArrayList<>();
		for (long i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

	static void sort(int[] a) {
		ArrayList<Integer> l = new ArrayList<>();
		for (int i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

	

	

	

	

	

	

	

	

	

	

	// Debugging Functions Starts

	static void print(char A[]) {
		for (char c : A)
			System.out.print(c + "" "");
		System.out.println();
	}

	static void print(boolean A[]) {
		for (boolean c : A)
			System.out.print(c + "" "");
		System.out.println();
	}

	static void print(int A[]) {
		for (int a : A)
			System.out.print(a + "" "");
		System.out.println();
	}

	static void print(long A[]) {
		for (long i : A)
			System.out.print(i + "" "");
		System.out.println();

	}

	static void print(ArrayList<Integer> A) {
		for (int a : A)
			System.out.print(a + "" "");
		System.out.println();
	}

	// Debugging Functions END
	// ----------------------
	// IO FUNCTIONS STARTS
	

	public static Map<Character, Integer> mapSortByValue(Map<Character, Integer> hm) {
		// Create a list from elements of HashMap
		List<Map.Entry<Character, Integer>> list = new LinkedList<Map.Entry<Character, Integer>>(hm.entrySet());

		// Sort the list
		Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
			
		});

		// put data from sorted list to hashmap
		Map<Character, Integer> temp = new LinkedHashMap<Character, Integer>();
		for (Map.Entry<Character, Integer> aa : list) {
			temp.put(aa.getKey(), aa.getValue());
		}
		return temp;
	}
	static String string() {
		return in.nextLine();
	}

	static int i() {
		return in.nextInt();
	}

	static long l() {
		return in.nextLong();
	}

	static int[] arrI(int N) {
		int A[] = new int[N];
		for (int i = 0; i < N; i++) {
			A[i] = in.nextInt();
		}
		return A;
	}

	

}


","import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.*;
 
public class Div2 {
	
	

	 public static String solution(int [] arr, int n, String st) 
	 {
        ArrayList<Integer> red = new ArrayList<>();
        ArrayList<Integer> blue = new ArrayList<>();
        
        for(int i = 0; i<n; i++)
        {
        	if(st.charAt(i)=='R')
        		red.add(arr[i]);
        	else
        		blue.add(arr[i]);
        }
	    	
        Collections.sort(red);
        Collections.sort(blue);
        int cb = 1;
        
        for(int j = 0; j<blue.size(); j++)
        {
            if(blue.get(j)<cb)
            	return ""NO"";
            cb++;
        }
        
        int cr = n;
        for(int j = red.size()-1; j>=0; j--)
        {
            if(red.get(j)>cr)
            	return ""NO"";
            cr--;
        }
        
        return ""YES"";

	 }
        
private static PrintWriter out = new PrintWriter(System.out);

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
	  
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	String st = s.next();
   
    	out.println(solution(arr,n, st));
    }
    
		     
    out.flush();
    out.close();
    
}
}
",0,Non-plagiarised
6c4ac8d3,829d2024,"import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.io.*;


public class ieee1{

    
    public static void main(String[] args) {
           Scanner scn=new Scanner(System.in);
           int t=scn.nextInt();
           while(t-->0){
               HashMap<Integer,Integer> map=new HashMap<>();
              
               int b=scn.nextInt();
               int m=scn.nextInt();
               int x=scn.nextInt();
               int[] arr=new int[b];
               PriorityQueue<Node> pq=new PriorityQueue<>(new pqc());
               for(int i=0;i<b;i++){
                   int ele=scn.nextInt();
                   
                  
                   arr[i]=ele;
               }
               for(int i=1;i<=m;i++){
                   pq.add(new Node(i,0));
               }
               System.out.println(""YES"");
               for(int i=0;i<arr.length;i++){
                   int ele=arr[i];
                   Node n=pq.poll();
                   System.out.print(n.ind+"" "");
                   n.data+=ele;
                   pq.add(n);
               }
               System.out.println();
              
              
    }
}
    public static class Node{
        int ind;
        int data;
        Node(int ind,int data){
            this.ind=ind;
            this.data=data;
        }
    }
    public static class pqc implements Comparator<Node>{
        
        
    }

}
","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();
        }
    }
}
",1,Plagiarised
0cedec8a,ac8acb97,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC
    {
        public void solve(int testNumber, Scanner in, PrintWriter out)
        {
            int T = in.nextInt();
            while (T-- > 0)
            {
                solveOne(in, out);
            }
        }

        private void solveOne(Scanner in, PrintWriter out)
        {
            int N = in.nextInt();
            int nums[] = L.readIntArray(N, in);
            int min[] = new int[]{Integer.MAX_VALUE, Integer.MAX_VALUE};
            int rem[] = new int[]{N, N};
            long sum = 0;
            long ans = Long.MAX_VALUE;
            for (int idx = 0; idx < N; idx++)
            {
                min[idx % 2] = Math.min(min[idx % 2], nums[idx]);
                rem[idx % 2]--;
                sum += nums[idx];

                long cur = sum + rem[0] * (long) min[0] + rem[1] * (long) min[1];
                ans = Math.min(ans, cur);
            }
            out.println(ans);
        }

    }

    static class L
    {
        public static int[] readIntArray(int size, Scanner in)
        {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
            {
                array[i] = in.nextInt();
            }
            return array;
        }

    }
}
","import java.util.Scanner;

public class C1499 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int t = in.nextInt();
		while (t-- > 0) {
			int n = in.nextInt();
			// int[] arr = new int[n];
			long[] mn = { Long.MAX_VALUE, Long.MAX_VALUE };
			long[] rem = { n, n };
			long sum = 0;
			long ans = Long.MAX_VALUE;
			for (int i = 0; i < n; i++) {
				int temp = in.nextInt();
				mn[i % 2] = Math.min(mn[i % 2], temp);
				rem[i % 2]--;
				sum += temp;
				if (i > 0) {
					long cur = sum + rem[0] * mn[0] + rem[1] * mn[1];
					ans = Math.min(ans, cur);
				}
			}
			System.out.println(ans);

//			int a = Integer.MAX_VALUE;
//			int aIndex = -1;
//			int b = Integer.MAX_VALUE;
//			int bIndex = -1;
//
//			for (int i = 0; i < n; i++) {
//				arr[i] = in.nextInt();
//				if (i % 2 == 0) {
//					if (arr[i] < a) {
//						a = arr[i];
//						aIndex = i;
//					}
//				} else {
//					if (arr[i] < b) {
//						b = arr[i];
//						bIndex = i;
//					}
//				}
//			}
//			int sum = 0;
//			for (int i = 0; i < Math.max(bIndex, aIndex) + 1; i++) {
//				if (i % 2 == 0) {
//					if (i == aIndex) {
//						if (aIndex < bIndex) {
//							sum += (n - (i / 2) - ((bIndex - aIndex) / 2)) * arr[i];
//						} else {
//							sum += (n - (i / 2)) * arr[i];
//						}
//					} else {
//						sum += arr[i];
//					}
//				} else {
//					if (i == bIndex) {
//						if (bIndex < aIndex) {
//							sum += (n - (i / 2) - ((aIndex - bIndex) / 2)) * arr[i];
//						} else {
//							sum += (n - (i / 2)) * arr[i];
//						}
//					} else {
//						sum += arr[i];
//					}
//				}
//
//			}
//			System.out.println(sum);
//			for (int i = 0; i < n; i++) {
//				arr[i] = in.nextInt();
//				if (arr[i] < a) {
//					a = arr[i];
//					aIndex = i;
//
//				}
//
//			}
//			if (aIndex == 0) {
//
//				for (int i = 1; i < n; i++) {
//					if (arr[i] < b) {
//						b = arr[i];
//						bIndex = i;
//					}
//				}
//				System.out.println(aIndex + "" "" + bIndex);
//				System.out.println(a + "" "" + b);
//				int sum = 0;
//				for (int i = 1; i < bIndex; i++) {
//					sum += arr[i];
//				}
//				sum += b * (n - bIndex + 1);
//				sum += a * n;
//				System.out.println(sum);
//			} else {
//				int b = Integer.MAX_VALUE;
//				int bIndex = -1;
//				for (int i = 0; i < aIndex; i++) {
//					if (arr[i] < b) {
//						b = arr[i];
//						bIndex = i;
//					}
//				}
//				System.out.println(aIndex + "" "" + bIndex);
//				System.out.println(a + "" "" + b);
//				int sum = 0;
//				for (int i = 0; i < bIndex; i++) {
//					sum += arr[i];
//				}
//				sum += b * (n - bIndex);
//				sum += a * n;
//				System.out.println(sum);
//			}

		}
	}
}
",1,Plagiarised
11c2ab99,fadc1365,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		for (int tt=0; tt<T; tt++) {
			int n=fs.nextInt(), k=fs.nextInt();
			int[] positions=fs.readArray(k), temps=fs.readArray(k);
			int[] forced=new int[n];
			Arrays.fill(forced, Integer.MAX_VALUE/2);
			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
			for (int i=1; i<n; i++)
				forced[i]=Math.min(forced[i], forced[i-1]+1);
			for (int i=n-2; i>=0; i--)
				forced[i]=Math.min(forced[i], forced[i+1]+1);
			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
			out.println();
			
		}
		out.close();
	}

	
	
	

	
}
","import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class a{ 
    public static void main(String args[]) throws java.lang.Exception{ 
    	FastScanner s=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		int t=s.nextInt();
		for(int tt=0;tt<t;tt++) {
			int n=s.nextInt(),k=s.nextInt();
			int pos[]=s.readArray(k);
			int temp[]=s.readArray(k);
			long ans[]=new long[n];
			Arrays.fill(ans,Integer.MAX_VALUE);
			for(int i=0;i<k;i++){
				ans[pos[i]-1]=temp[i];
			}
			for(int i=1;i<n;i++){
				ans[i]=Math.min(ans[i-1]+1,ans[i]);
			}
			for(int i=n-2;i>=0;i--){
				ans[i]=Math.min(ans[i],ans[i+1]+1);
			}
			for(int i=0;i<n;i++){
				out.print(ans[i]+"" "");
			}
			out.println();
		}
		out.close();
    }
	
    
	
    
    
    
    
    
    
}
",1,Plagiarised
a4d6775d,eea69e7f,"import java.io.*;
import java.util.*;
 
public class ArmChairs {
    
 
    public static int solution(int n, int[] arr) {
 
        ArrayList<Integer> one = new ArrayList<Integer>();
        ArrayList<Integer> zero = new ArrayList<Integer>();
 
        for (int i = 0; i < n; i++) {
            if (arr[i] == 1) {
                one.add(i);
            } else {
                zero.add(i);
            }
        }
 
        int[][] dp = new int[one.size() + 1][zero.size() + 1];
 
        for (int i = 1; i <= one.size(); i++) {
            dp[i][i] = dp[i - 1][i - 1] + Math.abs(one.get(i - 1) - zero.get(i - 1));
            for (int j = i + 1; j <= zero.size(); j++) {
                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j - 1] + Math.abs(one.get(i - 1) - zero.get(j - 1)));
            }
        }
 
        return dp[one.size()][zero.size()];
    }
 
 
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int n = Integer.parseInt(br.readLine());
 
        String[] s = br.readLine().split("" "");
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(s[i]);
        } 
 
        log.write(Integer.toString(solution(n, arr)) + ""\n"");
        log.flush();
        
    }
 
}
","import java.util.*;

public class Solution {
	
	public static int minMoves(int[] input) {
		List<Integer> people = new ArrayList<Integer>();
		List<Integer> chairs = new ArrayList<Integer>();
		
		for (int i = 0; i < input.length; i++) {
			if (input[i] == 1) {
				people.add(i);
			} else {
				chairs.add(i);
			}
		}
		
		int[] memo = new int[chairs.size() + 1];
		

		for (int p = 1; ((!people.isEmpty()) && (p <= people.size())); p++) {
			int prev = memo[p];
			memo[p] = memo[p - 1] + Math.abs(people.get(p - 1) - chairs.get(p - 1));
			for (int c = p + 1; c <= chairs.size(); c++) {
				int tmp = memo[c];
				memo[c] = Math.min(memo[c - 1], prev + Math.abs(people.get(p - 1) - chairs.get(c - 1)));
				prev = tmp;
			}
		}
		return memo[memo.length - 1];
	}
	
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] input = new int[n];
		for (int i = 0; i < n; i++) {
			input[i] = sc.nextInt();
		}
		
		System.out.println(Solution.minMoves(input));
		
	}
}
",0,Non-plagiarised
31f29772,b728ba1d,"import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.io.*;
 
public class PhoenixTow {
	
	
	

	public static class  Pair implements Comparable<Pair>
	{
		int x; 
		int y;
		
		Pair(int x, int y)
		{
			this.x = x;
			this.y = y;
		}
		
		
	}
	
	public static void solution(int[] arr, int n, int m, int x)
			
	{
		ArrayList<Pair> list = new ArrayList<>();
		
		for(int i = 0; i<n; i++)
		{
			list.add(new Pair(arr[i], i));
		}
		
		Collections.sort(list);
		
		long[] sum = new long[m];
		
		int[] ans = new int[n];
		
		int k = 1;
		
		for(int i = 0; i<list.size(); i++)
		{
			if(k<m)
		    { 
				if(sum[k-1]+list.get(i).x - sum[k]>x)
			      {out.println(""NO""); return; }
		      
		    }
			
			  
	    	sum[k-1]+=list.get(i).x;
	    	ans[list.get(i).y] = k;
	    	k++;
	    	
	    	if(k==(m+1))
	    		k=1;
	    	
			
		}
		
		out.println(""YES""); 
		
		for(int i = 0; i<n; i++)
			out.print(ans[i]+"" "");
		
		out.println();
		
		
	}
        
private static PrintWriter out = new PrintWriter(System.out);

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
     
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int m = s.nextInt();
    	int x = s.nextInt();
    	
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	solution(arr,n,m,x);
    }
    
    out.flush();
    out.close();
    
}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CPhoenixAndTowers solver = new CPhoenixAndTowers();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }

        

        

        

    }

    
}
",0,Non-plagiarised
49e94e7e,da5cf40b,"import java.io.BufferedReader;
import java.io.IOException;
import java.lang.*;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.out;
import java.util.*;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
public class Main {
 
	
	/* 10^(7) = 1s.
	 * ceilVal = (a+b-1) / b */
	
	static final int mod = 1000000007;
	static final long temp = 998244353;
	static final long MOD = 1000000007;
	static final long M = (long)1e9+7;
 
	
	
	
	
	
	
	

	
	
	 
 
		
	
	
	
		
	
		//Count the number of coprime's upto N
			
	
	
	
	   
	   
	   
	 
	    // Returns nCr % p using Fermat's little theorem.
	    
	    
	    
	    
	    
	    
 
		//Modular Operations for Addition and Multiplication. 
		   
		   
		  
		   
		   
		   
		   
		   
			
			
			
			
			
			
			   
				
		   
		   
		
			   /*
			    * 
			    * >=         <=
			   0 1 2 3 4 5 6 7  
			   5 5 5 6 6 6 7 7
			   lower_bound for 6 at index 3 (>=)
			   upper_bound for 6 at index 6(To get six reduce by one) (<=)
			   */

		   
		   
			
			
			
			
			
	
	
	public static void main(String[] args) throws Exception 
	{
		Reader sc = new Reader();
		PrintWriter fout = new PrintWriter(System.out); 
		
		int tt = sc.nextInt();
		while(tt-- > 0)
		{
	       int n = sc.nextInt();
	       char[] a = sc.next().toCharArray(), b = sc.next().toCharArray();
	       
	       int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
	       for(int i = 0;i<n;i++)
	       {
	    	   if(a[i] == '0' && b[i] == '0')
	    	   {
	    		   c00++;
	    	   }
	    	   else if(a[i] == '0' && b[i] == '1')
	    	   {
	    		   c01++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '0')
	    	   {
	    		   c10++;
	    	   }
	    	   else if(a[i] == '1' && b[i] == '1')
	    	   {
	    		   c11++;
	    	   }
	       }
	       
	       int ans = mod;
	       if(c01 == c10) ans = min(ans, c01 + c10);
	       if(c11 == c00 + 1) ans = min(ans, c11 + c00);
	       
	       fout.println((ans == mod) ? -1 : ans);
		}
		
		fout.close();
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;
public class Main  
{
    static FastReader sc =new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    /* start */
   
       public static void main(String [] args)
    {
        // int testcases = 1;
        int testcases = i();
        while(testcases-->0)
        {
            
            solve();
        }
        out.flush();
        out.close();
    }
    static void solve()
    { 
        int n = i();
        char c[] = inputC();
        char d[] = inputC();
        int x01=0,x10=0,x00=0,x11=0;
        for(int i=0;i<n;i++)
        {
            if(c[i]=='0'&&d[i]=='0')x00++;
            if(c[i]=='0'&&d[i]=='1')x01++;
            if(c[i]=='1'&&d[i]=='0')x10++;
            if(c[i]=='1'&&d[i]=='1')x11++;
        }

        int ans = Integer.MAX_VALUE;
        if(x01==0 && x10==0)
        {
            System.out.println(0);
            return ;
        }
        if(x11==x00+1)
        {
            ans = Math.min(x11+x00,ans);
        }
      if(x01==x10)
        {
            ans = Math.min(x01+x10,ans);
        }
        if(ans == Integer.MAX_VALUE){
            ans = -1;
        }
        System.out.println(ans);
    }
    
    /* end */
     

    static int i() {
        return sc.nextInt();
    }


    

    static char[] inputC()
    {
        String s = sc.nextLine();
        return s.toCharArray();
    }

    

    

    

    
      
     

      

     
    
     

    
    

    

    

    

    

    

    

     

      

        
    
        
        //pair class
        
}
",0,Non-plagiarised
a8f7c8b7,f229aa7f,"import java.util.Scanner;

public class Menorah {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            char initial[] = sc.next().toCharArray();
            char desired[] = sc.next().toCharArray();
            int lit1 = 0, lit2 = 0;
            int ans = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                if (initial[i] == '1') {
                    ++lit1;
                }
                if (desired[i] == '1') {
                    ++lit2;
                }
            }
            if (lit1 == lit2) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] != desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(count, ans);
            }
            if (lit2 == (n - lit1 + 1)) {
                int count = 0;
                for (int i = 0; i < n; i++) {
                    if (initial[i] == desired[i]) {
                        ++count;
                    }
                }
                ans = Math.min(ans, count);
            }
            if (ans == Integer.MAX_VALUE) {
                System.out.println(-1);
            } else {
                System.out.println(ans);
            }
        }
    }
}
","import java.util.*;
import java.io.*;
import java.math.*;

public class cf {
	static PrintWriter pw = new PrintWriter(System.out);

	public static void main(String[] args) throws IOException, InterruptedException {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();
			char[] a = sc.next().toCharArray();
			char[] b = sc.next().toCharArray();
			int x = 0, y = 0, lit = 0,lit2 = 0;
			for (int i = 0; i < n; i++) {
				if (a[i] == '1')
					lit++;
				if (b[i] == '1')
					lit2++;
				if (a[i] == b[i])
					x++;
				else
					y++;
			}
			if(lit == lit2 || n - lit + 1 == lit2) {
				if (lit == lit2 && n - lit + 1 == lit2) {
					pw.println(Math.min(x,y));
				}else if(lit == lit2) {
					pw.println(y);
				}else {
					pw.println(x);
				}
			}else {
				pw.println(-1);
			}
		}
		pw.close();
	}

	

	

	

}
",0,Non-plagiarised
065e0cbd,9b449b4f,"import java.util.*;
import java.io.*;
public class Main
{
	
    public static int ask(int i){
        FastReader sc = new FastReader();
        System.out.println(""? "" + (i+1));
        System.out.flush();
        int x = sc.nextInt();
        return x - 1;
    }
	public static void main(String[] args) {
		FastReader sc = new FastReader();
		int t = sc.nextInt();
		int inf = 1000000007;
		while(t-->0){
		    int n = sc.nextInt();
		    int ans[] = new int[n];
		    for(int i=0;i<n;i++){
		        if(ans[i] == 0){
		            ArrayList<Integer> cycle = new ArrayList<Integer>();
    		        int x = ask(i), y = ask(i);
    		        cycle.add(y);
    		        while(y != x){
    		            y = ask(i);
    		            cycle.add(y);
    		        }  
    		        for(int j=0;j<cycle.size();j++){
    		            ans[cycle.get(j)] = cycle.get((j+1)%cycle.size()) + 1;
    		        }
		        }
		    }
		    
		    System.out.print(""! "");
		    for(int i=0;i<n;i++) System.out.print(ans[i] + "" "");
		    System.out.println();
		}
	}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

public class Solution {
    public static void main(String[] args) throws java.lang.Exception {
        out = new PrintWriter(new BufferedOutputStream(System.out));
        sc = new FastReader();

        int test = sc.nextInt();
        for (int t = 0; t < test; t++) {
            solve();
        }
        out.close();
    }

    private static void solve() {
        int n = sc.nextInt();
        int[] permutation = new int[n];
        Arrays.fill(permutation, -1);

        // there may be multiple cycles in the given permutation
        for (int i = 0; i < n; i++) {
            if (permutation[i] == -1) { // ith permutation value is not found yet
                // so we find all values of permutation having i in their cycle
                // for that we always ask(i) so that we can get all values in that cycle
                List<Integer> cycle = new ArrayList<>();

                int startCycleValue = ask(i + 1);
                int currValueAt = ask(i + 1);

                cycle.add(currValueAt);
                while (currValueAt != startCycleValue) {
                    currValueAt = ask(i + 1);
                    cycle.add(currValueAt);
                }

                int m = cycle.size();
                for (int j = 0; j < m; j++) {
                    permutation[cycle.get(j)] = cycle.get((j + 1) % m);
                }
            }
        }

        out.println(""! "");
        for (int i = 0; i < n; i++) {
            out.print((permutation[i] + 1) + "" "");
        }
        out.println();
        out.flush();
    }

    private static int ask(int i) {
        out.println(""? "" + i + "" "");
        out.flush();
        int value = sc.nextInt();
        return value - 1;
    }


    public static FastReader sc;
    public static PrintWriter out;
    
}
",0,Non-plagiarised
53d782a0,5769b7b3,"import java.io.*;
import java.util.*;

public class B {
    //--------------------------INPUT READER---------------------------------//
    //-----------------------------------------------------------------------//

    //---------------------------PRINTER-------------------------------------//
    //-----------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


    }

    static void solve() throws IOException {
        int n = sc.ni();
        long k = sc.nl();
        Long[] arr = new Long[n];
        for(int i = 0; i < n; i++) arr[i] = sc.nl();
        Arrays.sort(arr);
        long sum = 0;
        for(int i = 0; i < n; i++) {
            sum += arr[i];
        }
        if(sum <= k) {
            System.out.println(0);
            return;
        }


        long cont = 0;
        long min = sum-k;
        for(int i = n-1; i >= 0; i--) {
            cont += arr[i];
            long psum = sum-cont;


            if(psum <= k) {
                long extra = k-psum;
                if(arr[0]*(n-i)<=extra) {
                    min = Math.min(min, n-i);
                    continue;
                }

                if(i == 0) {
                    long q = k/n;
                    long ans = arr[0]-q+n-1;
                    min = Math.min(min, ans);
                    continue;
                }
                extra += arr[0];
                long q = extra/(n-i+1);
                long ans = arr[0]-q+n-i;
                min = Math.min(min, ans);

            } else {
                long toRem = psum-k-arr[0];
                long q = (long)Math.ceil(toRem/(n-i+1.0));
                long ans = q+arr[0]+n-i;
                min = Math.min(min, ans);
            }
        }

        System.out.println(min);
    }

}
","import java.io.*;
import java.util.*;

public class B {
    //--------------------------INPUT READER---------------------------------//

    //-----------------------------------------------------------------------//

    //---------------------------PRINTER-------------------------------------//
    //-----------------------------------------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


        w.close();
    }

    static void solve() throws IOException {
        int n = sc.ni();
        long k = sc.nl();
        Long[] arr = new Long[n];
        for(int i = 0; i < n; i++) arr[i] = sc.nl();
        Arrays.sort(arr);
        long sum = 0;
        for(int i = 0; i < n; i++) {
            sum += arr[i];
        }
        if(sum <= k) {
            System.out.println(0);
            return;
        }


        long cont = 0;
        long min = sum-k;
        for(int i = n-1; i >= 0; i--) {
            cont += arr[i];
            long psum = sum-cont;


            if(psum <= k) {
                long extra = k-psum;
                if(arr[0]*(n-i)<=extra) {
                    min = Math.min(min, n-i);
                    continue;
                }

                if(i == 0) {
                    long q = k/n;
                    long ans = arr[0]-q+n-1;
                    min = Math.min(min, ans);
                    continue;
                }
                extra += arr[0];
                long q = extra/(n-i+1);
                long ans = arr[0]-q+n-i;
                min = Math.min(min, ans);

            } else {
                long toRem = psum-k-arr[0];
                long q = (long)Math.ceil(toRem/(n-i+1.0));
                long ans = q+arr[0]+n-i;
                min = Math.min(min, ans);
            }
        }

        System.out.println(min);
    }

}
",1,Plagiarised
35eb27da,64ce7b1e,"import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-- > 0)
		{
		    int n = sc.nextInt();
		    sc.nextLine();
		    int a[][] = new int[26][26];
		    int b[][][] = new int[26][26][26];
		    
		    boolean bl = false;
		    String arr[] = new String[n];
		    for(int i = 0 ; i < n ; i++)
		    {
		        arr[i] = sc.nextLine();
		        
		        if(arr[i].length() == 1)
		        {
		            bl = true;
		        }
		        
		        else if(arr[i].length() == 2)
		        {
		            //a[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'] = 1;
		            if(arr[i].charAt(0)==arr[i].charAt(1))
		            bl = true;
		        }
		        
		        else
		        {
		           //b[arr[i].charAt(0)-'a'][arr[i].charAt(1)-'a'][arr[i].charAt(2)-'a'] = 1; 
		           if(arr[i].charAt(0) == arr[i].charAt(2))
		           bl = true;
		        }
		    }
		    
		    if(bl)
		    System.out.println(""YES"");
		    
		    else
		    {
		        for(int i = 0; i < n ; i++)
		        {
		            if(arr[i].length() == 2)
		            {
		                int p1 = arr[i].charAt(0)-'a';
		                int p2 = arr[i].charAt(1)-'a';
		                
		                if(a[p2][p1] == 1)
		                bl = true;
		                
		                for(int j = 0;  j < 26 ; j++)
		                {
		                    if(b[p2][p1][j] == 1)
		                    bl = true;
		                }
		                a[p1][p2] = 1;
		            }
		            
		            else
		            {
		                 int p1 = arr[i].charAt(0)-'a';
		                int p2 = arr[i].charAt(1)-'a';
		                int p3 = arr[i].charAt(2)-'a';
		                
		                if(a[p3][p2] == 1)
		                bl = true;
		                
		                if(b[p3][p2][p1] == 1)
		                bl = true;
		                
		                b[p1][p2][p3] = 1;
		            }
		        }
		        if(bl)
		        System.out.println(""YES"");
		        
		        else
		        System.out.println(""NO"");
		    }
		}
	}
}
","import java.io.*;
import java.util.*;
public class new1{
	
    
    

	public static void main(String[] args)  throws IOException{

		BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
		FastReader s = new FastReader();
		int t = s.nextInt();
		for(int z = 0; z < t; z++) {
			int n = s.nextInt();
			Set<String> st = new HashSet<String>();
			String[] arr = new String[n];
			boolean pos = false;
			for(int i = 0; i < n; i++) {
				String str = s.next();
				st.add(str); arr[i] = str;
				if(str.length() == 1) pos = true;
			}
			if(pos) {
				System.out.println(""YES"");
				continue;
			}
			for(int i = 0; i < n; i++) {
				String str = arr[i];
				st.remove(str);
				if(str.charAt(0) == str.charAt(str.length() - 1)) pos = true;
				if(str.length() == 3) {
					String str1 = Character.toString(str.charAt(1)) + Character.toString(str.charAt(0));
					if(st.contains(str1)) pos = true;
					String str2 = Character.toString(str.charAt(2)) + str1;
					if(st.contains(str2)) pos = true;
				}
				else {
					String str1 = Character.toString(str.charAt(1)) + Character.toString(str.charAt(0));
					if(st.contains(str1)) pos = true;;
					for(int j = 0; j < 26; j++) {
						char ch = (char) ((int)'a' + j);
						String str2 = Character.toString(ch) + str1;
						if(st.contains(str2)) pos = true;;
					}
					
					
				}
			}
			//System.out.println(st.toString());
			if(pos) System.out.println(""YES"");
			else System.out.println(""NO"");
			//System.out.println(st.contains(""ba""));
		}
			
	  }
}


 
	
",0,Non-plagiarised
12309af3,390d2f23,"import java.util.*;
import java.lang.*;
import java.io.*;
public class MyAnswer {
     public static void main(String[] args)throws IOException{
          FastScanner scan = new FastScanner();
          //SuperFastScanner scan = new SuperFastScanner();
          PrintWriter out = new PrintWriter(System.out);
          StringBuilder result = new StringBuilder();
     
          int t = scan.nextInt();
          while (t-- > 0){
               int n = scan.nextInt();
               int arr[] = scan.nextIntArray(n);
               if(n%2==0){
                    int j = n/2;
                    for(int i = j;i<n;i++){
                         int val = arr[i] * -1;
                         result.append(val + "" "");
                    }
                    for(int i = 0;i<j;i++){
                         int val = arr[i] ;
                         result.append(val + "" "");
                    }
               }else{
                    int j = (n-3)/2;
                    for(int i = j;i<n-3;i++){
                         int val = arr[i] * -1;
                         result.append(val + "" "");
                    }
                    for(int i = 0;i<j;i++){
                         int val = arr[i] ;
                         result.append(val + "" "");
                    }
                    
                    if(arr[n-3]+arr[n-2] !=0 ){
                         int sum = arr[n-3] + arr[n-2];
                         sum *=-1;
                         result.append(arr[n-1] + "" "");
                         result.append(arr[n-1] + "" "");
                         result.append(sum+ "" "");
                         
                    }else if(arr[n-1]+arr[n-2] !=0 ){
                         int sum = arr[n-1] + arr[n-2];
                         sum *=-1;
                         result.append(sum+ "" "");
                         result.append(arr[n-3] + "" "");
                         result.append(arr[n-3]+"" "");
                         
                    }else{
                         int sum = arr[n-1] + arr[n-3];
                         sum *=-1;
                         result.append(arr[n-2] + "" "");
                         result.append(sum+ "" "");
                         result.append(arr[n-2]+ "" "");
                    }
                         
               }
               result.append(""\n"");
               
          }
          out.println(result);
          out.flush();
     }
     

     
     

}
","import java.io.*;

public class Main {
    static BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer IN = new StreamTokenizer(BR);
    static PrintWriter OUT = new PrintWriter(new BufferedOutputStream(System.out));
    static int nextInt() throws IOException {
        IN.nextToken();
        return (int) IN.nval;
    }
    
    
    


    
    
    public static void main(String[] args) throws IOException {
//        Scanner sc = new Scanner(System.in);
        int T = nextInt();

        while(T-- > 0) {
            int N = nextInt();

            int[] a = new int[N];

            for (int i = 0; i < N; i++) {
                a[i] = nextInt();
            }
            if (N % 2 == 0) {
               for (int i = 0; i < N; i+=2) {
                   OUT.print(a[i+1] + "" "");
                   OUT.print(-1 * a[i] + "" "");
               }
            } else{
                for (int i = 0; i < N-3; i+=2) {
                    OUT.print(a[i+1] + "" "");
                    OUT.print(-1 * a[i] + "" "");
                }
                if(a[N-3] + a[N-2] != 0) {
                    OUT.print(-a[N-1] + "" "" + -a[N-1] + "" "" + (a[N-3] + a[N-2]));
                } else if(a[N-2] + a[N-1] != 0) {
                    OUT.print((a[N-2] + a[N-1]) + "" "" + -a[N-3] + "" "" + -a[N-3]);
                } else {
                    OUT.print(-a[N-2] + "" "" + (a[N-1] + a[N-3]) + "" "" + -a[N-2]);
                }
            }

            OUT.println();
        }

        OUT.flush();
    }
}
",0,Non-plagiarised
12c1cc56,7b71234c,"import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int n=Integer.parseInt(bu.readLine());
        String s[]=bu.readLine().split("" "");
        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
        long dp[][]=new long[n+1][n+1];
        int i,j,a;
        for(i=0;i<n;i++)
        {
            a=Integer.parseInt(s[i]);
            if(a==0) z.add(i);
            else o.add(i);
        }

        for(i=1;i<=o.size();i++)
        {
            long min=dp[i-1][i-1];
            for(j=i;j<=z.size();j++)
            {
                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
                min=Math.min(min,dp[i-1][j]);
            }
        }
        long ans=Long.MAX_VALUE;
        for(i=o.size();i<=z.size();i++)
        ans=Math.min(ans,dp[o.size()][i]);
        System.out.print(ans);
    }
}
","import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int n=Integer.parseInt(bu.readLine());
        String s[]=bu.readLine().split("" "");
        ArrayList<Integer> z=new ArrayList<>(),o=new ArrayList<>();
        long dp[][]=new long[n+1][n+1];
        int i,j,a;
        for(i=0;i<n;i++)
        {
            a=Integer.parseInt(s[i]);
            if(a==0) z.add(i);
            else o.add(i);
        }

        for(i=1;i<=o.size();i++)
        {
            long min=dp[i-1][i-1];
            for(j=i;j<=z.size();j++)
            {
                dp[i][j]=min+Math.abs(z.get(j-1)-o.get(i-1));
                min=Math.min(min,dp[i-1][j]);
            }
        }
        long ans=Long.MAX_VALUE;
        for(i=o.size();i<=z.size();i++)
        ans=Math.min(ans,dp[o.size()][i]);
        System.out.print(ans);
    }
}
",1,Plagiarised
b56ebada,b95a75a7,"import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class First {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        //int a = 1;
        int t;
        t = in.nextInt();
        //t = 1;
        while (t > 0) {
            //out.print(""Case #""+(a++)+"": "");
            solver.call(in, out);
            t--;
        }
        out.close();

    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            int n;
            n = in.nextInt();

            int[] arr = new int[n];
            Integer[] lower = new Integer[n];
            Integer[] higher = new Integer[n];

            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
            }

            TreeSet<Integer> set = new TreeSet<>();
            for (int i = 0; i < n; i++) {
                set.add(arr[i]);
                lower[i] = set.lower(arr[i]);
                higher[i] = set.higher(arr[i]);
            }

            for (int i = 1; i < n; i++) {
                if(arr[i]>arr[i-1]){
                    if(higher[i-1] != null && higher[i-1]<arr[i]){
                        out.println(""NO"");
                        return;
                    }
                }
                else{
                    if(lower[i-1] != null && lower[i-1]>arr[i]){
                        out.println(""NO"");
                        return;
                    }
                }
            }
            out.println(""YES"");


        }
    }

    

    

    

    

    

    

    static final Random random=new Random();

    

    
}
","import java.util.*;
import java.io.*;


public class Main{
    public static class Node {
        int val;
        Node left;
        Node right;
        Node(int val)
        {
            this.val=val;
        }
    }
    public static void main(String[] args) throws java.io.IOException {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t-->0)
        {
            int n=sc.nextInt();
            int[] arr=new int[n];
            for(int i=0;i<n;++i)
            {
                arr[i]=sc.nextInt();
            }
            Node head=new Node(arr[0]);
            boolean cond=false;
            for(int i=1;i<n;i++)
            {
                int cur=head.val;
                //System.out.println(cur);
                if(arr[i]>cur)
                {
                    if(head.right==null)
                    {
                        Node next=new Node(arr[i]);
                        head.right=next;
                        next.left=head;
                        head=head.right;
                    }
                    else if(head.right.val<arr[i])
                    {
                        cond=true;
                        break;
                    }
                    else if(head.right.val==arr[i])
                    {
                        head=head.right;
                    }
                    else
                    {
                        Node next=new Node(arr[i]);
                        next.right=head.right;
                        head.right.left=next;
                        head.right=next;
                        next.left=head;
                        head=next;
                    }
                }
                else if(arr[i]<cur)
                {
                    if(head.left==null)
                    {
                        Node next=new Node(arr[i]);
                        head.left=next;
                        next.right=head;
                        head=head.left;
                    }
                    else if(head.left.val>arr[i])
                    {
                        cond=true;
                        break;
                    }
                    else if(head.left.val==arr[i])
                    {
                        head=head.left;
                    }
                    else
                    {
                        Node next=new Node(arr[i]);
                        next.left=head.left;
                        head.left.right=next;
                        head.left=next;
                        next.right=head;
                        head=next;
                    }
                }
            }
            if(cond)
                System.out.println(""NO"");
            else
                System.out.println(""YES"");
        }
    }
}
",0,Non-plagiarised
bdf7bfb2,d92c5342,"import java.util.*;
import java.io.*;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-- > 0){
            int n = sc.nextInt();
            String[] s = new String[n];
            for(int i=0; i<n; i++)
                s[i] = sc.next();
            int MAX = 0;
            for(char c = 'a'; c <= 'e'; c++){
                PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); //Big comes in top;
                for(int i=0; i<n; ++i) {
                    int curChar = 0;
                    int otherChar = 0;
                    for(int j=0; j<s[i].length(); j++) {
                        if(s[i].charAt(j) == c)
                            curChar++;
                        else
                            otherChar++;
                    }
                    int diff = curChar - otherChar;
                    pq.add(diff);
                }
                int cur = 0;
                int numberOfWords = 0;
                while(!pq.isEmpty()){
                    if(cur + pq.peek() > 0){
                        cur += pq.poll();
                        numberOfWords++;
                    }else{
                        break;
                    }
                }
                MAX = Math.max(MAX, numberOfWords);
            }
            pw.println(MAX);
        }
        pw.close();
    }
 
    
}
","import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;
public class Main{
    
    
    static int MOD=1000003;
    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner();
        FastWriter out = new FastWriter();
        int t=in.nextInt();
        //int t=1;
        while (t-->0){
            int n=in.nextInt();
            String[] ar=new String[n];
            for (int i = 0; i < n; i++) {
                ar[i]=in.next();
            }
            int ans=0;
            for(char ch='a';ch<='e';ch++){
                int[] res=new int[n];
                for (int i = 0; i < n; i++) {
                    String ss=ar[i];
                    for (int j = 0; j < ss.length(); j++) {
                        if(ss.charAt(j)==ch){
                            res[i]++;
                        }else {
                            res[i]--;
                        }
                    }
                }
                Arrays.sort(res);int max=0,nn=0;
                for (int i = n-1; i>=0; i--) {
                    max+=res[i];
                    if(max>0){
                        nn++;
                    }else {
                        break;
                    }
                }
                ans=Math.max(ans,nn);
            }
            out.println(ans);
        }
        out.close();
    }
    //Arrays.sort(a, (o1, o2) -> (o1[0] - o2[0]));
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
}
",0,Non-plagiarised
69b8ffb2,ba468e1f,"import java.util.*;

//CODE FORCES

public class anshulvmc {

    
    public static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
    
    
    
    
    
    
    
    
    
//    public static void gt(int[][] arr,int k) {
//    	int n = arr.length+1;
//    	k = Math.min(k,n+1);
//    	
//    	Node[] nodes = new Node[n];
//    	for(int i=0;i<n;i++) nodes[i] = new Node();
//    	for(int i=0;i<n-1;i++) {
//    		int a = arr[i][0];
//    		int b = arr[i][1];
//    		System.out.println(a+"" ""+b);
//    		nodes[a].adj.add(nodes[b]);
//    		nodes[b].adj.add(nodes[a]);
//    	}
//    	
//    	ArrayDeque<Node> bfs = new ArrayDeque<>();
//    	for(Node nn:nodes) {
//    		if(nn.adj.size()<2) {
//    			bfs.addLast(nn);
//    			nn.dist=0;
//    		}
//    	}
//    	
//    	while(bfs.size()>0) {
//    		Node nn = bfs.removeFirst();
//    		for(Node a : nn.adj) {
//    			if(a.dist!=-1) continue;
//    			a.usedDegree++;
//    			if(a.adj.size() - a.usedDegree <= 1) {
//    				a.dist = nn.dist+1;
//    				bfs.addLast(a);
//    			}
//    		}
//    	}
//    	
//    	int[] cs = new int[n+1];
//    	for(Node nn:nodes) {
//    		cs[nn.dist]++;
//    	}
//    	for(int i=1;i<cs.length;i++) cs[i]+=cs[i-1];
//    	System.out.println(n-cs[k-1]);
//    }
    
    
    
    
    
    
    
    
	
    
    
    
	public static boolean redblue(int[] num, String chnum) {
    	ArrayList<Integer> blue = new ArrayList<>();
    	ArrayList<Integer> red = new ArrayList<>();
    	for(int i=0;i<chnum.length();i++) {
    		char ch = chnum.charAt(i);
    		if(ch == 'B') {
    			blue.add(num[i]);
    		}
    		else {
    			red.add(num[i]);
    		}
    	}
    	Collections.sort(blue);
    	Collections.sort(red);
//    	System.out.println(blue);
//    	System.out.println(red);
    	for(int i=0;i<blue.size();i++) {
    		if(blue.get(i) >= i+1) {
    			
    		}
    		else {
    			return false;
    		}
    	}
    	for(int i=0;i<red.size();i++) {
    		if(red.get(i) > i+1 + blue.size()) {
//    			System.out.println(red.get(i)+"" ""+(i+1 + blue.size()));
    			return false;
    		}
    	}
    	return true;
    }
    
    public static void main(String args[])
    
    
    {	
    	Scanner scn = new Scanner(System.in);
    	int test = scn.nextInt();
    	for(int i=0;i<test;i++) {
    		int size = scn.nextInt();
    		int[] arr = new int[size];
    		for(int j=0;j<size;j++) {
    			arr[j] = scn.nextInt();
    		}
    		String str = scn.next();
    		boolean f = redblue(arr,str);
    		if(f) {
    			System.out.println(""YES"");
    		}
    		else {
    			System.out.println(""NO"");
    		}
    	}
//    	int n = 1;
//    	int[] dp = new int[2];
//    	System.out.println(fact(n,dp));
    			
    }

}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
",0,Non-plagiarised
4323e2bd,ebd8ff55,"import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<ArrayList<Integer>> g;
	static long mod=(long)(1e9+7);
	static int D1[],D2[],par[];
	static boolean set[];
	static int value[];
	static long INF=Long.MAX_VALUE;
	static int dp[][];
	static int N,M;
	static int A[][],B[][];
	static int s=1;
	public static void main(String args[])throws IOException
	{  					
		int N=i();
		int A[]=input(N);
		ArrayList<Integer> one=new ArrayList<Integer>();
		ArrayList<Integer> zero=new ArrayList<Integer>();
		for(int i=1; i<=N; i++)
		{
			if(A[i-1]==1)one.add(i);
			else zero.add(i);
		}
		int sum[][]=new int[N+5][N+5];
		for(int i=1; i<=one.size(); i++)
		{
			for(int j=1; j<=zero.size(); j++)
			{
				sum[i][j]=Math.abs(one.get(i-1)-zero.get(j-1));
			}
			//print(sum[i]);
		}
		dp=new int[N+5][N+5];
		//for(int d[]:dp)Arrays.fill(d, Integer.MAX_VALUE);
		Arrays.fill(dp[0], 0);
		for(int i=1; i<=one.size(); i++)
		{
			for(int j=i; j<=zero.size(); j++)
			{
				if(i==j)
				{
					dp[i][j]=dp[i-1][j-1]+sum[i][j];
				}
				else
				{
					dp[i][j]=Math.min(dp[i][j-1], dp[i-1][j-1]+sum[i][j]);
				}
			}
		}
		System.out.println(dp[one.size()][zero.size()]);
//		f(0,0,one,zero,0);
		//for(int d[]:dp)print(d);
		
	}	
	
	
	


	

	
	
	
	
	

	
	
	
	

	static 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

","import java.io.*;
import java.util.*;

public class Armchairs {
    static final int INF = 1000000000;
    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        PrintWriter writer = new PrintWriter(System.out, false);
        int N = reader.nextInt();
        int[] A = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = reader.nextInt();
        }
        List<Integer> occupied = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            if (A[i] == 1) occupied.add(i);
        }
        int K = occupied.size();
        int[][] dp = new int[N + 1][K + 1];
        for (int[] row : dp) Arrays.fill(row, INF);
        dp[0][0] = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j <= K; j++) {
                int x = j < K ? occupied.get(j) : 0;
                dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
                if (j + 1 <= K && A[i] == 0) {
                    dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], dp[i][j] + Math.abs(i - x));
                }
            }
        }
        writer.println(dp[N][K]);
        writer.close();
        System.exit(0);
    }
    
}
",0,Non-plagiarised
01c915a2,4e5ee0f7,"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.io.*;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {







    public static void main(String[] args) throws IOException {

//        try {
//             Scanner in = new Scanner(System.in) ;
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);



            int t = in.nextInt() ;
            while (t-- > 0){
                int n = in.nextInt() ;
                int dp[][] = new int[n][5] ;
                String tt[] = new String[n] ;

                for (int i = 0; i <n ; i++) {
                    String  s= in.next() ;
                    tt[i] = s ;
                    for (int j = 0; j <s.length() ; j++) {
                        dp[i][s.charAt(j)-'a']++ ;
                    }
                }
                int max = 0 ;


                for (int i = 0; i <5 ; i++) {
                    ArrayList<Integer>list = new ArrayList<>() ;
                    for (int j = 0; j <n ; j++) {
                        list.add(dp[j][i] - (tt[j].length()-dp[j][i]) );
                    }
                    list.sort(Collections.reverseOrder());
                    int ans = 0 ;
                    int sum = 0 ;
                    for (int curr : list){
                        sum+= curr ;
                        if (sum > 0){
                            ans++ ;
                            max = max(max , ans) ;
                        }
                        else break;
                    }

                }

                System.out.println(max);
            }










            out.flush();
            out.close();


//        } catch (Exception e) {
//            return;
//        }

}

    

    

    static void sort(int ar[]) {
        int n = ar.length;
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    

    

    

    


    


}
",0,Non-plagiarised
1c90c367,e52863b8,"import java.io.BufferedReader;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import java.io.*;

public class abc {
	static PrintWriter pw;

	static long x = 1, y = 1;

	/*
	 * static long inv[]=new long[1000001]; static long dp[]=new long[1000001];
	 */
	/// MAIN FUNCTION///
	public static void main(String[] args) throws Exception {

		FastReader sc = new FastReader();
		pw = new PrintWriter(System.out);
		// use arraylist as it uses the concept of dynamic table(amortized analysis)
		// Arrays.stream(array).forEach(a -> Arrays.fill(a, 0));
		/* List<Integer> l1 = new ArrayList<Integer>(); */
		// Random rand = new Random();
		int tst = sc.nextInt();
		while(tst-->0) {
			int n=sc.nextInt();
			int app[]=new int[n];
			int h[]=new int[n];
			for(int i=0;i<n;i++)
			{
				app[i]=sc.nextInt();
			}
			for(int i=0;i<n;i++)
			{
				h[i]=sc.nextInt();
			}
			long man = 0;
			long last = app[n - 1] - h[n - 1] + 1;
			int end = n-1;
			for (int i = n-2; i >=0; i--) {
				if(app[i]>=last) {
					last = Math.min(last,app[i] - h[i] + 1);
				}
				else {
					long s = app[end]-last+1;
					man += (s*(s+1))/2;
					end = i;
					last = app[i] - h[i] + 1;;
				}
			}
			long s = app[end]-last+1;
			man += (s*(s+1))/2;
			pw.println(man);
		}
		pw.flush();
	}

	

	

	

	

	

	

	

	

	// ch.charAt(i)+"""" converts into a char sequence
	

	

	

	

	

	

	

	

	// modular exponentiation
	

	

	/*
	 * public static void extract(ArrayList<Integer> ar, int k, int d) { int c = 0;
	 * for (int i = 1; i < k; i++) { int x = 0; boolean dm = false; while (x > 0) {
	 * long dig = x % 10; x = x / 10; if (dig == d) { dm = true; break; } } if (dm)
	 * ar.add(i); } }
	 */

	

// counts the set(1) bit of a number
	

//tells whether a particular index has which bit of a number	
	

	

	

//use collections.swap for swapping 
	

	

	

	// return the hash value of a string
	

}
","import java.util.*;
import java.io.*;

public class q3{
    static FastScanner fs = new FastScanner();
    static PrintWriter pw = new PrintWriter(System.out);

    static int[] sec;
    static int[] health;
    static int[] pp;
    public static void main(String[] args){
        int T = fs.nextInt();
        for (int tt=0;tt<T;tt++){
            int n = fs.nextInt();
            sec = new int[n];
            health = new int[n];

            for (int i=0;i<n;i++) sec[i] = fs.nextInt();
            for (int i=0;i<n;i++) health[i] = fs.nextInt();

            pp = new int[]{sec[n-1]-health[n-1]+1, sec[n-1], health[n-1]};

            long sum = 0;
            for (int i=n-2;i>=0;i--){
                int left = sec[i] - health[i] + 1, right = sec[i], top = health[i];

                if (right < pp[0]){
                    sum += ((long)pp[2] + 1) * (long)pp[2] / 2;
                    pp = new int[]{left, right, top};
                }
                else if (left < pp[0]){
                    pp[0] = left;
                    pp[2] = top + (pp[1] - right);
                }
            }
            sum += ((long)pp[2] + 1) * (long)pp[2] / 2;

            pw.println(sum);
        }



        pw.close();
    }

//    ----------input function----------

    

    
}
",0,Non-plagiarised
4e5ee0f7,d6fb3b9e,"import java.io.*;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {







    public static void main(String[] args) throws IOException {

//        try {
//             Scanner in = new Scanner(System.in) ;
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);



            int t = in.nextInt() ;
            while (t-- > 0){
                int n = in.nextInt() ;
                int dp[][] = new int[n][5] ;
                String tt[] = new String[n] ;

                for (int i = 0; i <n ; i++) {
                    String  s= in.next() ;
                    tt[i] = s ;
                    for (int j = 0; j <s.length() ; j++) {
                        dp[i][s.charAt(j)-'a']++ ;
                    }
                }
                int max = 0 ;


                for (int i = 0; i <5 ; i++) {
                    ArrayList<Integer>list = new ArrayList<>() ;
                    for (int j = 0; j <n ; j++) {
                        list.add(dp[j][i] - (tt[j].length()-dp[j][i]) );
                    }
                    list.sort(Collections.reverseOrder());
                    int ans = 0 ;
                    int sum = 0 ;
                    for (int curr : list){
                        sum+= curr ;
                        if (sum > 0){
                            ans++ ;
                            max = max(max , ans) ;
                        }
                        else break;
                    }

                }

                System.out.println(max);
            }










            out.flush();
            out.close();


//        } catch (Exception e) {
//            return;
//        }

}

    

    

    static void sort(int ar[]) {
        int n = ar.length;
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < n; i++)
            a.add(ar[i]);
        Collections.sort(a);
        for (int i = 0; i < n; i++)
            ar[i] = a.get(i);
    }

    

    

    

    


    


}
","import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
",0,Non-plagiarised
b185d034,ccc8ef27,"import java.io.*;
import java.util.*;
public class A734C {
    public static void main(String[] args) {
        JS scan = new JS();
        int t = scan.nextInt();
        loop:while(t-->0){
            int n = scan.nextInt();
            String[] arr= new String[n];
            Integer[][] counts = new Integer[5][n];
            for(int i = 0;i<5;i++){
                for(int j = 0;j<n;j++){
                    counts[i][j] = 0;
                }
            }
            for(int i =0;i<n;i++){
                arr[i] = scan.next();
                int[] freq =new int[5];
                for(int j = 0;j<arr[i].length();j++){
                    freq[arr[i].charAt(j)-'a']++;
                }
                for(int j = 0;j<5;j++){
                    counts[j][i] = freq[j]-(arr[i].length()-freq[j]);
                }
            }
            int best = 0;
            for(int i = 0;i<5;i++){
                Arrays.sort(counts[i]);
                int curr = 0;
                int extra = 0;
                for(int j = n-1;j>=0;j--){
                    extra+=counts[i][j];
                    if(extra>0)curr++;
                }
                best = Math.max(best,curr);
            }
            System.out.println(best);

        }
    }
    
}
","import java.util.*;
public class Sol
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
        {
			int n = sc.nextInt();
			int a[][]=new int[n][5];
			int tot[]=new int[n];
			for(int i=0;i<n;i++)
			{
				String x = sc.next();
				for(int j=0;j<x.length();j++)
					a[i][x.charAt(j)-'a'] += 1;
				tot[i]=x.length();
			}
			
			int max=Integer.MIN_VALUE;
			for(int i=0;i<5;i++)
				max=Math.max(max,function(a,n,i,tot));
			System.out.println(max);
			
		}	
    }
	static int function(int a[][],int n,int i,int tot[])
	{
		Integer ans[] = new Integer[n];
		for(int j=0;j<n;j++)
			ans[j]=a[j][i]-(tot[j]-a[j][i]);
		int res=0,j=0;
		Arrays.sort(ans,Collections.reverseOrder());
		while(j<n&&res+ans[j]>0)
			res+=ans[j++];
		return j;
	}
}
",0,Non-plagiarised
5a81e159,d82fa7e3,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class C_CF {

    public static void main(String[] args) {
        FastScanner57 fs = new FastScanner57();
        PrintWriter pw = new PrintWriter(System.out);
        int t = fs.ni();
        //int t = 1;
        for (int tc = 0; tc < t; tc++) {
            int n = fs.ni();
            long[][] lr = new long[n][2];
            for (int i = 0; i < n; i++) {
                lr[i][0] = fs.nl();
                lr[i][1] = fs.nl();
            }
            List<List<Integer>> list = new ArrayList();
            for (int i = 0; i < n;i ++) {
                List<Integer> temp = new ArrayList();
                list.add(temp);
            }
            for (int i = 0; i < n-1; i++) {
                int a = fs.ni()-1, b = fs.ni()-1;
                list.get(a).add(b);
                list.get(b).add(a);
            }
            Long[][] dp = new Long[n][2];
            pw.println(recur(0,0,-1,new long[] {0,0},dp,lr,list));
        }
        pw.close();

    }
    // 0 -> left was chosen
    // 1 -> right was chosen
    public static long recur(int ind, int p,int prev, long[] v, Long[][] dp, long[][] lr,List<List<Integer>> list) {

        long last = v[0];
        long ls = 0L;
        long rs = 0L;
        if (p==1) {
            last = v[1];
        }
        if (ind!=0) ls += (long)Math.abs(last-lr[ind][0]);
        if (ind!=0) rs += (long)Math.abs(last-lr[ind][1]);
        if (dp[ind][p]!=null) return dp[ind][p];
        long[] cur = lr[ind];
        
        List<Integer> temp = list.get(ind);
        for (int val : temp) {
            if (prev==val) continue;
            ls += recur(val,0,ind,cur,dp,lr,list);
            rs += recur(val,1,ind,cur,dp,lr,list);
        }
        return dp[ind][p] = Math.max(ls,rs);
    }

    

    

}




","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CParsasHumongousTree solver = new CParsasHumongousTree();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class CParsasHumongousTree {
        int n;
        long[][] dp;
        int[] l;
        int[] r;
        ArrayList<Integer>[] a;

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            n = in.nextInt();
            l = new int[n];
            r = new int[n];
            dp = new long[n][2];
            a = new ArrayList[n];
            for (int i = 0; i < n; ++i) {
                a[i] = new ArrayList<>();
            }

            for (int i = 0; i < n; ++i) {
                l[i] = in.nextInt();
                r[i] = in.nextInt();
            }

            for (int i = 0; i < n - 1; ++i) {
                int u = in.nextInt() - 1, v = in.nextInt() - 1;
                a[u].add(v);
                a[v].add(u);
            }

            dfs(0, -1);

            out.println(Math.max(dp[0][0], dp[0][1]));
        }

        void dfs(int u, int p) {
            dp[u][0] = dp[u][1] = 0;
            for (int v : a[u]) {
                if (v != p) {
                    dfs(v, u);
                    dp[u][0] += Math.max(dp[v][0] + Math.abs(l[u] - l[v]), dp[v][1] + Math.abs(l[u] - r[v]));
                    dp[u][1] += Math.max(dp[v][0] + Math.abs(r[u] - l[v]), dp[v][1] + Math.abs(r[u] - r[v]));
                }
            }
        }

    }

    
}
",0,Non-plagiarised
1ea771ea,ee270b2a,"import java.io.*;
import java.util.*;


public class CODECHEF {
    
    static long MOD=1000000000;
    
    static long[] solve(int[] pos,long[] arr,int n,int k){
        long[] ans=new long[n];
        long[] left=new long[n];
        long[] right=new long[n];
        long min=Integer.MAX_VALUE;
        for(int i=0;i<n;i++){
            min=Math.min(min+1,arr[i]);
            left[i]=min;
        }
        min=Integer.MAX_VALUE;
        for(int i=n-1;i>=0;i--){
            min=Math.min(min+1,arr[i]);
            right[i]=min;
        }
        for(int i=0;i<n;i++){
            ans[i]=Math.min(left[i],right[i]);
        }
        return ans;


    }


    public static void main(String[] args) throws java.lang.Exception {
         FastReader fs=new FastReader(System.in);
//       StringBuilder sb=new StringBuilder();
//       PrintWriter out=new PrintWriter(System.out);
         int t=fs.nextInt();
         while (t-->0){
            int n=fs.nextInt();
            int k=fs.nextInt();
            int[] pos=new int[k];
            for(int i=0;i<k;i++)
                pos[i]=fs.nextInt()-1;
            long[] temp=new long[n];
            int ptr=0;
            Arrays.fill(temp,Integer.MAX_VALUE);
             for(int i=0;i<k;i++)
                 temp[pos[ptr++]]=fs.nextLong();
             long[] ans=solve(pos,temp,n,k);
             for(int i=0;i<n;i++)
                 System.out.print(ans[i]+"" "");
             System.out.println();

         }
        //out.close;
    }
}
","import java.util.*;

public class D{
    private static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args){
        int q = scanner.nextInt();
        while(q-- > 0){
            int n = scanner.nextInt(),
            k = scanner.nextInt();
            int[] a = new int[k];
            for(int i=0;i<k;i++){
                a[i] = scanner.nextInt();
            }
            int[] t = new int[k];
            for(int j=0;j<k;j++){
                t[j] = scanner.nextInt();
            }
            long[] L = new long[n];
            long[] R = new long[n];
            for(int i=0;i<n;i++){
                L[i] = Integer.MAX_VALUE;
                R[i] = Integer.MAX_VALUE;
            }
            for(int i=0;i<k;i++){
                L[a[i]-1] = t[i];
                R[a[i]-1] = t[i];
            }
            
            long min = Integer.MAX_VALUE;
            for(int i=0;i<n;i++){
                L[i] = Math.min(min+1,L[i]);
                min = L[i];
            }
            min = Integer.MAX_VALUE;
            for(int i=n-1;i>=0;i--){
                R[i] = Math.min(min+1,R[i]);
                min = R[i];
            }
            for(int i=0;i<n;i++){
                System.out.print(Math.min(L[i],R[i]) + "" "");
            }
            System.out.println();
        }
    }
}
",1,Plagiarised
7814575b,b55888de,"import java.io.*;
import java.util.*;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;

public class C {

    static int fval(String s, char x){
        int fx = 0, oth = 0;
        for(int i = 0; i<s.length(); i++){
            if(x == s.charAt(i)) fx++;
            else oth++;
        }
        return fx-oth;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        //int tst = 1;
        int tst = Integer.parseInt(br.readLine());
        long mod = (long)1e9+7;
        while(tst-->0){
            int n = Integer.parseInt(br.readLine());
            ArrayList<String> lst = new ArrayList<>();
            for(int i = 0; i<n; i++){
                lst.add(br.readLine());
            }
            int ans = 0;
            for(int i = 0; i<5; i++){
                char x = (char)(97+i);
                ArrayList<Integer> vals = new ArrayList<>();
                for(int j = 0; j<n; j++){
                    vals.add(fval(lst.get(j), x));
                }
                Collections.sort(vals, Collections.reverseOrder());
                int pt = -1, sum = 0;
                while(pt+1<n && sum+vals.get(pt+1)>0){
                    sum+=vals.get(++pt);
                }
                ans = max(ans, pt+1);
            }
            sb.append(ans).append('\n');
        }
        System.out.println(sb);
    }
}
","import java.lang.reflect.Array;
import java.util.*;
public class Rough {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);   
        int t = sc.nextInt();
        while (t-->0) {
            int n = sc.nextInt();
            sc.nextLine();
            String s[] = new String[n];
            int f[][] = new int[n][5];
            for (int i = 0; i < n; i++) {
                s[i]  = sc.nextLine();

                for (int j = 0; j < s[i].length(); j++) {
                    f[i][s[i].charAt(j)-'a']++;
                }
            }

            int ans = 0;
            for ( int i = 0; i < 5; i++) {
                ArrayList<Integer> al = new ArrayList<>();

                for (int j = 0; j < n; j++) {
                    int o = 0;
                    for (int k = 0; k < 5; k++) {
                        if(k != i)
                            o+=f[j][k];
                    }
                    al.add(f[j][i]-o);
                }

                Collections.sort(al,Collections.reverseOrder());

                int max = 0;
                int x = 0;
                for (int j = 0; j < n; j++) {
                    x+=al.get(j);
                    if(x<=0)break;
                    max++;
                }
                ans = Math.max(max,ans);
            }

            System.out.println(ans);
        }
        sc.close();
    }
}
",0,Non-plagiarised
8f30bfc3,af1b152e,"import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.StringJoiner;

public class Solution {

  private static List<Long> chairs;
  private static List<Long> folks;
  private static Long[] data;
  private static Long[][] cache;

  public static void main(String[] args) {
    Print print = new Print();
    Scan scan = new Scan();

    int n = scan.scanInt();
    data = scan.scan1dLongArray();
    chairs = new ArrayList<>();
    folks = new ArrayList<>();
    cache = new Long[n][n];

    for (int i = 0; i < n; i++) {
      if (data[i] == 0) {
        chairs.add((long) i);
      } else {
        folks.add((long) i);
      }
    }

    print.printLine(Long.toString(solve(folks, chairs, 0, 0)));
    print.close();
  }

  private static long solve(List<Long> folks, List<Long> chairs, int i, int j) {
    if (i == folks.size()) {
      return 0;
    }
    if (j == chairs.size()) {
      return Integer.MAX_VALUE;
    }

    if (cache[i][j] != null) {
      return cache[i][j];
    }

    return cache[i][j] = Math
        .min(Math.abs(folks.get(i) - chairs.get(j)) + solve(folks, chairs, i + 1, j + 1),
            solve(folks, chairs, i, j + 1));

  }


  static class Scan {

    private byte[] buf = new byte[1024];
    private int index;
    private InputStream in;
    private int total;

    public Scan() {
      in = System.in;
    }

    public int scan() {
      if (total < 0) {
        throw new InputMismatchException();
      }
      if (index >= total) {
        index = 0;
        try {
          total = in.read(buf);
        } catch (IOException ignored) {
        }
        if (total <= 0) {
          return -1;
        }
      }
      return buf[index++];
    }

    public int scanInt() {
      int integer = 0;
      int n = scan();
      while (isWhiteSpace(n)) {
        n = scan();
      }
      int neg = 1;
      if (n == '-') {
        neg = -1;
        n = scan();
      }
      while (!isWhiteSpace(n)) {
        if (n >= '0' && n <= '9') {
          integer *= 10;
          integer += n - '0';
          n = scan();
        } else {
          throw new InputMismatchException();
        }
      }
      return neg * integer;
    }

    

    

    

    

    

    

    

    public Long[] scan1dLongArray() {
      String[] s = this.scanString().split("" "");
      Long[] arr = new Long[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Long.parseLong(s[i]);
      }
      return arr;
    }

    

    public String scanString() {
      StringBuilder sb = new StringBuilder();
      int n = scan();
      while (isWhiteSpace(n)) {
        n = scan();
      }
      while (!isWhiteSpace(n)) {
        sb.append((char) n);
        n = scan();
      }
      return sb.toString();
    }

    private boolean isWhiteSpace(int n) {
      if (n == '\n' || n == '\r' || n == '\t' || n == -1) {
        return true;
      }
      return false;
    }
  }

  

}
","import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.StringJoiner;

public class D {

  private static List<Long> chairs;
  private static List<Long> folks;
  private static Long[] data;
  private static Long[][] cache;

  public static void main(String[] args) {
    Print print = new Print();
    Scan scan = new Scan();

    int n = scan.scanInt();
    data = scan.scan1dLongArray();
    chairs = new ArrayList<>();
    folks = new ArrayList<>();
    cache = new Long[n][n];

    for (int i = 0; i < n; i++) {
      if (data[i] == 0) {
        chairs.add((long) i);
      } else {
        folks.add((long) i);
      }
    }

    print.printLine(Long.toString(solve(folks, chairs, 0, 0)));
    print.close();
  }

  private static long solve(List<Long> folks, List<Long> chairs, int i, int j) {
    if (i == folks.size()) {
      return 0;
    }
    if (j == chairs.size()) {
      return Integer.MAX_VALUE;
    }

    if (cache[i][j] != null) {
      return cache[i][j];
    }

    return cache[i][j] = Math
        .min(Math.abs(folks.get(i) - chairs.get(j)) + solve(folks, chairs, i + 1, j + 1),
            solve(folks, chairs, i, j + 1));

  }


  static class Scan {

    private byte[] buf = new byte[1024];
    private int index;
    private InputStream in;
    private int total;

    public Scan() {
      in = System.in;
    }

    public int scan() {
      if (total < 0) {
        throw new InputMismatchException();
      }
      if (index >= total) {
        index = 0;
        try {
          total = in.read(buf);
        } catch (IOException ignored) {
        }
        if (total <= 0) {
          return -1;
        }
      }
      return buf[index++];
    }

    public int scanInt() {
      int integer = 0;
      int n = scan();
      while (isWhiteSpace(n)) {
        n = scan();
      }
      int neg = 1;
      if (n == '-') {
        neg = -1;
        n = scan();
      }
      while (!isWhiteSpace(n)) {
        if (n >= '0' && n <= '9') {
          integer *= 10;
          integer += n - '0';
          n = scan();
        } else {
          throw new InputMismatchException();
        }
      }
      return neg * integer;
    }

    

    

    

    

    

    

    

    public Long[] scan1dLongArray() {
      String[] s = this.scanString().split("" "");
      Long[] arr = new Long[s.length];
      for (int i = 0; i < s.length; i++) {
        arr[i] = Long.parseLong(s[i]);
      }
      return arr;
    }

    

    public String scanString() {
      StringBuilder sb = new StringBuilder();
      int n = scan();
      while (isWhiteSpace(n)) {
        n = scan();
      }
      while (!isWhiteSpace(n)) {
        sb.append((char) n);
        n = scan();
      }
      return sb.toString();
    }

    private boolean isWhiteSpace(int n) {
      if (n == '\n' || n == '\r' || n == '\t' || n == -1) {
        return true;
      }
      return false;
    }
  }

  

}
",1,Plagiarised
14b0fb8e,8ddb5587,"import java.io.*;

import java.util.*;
 public class Solution {
	 
	static long res;
	public static void main(String[] args) throws Exception
    {
		FastReader fr=new FastReader();
        int n=fr.nextInt();
        ArrayList<Integer> oc=new ArrayList<>();
        ArrayList<Integer> em=new ArrayList<>();
        res=Long.MAX_VALUE;
        for(int i=0;i<n;i++) {
        	int v=fr.nextInt();
        	if(v==1)
        		oc.add(i);
        	else
        		em.add(i);
        }
        Collections.sort(oc);
        Collections.sort(em);
        long dp[][]=new long[5001][5001];
        for(int i=0;i<dp.length;i++) {
        	for(int j=0;j<dp[i].length;j++) {
        		dp[i][j]=-1;
        	}
        }
        System.out.println(getMin(oc,em,0,0,dp));
        
        
		
    }
	public static long getMin(ArrayList<Integer> oc,ArrayList<Integer> em,int idx,int j,long dp[][]) {
	   if(idx==oc.size())
		   return 0;
		long available=em.size()-j;
		long req=oc.size()-idx;
		if(available<req)
			return Integer.MAX_VALUE;
		if(dp[idx][j]!=-1)
			return dp[idx][j];
		
		long ch1=getMin(oc,em,idx,j+1,dp);
		long ch2=getMin(oc,em,idx+1,j+1,dp)+Math.abs(em.get(j)-oc.get(idx));
		
		return dp[idx][j]=Math.min(ch1,ch2);
		
	}
	
		
	
	 

	
	 
	 
	 
	 
	 
	 
	 
	
		
	 
	 
	 
	 
	 
	
	 
	 
	
	 
	 
            	  
             
             
    }


	
	 
	
	

	 
 
  


","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
 
public class taskd {
    public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        taskd sol = new taskd();
        sol.solve(in, out);
        out.flush();
    }

    void solve(FastScanner in, PrintWriter out) {
        int n = in.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (x == 1) {
                a.add(i);
            } else {
                b.add(i);
            }
        }

        long dp[][] = new long[a.size() + 5][b.size() + 5];
        for (int i = a.size()-1; i >= 0; i--) {
            dp[i][b.size()] = Integer.MAX_VALUE;
            for (int j = b.size()-1; j >= 0; j--) {
                dp[i][j] = dp[i][j + 1];
                dp[i][j] = Math.min(dp[i][j], Math.abs(a.get(i) - b.get(j)) + dp[i + 1][j + 1]);
            }
        }
        out.println(dp[0][0]);
    }

    
}
",0,Non-plagiarised
72d4d693,ad2a1ae2,"import java.util.*;
import java.lang.*;
import java.io.*;




public class Codechef
{
    
       
     
    public static void main (String[] args) throws java.lang.Exception
    {
 
       try{
        FastReader sc=new FastReader();
        BufferedWriter out = new BufferedWriter(
            new OutputStreamWriter(System.out));
        int t=sc.nextInt();
        while(t-->0)
        {
            
            int n = sc.nextInt();
            
            int k[] = new int[n];
            for(int i=0;i<n;i++)
            {
                k[i] = sc.nextInt();
            }
            int h[] = new int[n];
            for(int i=0;i<n;i++)
            {
                h[i] = sc.nextInt();
            }
            
            
        long tail = k[n-1];
        long span = h[n-1];
            
            long ans = 0;
            
            for(int i=n-2;i>=0;i--)
            {
                if((tail-span)+1>k[i])
                {
                    ans+=(span*(span+1))/2;
                    tail=k[i];
                    span=h[i];
                }
                else if((tail-span)+1<=((k[i]-h[i])+1))
                {
                    continue;
                }
                else
                {
                    span+=(((tail-span)+1) - ((k[i]-h[i])+1));
                }
            }
            
            ans+=(span*(span+1))/2;
            
            System.out.println(ans);
            
        }
    }catch(Exception e){
            return;
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.StringTokenizer;
 
public class Solution {
	 
	 
	public static void main(String[] args) {
		FastReader sc = new FastReader();
       
        int t=sc.nextInt();
       while(t-->0) {
    	   int n=sc.nextInt();
    	   int r[]=new int[n];
    	   int l[]=new int[n];
    	   for(int i=0;i<n;i++) {
    		   r[i]=sc.nextInt();
    	   }
    	   for(int i=0;i<n;i++) l[i]=r[i]-sc.nextInt()+1;
    	   long ans=0,min=l[n-1],max=r[n-1];
    	   
    	   for(int i=n-2;i>=0;i--) {
    		   if(r[i]>=min) min=Math.min(min,l[i]);
    		   else {
    			   ans+=(max-min+1)*(max-min+2)/2;
    			   max=r[i];
    			   min=l[i];
    		   }
    		   
    	   }
    	   ans+=(max-min+1)*(max-min+2)/2;
    	   System.out.println(ans);
    	   
    	   
       }
}	
}
",0,Non-plagiarised
26e699de,90dc2b20,"import java.util.Scanner;

public class Menorah {
    static int MOD9= 1000000000;

    public static void main(String[] args){

        Scanner sc= new Scanner(System.in);
        int numberTest=sc.nextInt();
        while(numberTest-->0){
            int n=sc.nextInt();
            char[] s=new char[n+5];
            char[] t=new char[n+5];
            String ss=sc.next();
            String tt=sc.next();
            s=ss.toCharArray();
            t=tt.toCharArray();
            int cntax = 0, cntbx = 0, same = 0;
            int ans=MOD9;
            for(int i=0; i<n; i++){
                if(s[i]=='1')cntax++;
                if(t[i]=='1')cntbx++;
                if(s[i]==t[i])same++;
            }
            if(same==n){
                System.out.println(0);
                continue;
            }
            else if (cntax==0){
                System.out.println(-1);
                continue;
            }
            if(cntax==cntbx){
                ans=Math.min(ans,n-same);
            }
            if(n-cntax+1==cntbx)ans=Math.min(ans,same);
            if(ans<MOD9) System.out.println(ans);
            else System.out.println(-1);



        }

    }
}
","import java.util.*;
import java.io.*;
public class C1615{
	static FastScanner fs = null;
	public static void main(String[] args) {
		fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int t = fs.nextInt();
		while (t-->0) {
			int n = fs.nextInt();
			String a = fs.next();
			String b = fs.next();
			char ch1[] = a.toCharArray();
			char ch2[] = b.toCharArray();
			int c00 = 0;
			int c01 = 0;
			int c10 = 0;
			int c11 = 0;
			for(int i=0;i<n;i++){
				if(ch1[i]=='0'){
					if(ch2[i]=='0'){
						c00+=1;
					}
					else{
						c01+=1;
					}
				}
				else{
					if(ch2[i]=='0'){
						c10+=1;
					}
					else{
						c11+=1;
					}
				}
			}
			int ans = -1;
			if((c11-c00)==1 || c10==c01){
				int s1 = (int)1e7; 
				int s2 = (int)1e7;
				if((c11-c00)==1){
					s1 = c11+c00;
				}
				if(c10==c01)
				s2 = c10+c01;
				ans = Math.min(s1,s2); 
			}
			out.println(ans);
		}
		out.close();
	}
	
	
}
",0,Non-plagiarised
480de7be,f4757480,"import java.util.StringTokenizer;
import java.io.*;

public class CF_1551c{
    public static final void main(String[] args){
        Kattio io= new Kattio();
        int t= io.getInt();
        while(t-->0){
            int n= io.getInt();
            int[][] ps= new int[5][n];
            for(int i=0; i<n; i++){
                String w= io.getWord();
                int len= w.length();
                // count letters
                for(int j=0; j<len; j++)
                    ps[w.charAt(j)-'a'][i]++;   
                // calculate diffs letter-!letter
                // e.g. a-!a = a-(a+b+c+d+e-a) = a-(len-a) = a + (a-len) = 2a-len
                for(int k=0; k<5; k++)
                    ps[k][i]+= ps[k][i]-len;   
            }
            //sort diffs
            for(int k=0; k<5; k++)
                mergeSort(ps[k]);
            //calculate prefix sums of diffs (until they're non-positive)
            //start from the end as sort is ascending
            //pick largest index out of 5 letter at which sum of diffs is positive
            int max= 0;
            for(int k=0; k<5; k++){
                if(ps[k][n-1]<=0) continue;
                if(max==0) max= 1;
                for(int i=2; i<=n; i++){
                    ps[k][n-i]+= ps[k][n-i+1];
                    if(ps[k][n-i]<=0) break;
                    if(i>max) max= i;
                }
            }
            io.println(max);
        }
        io.close();
    }

    // using mergeSort to avoid Java quicksort TLE hacks
    static void mergeSort(int arr[]){
        int n= arr.length;
        for (int sz= 1; sz<=n-1; sz=2*sz){
            for (int l= 0; l<n-1; l+=2*sz){
                int m= Math.min(l + sz-1, n-1);
                int r= Math.min(l + 2*sz-1, n-1);
                int n1= m-l+1, n2= r-m;
                int L[] = new int[n1];
                for (int i= 0; i<n1; i++) L[i]= arr[l+i];
                int R[] = new int[n2];
                for (int j= 0; j<n2; j++) R[j]= arr[m+1+j];
                int i= 0, j= 0, k= l;
                for(;i<n1 && j<n2; k++){
                    if(L[i]<=R[j]){arr[k]= L[i]; i++;}
                    else{arr[k] = R[j]; j++;}
                }
                for(;i<n1; i++, k++) arr[k]= L[i];
                for(;j<n2; j++, k++) arr[k]= R[j];
            }
        }
    }    
    
    static class Kattio extends PrintWriter {
        private BufferedReader r;
        private String line, token;
        private StringTokenizer st;
    
        public Kattio(){this(System.in);}
        public Kattio(InputStream i){
        super(new BufferedOutputStream(System.out));
            r= new BufferedReader(new InputStreamReader(i));
        }
        public Kattio(InputStream i, OutputStream o){
        super(new BufferedOutputStream(o));
            r= new BufferedReader(new InputStreamReader(i));
        }
        
        public boolean 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;
        }
    }
}
","import java.util.*;
import java.io.*;

public class CF_1551c{
    public static final void main(String[] args){
        Kattio io= new Kattio();
        int t= io.getInt();
        while(t-->0){
            int n= io.getInt();
            int[][] ps= new int[5][n];
            for(int i=0; i<n; i++){
                String w= io.getWord();
                int len= w.length();
                // count letters
                for(int j=0; j<len; j++)
                    ps[w.charAt(j)-'a'][i]++;   
                // calculate diffs letter-!letter
                // e.g. a-!a = a-(a+b+c+d+e-a) = a-(len-a) = a + (a-len) = 2a-len
                for(int k=0; k<5; k++)
                    ps[k][i]+= ps[k][i]-len;   
            }
            //sort diffs
            for(int k=0; k<5; k++)
                //mergeSort(ps[k]);
                Arrays.sort(ps[k]);
            //calculate prefix sums of diffs (until they're non-positive)
            //start from the end as sort is ascending
            //pick largest index out of 5 letter at which sum of diffs is positive
            int max= 0;
            for(int k=0; k<5; k++){
                if(ps[k][n-1]<=0) continue;
                if(max==0) max= 1;
                for(int i=2; i<=n; i++){
                    ps[k][n-i]+= ps[k][n-i+1];
                    if(ps[k][n-i]<=0) break;
                    if(i>max) max= i;
                }
            }
            io.println(max);
        }
        io.close();
    }

    // using mergeSort to avoid Java quicksort TLE hacks
        
    
    static 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;
        }
    }
}
",1,Plagiarised
5d175166,d1391025,"import java.io.*;
import java.util.*;

public class A {
    //--------------------------INPUT READER---------------------------------//

    //-----------------------------------------------------------------------//

    //---------------------------PRINTER-------------------------------------//

    //--------------------------VARIABLES------------------------------------//
    static FastReader sc = new FastReader();
    static OutputStream outputStream = System.out;
    //-----------------------------------------------------------------------//

    //--------------------------ADMIN_MODE-----------------------------------//
    private static void ADMIN_MODE() throws IOException {
        if (System.getProperty(""ONLINE_JUDGE"") == null) {
            sc = new FastReader(new FileInputStream(""input.txt""));
        }
    }
    //-----------------------------------------------------------------------//

    //----------------------------START--------------------------------------//
    public static void main(String[] args)
            throws IOException {

        ADMIN_MODE();

        int t = sc.ni();while(t-->0)
            solve();


    }

    static int[] res;
    static List<List<Integer>> graph;
    static boolean two = true;
    static HashMap<pr<Integer, Integer>, Integer> hm;

    static void solve() throws IOException {
        int n = sc.ni();
        graph = new ArrayList<>();
        res = new int[n-1];
        hm = new HashMap<>();
        for(int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }
        boolean f = false;
        for(int i = 0; i < n-1; i++) {
            int a = sc.ni(), b = sc.ni();
            graph.get(a).add(b);
            graph.get(b).add(a);
            if(graph.get(a).size() > 2 || graph.get(b).size() > 2) f = true;
            hm.put(new pr<>(a, b), i);
            hm.put(new pr<>(b, a), i);
        }

        if(f) {
            System.out.println(-1);
            return;
        }

        int one = 0;
        for(int i = 0; i < n; i++) {
            if(graph.get(i).size() == 1) {
                one = i;
                break;
            }
        }
        dfs(one, -1);
        for(int i: res) {
            System.out.println(i+"" "");
        }
        System.out.println();
    }

    static void dfs(int at, int pt) {
        List<Integer> li = graph.get(at);
        if(pt != -1) {
            res[hm.get(new pr<>(at, pt))] = two?2:3;
            two = !two;
        }
        for(int to: li) {
            if(to == pt) continue;
            dfs(to, at);
        }
    }

    static class pr <T, V> {
            T a; V b;

            public pr(T a, V b) {
                this.a = a;
                this.b = b;
            }

            

            
        }

}
","import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class C {

    static class scanner {
        static BufferedReader reader;
        static StringTokenizer tokenizer;
        static void init(InputStream input) {
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("""");
        }
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine());
            }
            return tokenizer.nextToken();
        }
        static int nextInt() throws IOException {return Integer.parseInt(next());}
        
        
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    static class Pair {int first, second;public Pair(int first, int second) {this.first = first;this.second = second;}}
    
    public static void main(String[] args) throws IOException {
        scanner.init(System.in);
        int t = 1;
        t = scanner.nextInt();
        while (t-- > 0) {
            solve();
        }
    }
    
    static void solve() throws IOException {
        int n = scanner.nextInt();
        List<List<Pair>> tree = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            tree.add(new ArrayList<>());
        }
        for (int i = 0; i < n-1; i++) {
            int u = scanner.nextInt()-1;
            int v = scanner.nextInt()-1;
            tree.get(u).add(new Pair(v, i));
            tree.get(v).add(new Pair(u, i));
        }
        int start = -1;
        for (int i = 0; i < n; i++) {
            if(tree.get(i).size() > 2) {
                System.out.println(-1);
                return;
            }
            else if(tree.get(i).size() == 1) {
                start = i;
            }
        }
        int[] res = new int[n-1];

        Queue<Integer> q = new LinkedList<>();
        q.add(start);
        int weight =  2, prev = -1;
        while (!q.isEmpty()) {
            int u = q.poll();
            for(Pair v : tree.get(u)) {
                if(v.first != prev) {
                    q.add(v.first);
                    res[v.second] = weight;
                    weight = 5 - weight;
                }
            }
            prev = u;
        }

        for(int i : res) {
            System.out.print(i + "" "");
        }
        System.out.println();

    }

   
}
",0,Non-plagiarised
5647d16e,ea09d197,"import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;
/*
-> Give your 100%, that's it!
-> Rules To Solve Any Problem:
    1. Read the problem.
    2. Think About It.
    3. Solve it!
*/

public class Template {
    
	static int mod = 1000000007;

	public static void main(String[] args){
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int N = 100001;
        int yo = sc.nextInt();
        while (yo-- > 0) {
            List<List<Integer>> list = new ArrayList<>();
            int n = sc.nextInt();
            for(int i = 0; i < n; i++){
                list.add(new ArrayList<>());
            }
            
            List<Pair> res = new ArrayList<>();
            for(int i = 0; i < n-1; i++){
                int u = sc.nextInt()-1;
                int v = sc.nextInt()-1;
                res.add(new Pair(u+1,v+1));
                list.get(v).add(u);
                list.get(u).add(v);
            }
            
            boolean ok = helper(0,list,n,-1);
            if(ok){
                out.println(-1);
                continue;
            }
            map.clear();
            dfs(0,list,n,-1,-1);
            for(Pair p : res){
                int x = p.x;
                int y = p.y;
                out.print(map.get(x + "" "" + y) + "" "" );
            }
            out.println();
            
        }
        out.close();
	}
    
    static Map<String,Integer> map = new HashMap<>();
    static void dfs(int curr, List<List<Integer>> list, int n, int par, int what){
        List<Integer> neighbours = list.get(curr);
        if(what == -1){
            boolean three = true;
            for(int e : neighbours){
                String str1 = (curr+1) + "" "" + (e+1);
                String str2 = (e+1) + "" "" + (curr+1);
                // out.println(str1);
                if(three){
                    map.put(str1,3); map.put(str2,3);
                    three = false;
                }
                else {
                    map.put(str1,2);map.put(str2,2);
                }
                dfs(e,list,n,curr,map.get(str1));
            }
        }
        else {
            for(int e : neighbours){
                if(e == par) continue;
                String str1 = (curr+1) + "" "" + (e+1);
                String str2 = (e+1) + "" "" + (curr+1);
                if(what == 2){
                    map.put(str1,3);map.put(str2,3);
                }
                else {
                    map.put(str1,2); map.put(str2,2);
                }
                dfs(e,list,n,curr,map.get(str1));
            }    
        }
        
    }
    
    static boolean helper(int curr, List<List<Integer>> list, int n, int par){
        if(par != -1){
            if(list.get(curr).size() >= 3){
                return true;
            }
        }
        else {
            if(list.get(curr).size() > 2){
                return true;
            }
        }
        List<Integer> neighbours = list.get(curr);
        for(int e : neighbours){
            if(e == par) continue;
            if(helper(e,list,n,curr)){
                return true;
            }
        }
        return false;
    }
   
    
    
    /*
    Source: hu_tao
         Random stuff to try when stuck:
            - use bruteforcer
            - check for n = 1, n = 2, so on
            -if it's 2C then it's dp
            -for combo/probability problems, expand the given form we're interested in
            -make everything the same then build an answer (constructive, make everything 0 then do something)
            -something appears in parts of 2 --> model as graph
            -assume a greedy then try to show why it works
            -find way to simplify into one variable if multiple exist
            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
            -find lower and upper bounds on answer
            -figure out what ur trying to find and isolate it
            -see what observations you have and come up with more continuations
            -work backwards (in constructive, go from the goal to the start)
            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
            -draw something
            -simulate a process
            -dont implement something unless if ur fairly confident its correct
            -after 3 bad submissions move on to next problem if applicable
            -do something instead of nothing and stay organized
            -write stuff down
         Random stuff to check when wa:
            -if code is way too long/cancer then reassess
            -switched N/M
            -int overflow
            -switched variables
            -wrong MOD
            -hardcoded edge case incorrectly
         Random stuff to check when tle:
            -continue instead of break
            -condition in for/while loop bad
         Random stuff to check when rte:
            -switched N/M
            -long to int/int overflow
            -division by 0
            -edge case for empty list/data structure/N=1
      */

	public static class Pair {
		int x;
		int y;

		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	

	

	

	

	public static void print(int[] arr, PrintWriter out) {
		//for debugging only
		for (int x : arr)
			out.print(x + "" "");
		out.println();
	}
    
    
    
    

	

	//	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 static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;

import java.util.*;
import java.io.*;
import java.math.*;


public class C{

    static int mod = (int) (Math.pow(10, 9)+7);
	static final int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
	static final int[] dx8 = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy8 = { -1, 0, 1, -1, 1, -1, 0, 1 };
	static final int[] dx9 = { -1, -1, -1, 0, 0, 0, 1, 1, 1 }, dy9 = { -1, 0, 1, -1, 0, 1, -1, 0, 1 };

	static final double eps = 1e-10;
	static List<Integer> primeNumbers = new ArrayList<>();
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

        //code below
        int test = sc.nextInt();
        while(test --> 0){
            int n = sc.nextInt();
            int[][] data = new int[n-1][2];

            Map<Integer, Integer> count = new HashMap<>();
            Graph g = new Graph(n+1);

            for(int i= 0; i < n-1; i++){
                int x = sc.nextInt();
                int y = sc.nextInt();

                data[i][0] = x;
                data[i][1] = y;

                g.addEdge(x, y);
            
                count.putIfAbsent(x, 0);
                count.put(x, count.get(x)+1);

                count.putIfAbsent(y, 0);
                count.put(y, count.get(y)+1);
            }

            //we will count 
            int one = 0;
            int two = 0;

            boolean flag = true;
            int start = 0;
            for(int i : count.keySet()){
                if(count.get(i) == 1){  
                    start = i;
                    one++;
                }else if(count.get(i) == 2){
                    two++;
                }else{
                    flag = false;
                    break;
                }
            }

            if(one != 2){
                flag = false;
            }

            if(!flag){
                out.println(-1);
                continue;
            }

            //now we know this question is solvable for sure
            //we do something really cool
            Map<Integer, ArrayList<Pair>> fuck = new HashMap<>();
            g.addData(start, fuck);
            
            for(int i = 0; i < n-1; i++){
                int x = data[i][0];
                int y = data[i][1];

                //search for the answer 
                ArrayList<Pair> temp = fuck.get(x);
                for(Pair curr : temp){
                    if(curr.a == y){
                        out.print(curr.b + "" "");
                        break;
                    }
                }
            }
            
            out.println();
        }


        out.close();
    }

    //Updation Required
    //Fenwick Tree (customisable)
    //Segment Tree (customisable)

    //-----CURRENTLY PRESENT-------//
    //Graph
    //DSU
    //powerMODe
    //power
    //Segment Tree (work on this one) 
    //Prime Sieve
    //Count Divisors
    //Next Permutation 
    //Get NCR 
    //isVowel
    //Sort (int)
    //Sort (long)
    //Binomial Coefficient
    //Pair
    //Triplet
    //lcm (int & long)
    //gcd (int & long)
    //gcd (for binomial coefficient)
    //swap (int & char)
    //reverse

    //Fast input and output 

    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------

    //GRAPH (basic structure)
    public static class Graph{
        public int V;
        public ArrayList<ArrayList<Integer>> edges;

        //2 -> [0,1,2] (current)
        Graph(int V){
            this.V  = V;
            edges = new ArrayList<>(V+1);
            for(int i= 0; i <= V; i++){
                edges.add(new ArrayList<>());
            }
        }

        public void addEdge(int from , int to){
            edges.get(from).add(to);
            edges.get(to).add(from);
        }

        public void addData(int start, Map<Integer, ArrayList<Pair>> fuck){
            //we will add stuff here
            int curr = start;
            int[] visited = new int[V+1];
            visited[curr] = 1;

            int index = 0;
            while(true){
                int make = 0;
                boolean last = true;
                for(int edge : edges.get(curr)){
                    if(visited[edge] == 1){
                        continue;
                    }else{
                        make = edge; 
                        last = false;
                        break;
                    }
                }

                if(last){
                    break;
                }

                //now we have found make, we make and add it in map
                fuck.putIfAbsent(curr, new ArrayList<>());
                fuck.putIfAbsent(make, new ArrayList<>());

                fuck.get(curr).add(new Pair(make, index %2 == 0 ? 2 : 3));
                fuck.get(make).add(new Pair(curr, index %2 == 0 ? 2 : 3));

                visited[make] = 1;
                curr = make;
                index++;
            }
        }
    }

    //DSU (path and rank optimised)
    

    //with mod
    

    //without mod
    

    

    //prime sieve
    

    //number of divisors
    

    //now adding next permutation function to java hehe
    

    //finding the value of NCR in O(RlogN) time and O(1) space
    

    //is vowel function 
       

    //to sort the array with better method
	

    //sort long
    
	
    //for calculating binomialCoeff
    

    //Pair with int int 
    public static class Pair{
        public int a;
        public int b;

        Pair(int a , int b){
            this.a = a;
            this.b = b;
        }

        
    }

    //Triplet with int int int
    

    //Shortcut function
    

    //let's make one for calculating lcm basically
    

    //int version for gcd
    

    //long version for gcd
    

     //for ncr calculator(ignore this code)
     

    //swapping two elements in an array
    

    //for char array
    

    //reversing an array
    


    

    //SOME EXTRA DOPE FUNCTIONS 
    

    

    
   
    

    

    //O(n) every single time remember that
    

    // ll *fact = new ll[2 * n + 1];
	// ll *ifact = new ll[2 * n + 1];
	// fact[0] = 1;
	// ifact[0] = 1;
	// for (ll i = 1; i <= 2 * n; i++)
	// {
	// 	fact[i] = mod_mul(fact[i - 1], i, MOD1);
	// 	ifact[i] = mminvprime(fact[i], MOD1);
	// }
    //ifact is basically inverse factorial in here!!!!!(imp)
    

  

     
    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;
      
    //-----------MyScanner class for faster input----------
    
   //--------------------------------------------------------
}
",0,Non-plagiarised
1071f735,cd835290,"import java.util.*;
//import java.util.Stack;
import java.io.BufferedReader;
import java.io.IOException;
//import java.io.*;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
public class Main {


    

    

     static class obj{
           long a1;
           long a2;
           //int a3;
           obj(long a1,long a2){
               this.a1=a1;
               this.a2=a2;
              // this.a3=a3;
           }
       }
       static  class sortby implements Comparator<obj>{
           
       }
    
    
    
    

    //static ArrayList<Integer>[] a;
   // static int[] vis;
    //static int[] col;
  /*  static boolean dfs(int i,int c){
        vis[i]=1;
        col[i]=c;
        //System.out.println(i+"" ""+c);
        for(int j:a[i]){
            if(vis[j]==0) {
                if (dfs(j, c ^ 1) == false)
                    return false;
            }
            else
                if(col[i]==col[j])
                    return false;
        }
        return true;
    }*/
   static int[] m;
    
   static long[][] dis;
   // static long d=1000000007;
   
    public static void main(String[] args) {
        FastReader s = new FastReader();
        //InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        //Scanner s=new Scanner(System.in);
         int t = s.nextInt();

        while(t-->0) {
            int n = s.nextInt();
            int m = s.nextInt();
            int x=s.nextInt();
            long[] a = new long[n];
            for(int i=0;i<n;i++){
                a[i]=s.nextInt();
            }
           out.println(""YES"");
            PriorityQueue<obj> p = new PriorityQueue<>(new sortby());
            for (int i = 0; i <m; i++) {
             p.add(new obj(a[i],i+1));
             out.print(i+1+"" "");
            }
            for(int i=m;i<n;i++){
                obj o=p.poll();
                p.add(new obj(o.a1+a[i],o.a2));
                out.print(o.a2+"" "");
            }
            out.println();
        }
       out.close();

}}
","import java.util.*;

public class CP {
    


    

    public static void printArr(int[] a){
        for(int i=0; i<a.length; i++){
            System.out.print(a[i]+1+"" "");
        }
        System.out.println();
    }

    public static class Pair implements Comparable<Pair> {
        int val;
        int idx;

        Pair(int a, int b){
            this.val = a;
            this.idx = b;
        }

        
    }


    public static void main(String[] args) {
        // CF1
        // Scanner sc = new Scanner(System.in);
        // int t = sc.nextInt();
        // for (int i = 0; i < t; i++) {
        //     int n = sc.nextInt();
        //     int x = sc.nextInt();
        //     int[] arr = new int[n];
        //     int sum = 0;
        //     for (int j = 0; j < n; j++) {
        //         arr[j] = sc.nextInt();
        //         sum += arr[j];
        //     }
        //     if (x == sum) {
        //         System.out.println(""NO"");
        //     } else if (x > sum) {
        //         System.out.println(""YES"");
        //         for (int j = 0; j < n; j++) {
        //             System.out.print(arr[j] + "" "");
        //         }
        //         System.out.println();
        //     } else {// x<sum
        //         Arrays.sort(arr);
        //         int curr = 0;
        //         int k = 0;
        //         while ((curr != x) && (k < n)) {
        //             curr += arr[k];
        //             k++;
        //         }
        //         if(k==n) {
        //             System.out.println(""YES"");
        //             for (int j = 0; j < n; j++) {
        //                 System.out.print(arr[j] + "" "");
        //             }
        //             System.out.println();
        //         }
        //         else if (curr == x) {
                    
        //             arr = swap(arr, k-1, n - 1);
        //             System.out.println(""YES"");
        //             for (int j = 0; j < n; j++) {
        //                 System.out.print(arr[j] + "" "");
        //             }
        //             System.out.println();
                
        //         }else{
        //             System.out.println(""NO"");
        //         }

        //     }

        // }



        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int i = 0; i < t; i++) {
            int n = sc.nextInt();
            int m=sc.nextInt();
            int x = sc.nextInt();
            int[] arr = new int[n];
            int[] ans = new int[n];
            for (int j = 0; j < n; j++) {
                        arr[j] = sc.nextInt();
            }
            PriorityQueue<Pair> pq=new PriorityQueue<>();
            for (int j = 0; j < m; j++) {
                pq.add(new Pair(arr[j],j));
                ans[j]=j;
    }
    for (int j = m; j < n; j++) {
        Pair p=pq.remove();
        pq.add(new Pair(p.val+arr[j],p.idx));
        ans[j]=p.idx;
        }
        System.out.println(""YES"");
        printArr(ans); 

    }
}
}
",1,Plagiarised
0c9d4def,d3415fc5,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class C{
    private static int maxWords = 0;
    private static int[][] words;
    private static int n;
    private static int[] netwrtchar(int index){
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<n; i++){
            int sum = 0;
            for(int j=0; j<words[i].length; j++){
                if(j==index) continue;
                sum += words[i][j];
            }
            list.add(words[i][index] - sum);
            // f[i] = words[i][index] - sum;
        }
        Collections.sort(list, Collections.reverseOrder());
        int[] f = new int[list.size()];
        for(int i=0; i<list.size(); i++){
            f[i] = list.get(i);
        }
        return f;
    }
    private static int maxWindow(int[] f){
        int count = 0, sum = 0;
        int index = 0;
        while(index<f.length && sum+f[index]>0){
            sum += f[index++];
            count++;
        }
        return count;
    }
    public static void main(String[] args){
        FS sc = new FS();
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while(t-->0){
            n = sc.nextInt();
            words = new int[n][5];
            maxWords = 0;
            for(int i=0; i<n; i++){
                String s = sc.next();
                for(int j=0; j<s.length(); j++){
                    words[i][s.charAt(j)-'a']++;
                }
            }
            int maxWindow = 0;
            for(int i=0; i<5; i++){
                int[] f = netwrtchar(i);
                int current = maxWindow(f);
                maxWindow = Math.max(maxWindow, current);
            }
            System.out.println(maxWindow);
        }
        pw.flush();
        pw.close();
    }

    
}
","import java.io.*;
import java.util.*;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class C {
    Reader source;
    BufferedReader br;
    StringTokenizer in;
    PrintWriter out;

    public String nextToken() throws Exception {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }
        return in.nextToken();
    }
    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }
    
    
    public void run() throws Exception {
        source = OJ ? new InputStreamReader(System.in) : new FileReader(""C.in"");
        br = new BufferedReader(source);
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }
    public static void main(String[] args) throws Exception {
        new C().run();
    }
    private boolean OJ = System.getProperty(""ONLINE_JUDGE"") != null;

    public void solve() throws Exception {
        int t = nextInt();
        while (t-- > 0) {
            int n = nextInt();
            int A[] = new int [n];
            int B[] = new int [n];
            int C[] = new int [n];
            int D[] = new int [n];
            int E[] = new int [n];
            for (int i = 0; i < n; i++) {
                String s = nextToken();
                int sz = s.length();
                int a = 0, b = 0, c = 0, d = 0, e = 0;
                for (int j = 0; j < sz; j++) {
                    if (s.charAt(j) == 'a') a++;
                    if (s.charAt(j) == 'b') b++;
                    if (s.charAt(j) == 'c') c++;
                    if (s.charAt(j) == 'd') d++;
                    if (s.charAt(j) == 'e') e++;
                }
                A[i] = a - b - c - d - e;
                B[i] = b - a - c - d - e;
                C[i] = c - a - b - d - e;
                D[i] = d - a - b - c - e;
                E[i] = e - a - b - c - d;
            }
            int ans = 0, sum;
            sum = 0;
            Collections.sort(A);
            for (int j = 0; j < n; j++) {
                sum += A[j];
                if (sum <= 0) {
                    ans = max(ans, j);
                    break;
                }
            }
            if (sum > 0) ans = n;
            sum = 0;
            Collections.sort(B);
            for (int j = 0; j < n; j++) {
                sum += B[j];
                if (sum <= 0) {
                    ans = max(ans, j);
                    break;
                }
            }
            if (sum > 0) ans = n;
            sum = 0;
            Collections.sort(C);
            for (int j = 0; j < n; j++) {
                sum += C[j];
                if (sum <= 0) {
                    ans = max(ans, j);
                    break;
                }
            }
            if (sum > 0) ans = n;
            sum = 0;
            Collections.sort(D);
            for (int j = 0; j < n; j++) {
                sum += D[j];
                if (sum <= 0) {
                    ans = max(ans, j);
                    break;
                }
            }
            if (sum > 0) ans = n;
            sum = 0;
            Collections.sort(E);
            for (int j = 0; j < n; j++) {
                sum += E[j];
                if (sum <= 0) {
                    ans = max(ans, j);
                    break;
                }
            }
            if (sum > 0) ans = n;
            System.out.println(ans);
        }
    }
}
",0,Non-plagiarised
597195ee,5f3a196a,"import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class C_MonstersAndSpells_1700 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while(t-->0) {
            int n = sc.nextInt();
            int[] times = new int[n];
            int[] health = new int[n];
            for(int i = 0; i < n; i++) {
                times[i] = sc.nextInt();
            }
            for(int i = 0; i < n; i++) {
                health[i] = sc.nextInt();
            }
            Point[] points = new Point[n];
            for(int i = 0; i < n; i++) {
                points[i] = new Point(times[i]-health[i], times[i]);
            }
            Arrays.sort(points);
            long ans = 0;
            for(int i = 0; i < n; i++) {
                int j = i+1;
                int latestTime = points[i].time;
                while(j < n && points[j].startBy < latestTime) {
                    latestTime = Math.max(latestTime, times[j]);
                    j++;
                }
                long length = latestTime-points[i].startBy;
                ans += (length*(length + 1))/2;
                i = j - 1;
            }
            System.out.println(ans);
        }

        out.close();
    }

    static class Point implements Comparable<Point> {
        Integer startBy;
        Integer time;

        Point(int startBy, int time) {
            this.startBy = startBy;
            this.time = time;
        }

        
    }

    public static PrintWriter out;

    
    
}
","import java.io.*;
import java.util.*;
public class MonstersAndSpells {
	public static PrintWriter out;
	public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        out=new PrintWriter(System.out);
        int t=Integer.parseInt(st.nextToken());
        while(t-->0) {
        	st=new StringTokenizer(br.readLine());
        	int n=Integer.parseInt(st.nextToken());//monsters
        	int time[]=new int[n];//time
        	int health[]=new int[n];//health
        	st=new StringTokenizer(br.readLine());
        	for(int i=0;i<n;i++) {
        		time[i]=Integer.parseInt(st.nextToken());
        	}
        	st=new StringTokenizer(br.readLine());
        	for(int i=0;i<n;i++) {
        		health[i]=Integer.parseInt(st.nextToken());
        	}
        	State a[]=new State[n];
        	for(int i=0;i<n;i++) {
        		a[i]=new State(time[i]-health[i], time[i]);
        	}
        	Arrays.sort(a);
        	long ans=0;
        	for(int i=0;i<n;i++) {
        		int j=i+1;
        		int max=a[i].time;
        		while(j<n&&a[j].x<max) {
        			max=Math.max(max, time[j]);
        			j++;
        		}
        		ans+=((long)(max-a[i].x)*(long)(max-a[i].x+1))/2;
        		i=j-1;
        	}
        	out.println(ans);
        }
        out.close();
	}
	static class State implements Comparable<State>{
		int x, time;
		public State(int x, int time) {
			this.x=x;this.time=time;
		}
		
	}
}
",1,Plagiarised
3afcc566,3dd65549,"import java.io.*;
import java.util.*;

import static java.lang.Math.*;

//Think through the entire logic before jump into coding!
//If you are out of ideas, take a guess! It is better than doing nothing!
//Read both C and D, it is possible that D is easier than C for you!

//Be aware of integer overflow!
//If you find an answer and want to return immediately, don't forget to flush before return!

public class C {
    static InputReader in;
    static PrintWriter out;

    public static void main(String[] args) {
        //initReaderPrinter(true);
        initReaderPrinter(false);
        solve(in.nextInt());
        //solve(1);        
    }

    static void solve(int testCnt) {
        for (int testNumber = 0; testNumber < testCnt; testNumber++) {
            int n = in.nextInt();
            char[] a = in.next().toCharArray(), b = in.next().toCharArray();
            int match0 = 0, match1 = 0, mismatch10 = 0, mismatch01 = 0;
            for(int i = 0; i < n; i++) {
                if(a[i] == b[i]) {
                    if(a[i] == '0') match0++;
                    else match1++;
                }
                else {
                    if(a[i] == '0') mismatch01++;
                    else mismatch10++;
                }
            }
            if(mismatch01 + mismatch10 == 0) out.println(0);
            else {
                if(match1 - match0 == 1 && mismatch01 == mismatch10) {
                    out.println(min(match0 + match1, mismatch01 + mismatch10));
                }
                else if(match1 - match0 == 1) {
                    out.println(match0 + match1);
                }
                else if(mismatch01 == mismatch10) {
                    out.println(mismatch01 + mismatch10);
                }
                else out.println(-1);
            }
        }
        out.close();
    }

    static void initReaderPrinter(boolean test) {
        if (test) {
            try {
                in = new InputReader(new FileInputStream(""src/input.in""));
                out = new PrintWriter(new FileOutputStream(""src/output.out""));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            in = new InputReader(System.in);
            out = new PrintWriter(System.out);
        }
    }

    
}
","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);
}
",0,Non-plagiarised
4f7af821,f870e76b,"import java.util.*;

public class contestA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        int inf = 1000300300;
        while (t-->0){
            int n = scanner.nextInt();
            int k = scanner.nextInt();
            int[] c = new int[n];
            Arrays.fill(c,inf);
            int[] a = new int[k];
            int[] b = new int[k];
            for(int i=0;i<k;++i) a[i] = scanner.nextInt() - 1;
            for(int i=0;i<k;++i) b[i] = scanner.nextInt();
            for(int i=0;i<k;++i) c[a[i]] = b[i];
            for(int i=1;i<n;++i){
                c[i] = Math.min(c[i],c[i-1]+1);
            }
            for(int i=n-2;i>=0;--i){
                c[i] = Math.min(c[i],c[i+1]+1);
            }
            for(int i=0;i<n;++i) System.out.print(c[i]+"" "");
            System.out.println();
        }
    }
}
","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;

public class Main {

	static InputStream inputStream = System.in;
	static OutputStream outputStream = System.out;
	static InputReader in = new InputReader(inputStream);
	static PrintWriter out = new PrintWriter(outputStream);

	public static void main(String[] args) {

		int t = in.nextInt();

		while (t-- > 0) {

			int n = in.nextInt();

			int k = in.nextInt();

			int[] v1 = new int[k];
			int[] v2 = new int[k];

			for (int i = 0; i < k; i++) {
				v1[i] = in.nextInt();
			}

			for (int i = 0; i < k; i++) {
				v2[i] = in.nextInt();
			}
			
			
			
			//wejhfduiwehiofhw

			int[] res = new int[n + 2];

			Arrays.fill(res, 2000000000);

			for (int i = 0; i < k; i++) {
				res[v1[i]] = v2[i];

			}

			for (int i = 1; i <= n; i++) {

				int val = Math.min(res[i], res[i - 1] + 1);

				res[i] = val;

			}
			
			//ewhfowiejp
			
			
			
			
			
			
			
			
			
			//wedhciuwahidochqowi
			
			
			
			
			
			
			
			
			//wjdhoiqwnlidhqw
			for (int i = n; i >= 1; i--) {
				int val1 = Math.min(res[i], res[i + 1] + 1);
				res[i] = val1;
				// out.println(res[i]);
			}

			for (int i = 1; i <= n; i++) {
				int r = res[i];
				out.print(r + "" "");

			}

			out.println();

		}

		out.close();
	}

	

	

}
",0,Non-plagiarised
ba468e1f,d9199dfd,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Codeforces {
    public static void main(String[] args) {
        FastReader fastReader = new FastReader();
        int t = fastReader.nextInt();
        while (t-- > 0) {
            int n = fastReader.nextInt();

            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = fastReader.nextInt();
            }
            ArrayList<Integer> b = new ArrayList<>();
            ArrayList<Integer> r = new ArrayList<>();
            char c[] = fastReader.next().toCharArray();
            for (int i = 0; i < n; i++) {
                if (c[i] == 'B') {
                    b.add(a[i]);
                } else {
                    r.add(a[i]);
                }
            }

            Collections.sort(b);
            Collections.sort(r);
            int sizeb = b.size();

            boolean isValid = true;
            for (int i = 1 , j = 0; i <=sizeb; i++ , j++){
                if (b.get(j) <  i){
                    isValid =false;
                }
            }

            for (int i = sizeb+1 , j = 0; i <=n && j < r.size(); i++ , j++){
                if (r.get(j) >  i){
                    isValid =false;
                }
            }

            if (isValid){
                System.out.println(""YES"");
            }else{
                System.out.println(""NO"");
            }
        }


    }

    
}
","import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class Simple{  
    public static void main(String args[]){  
        //System.out.println(""Hello Java"");
        Scanner s = new Scanner(System.in);
        int t = s.nextInt();
        while (t>0){
            
            int n = s.nextInt();
            int arr[] = new int[n];

            for(int i=0;i<n;i++){
                arr[i] = s.nextInt();
            }
            String str = s.next();

            //Arrays.sort(arr);
            ArrayList<Integer> blue = new ArrayList<>();
            ArrayList<Integer> red = new ArrayList<>();
            for(int i=0;i<n;i++){
                if(str.charAt(i)=='R'){
                    red.add(arr[i]);
                }
                else{
                    blue.add(arr[i]);
                }
            }
            Collections.sort(red);
            Collections.sort(blue);
            
            int start =1;

            boolean bool =true;
            for(int i=0;i<blue.size();i++){
                if(blue.get(i)<start){
                    bool = false;
                    break;
                }

                start++;
            }
            if(!bool){
                System.out.println(""NO"");
            }
            else{
                for(int i=0;i<red.size();i++){
                    if(red.get(i)>start){
                        bool = false;
                        break;
                    }
                    start++;
                }
                if(bool){
                    System.out.println(""YES"");
                }
                else{
                    System.out.println(""NO"");
                }
            }
            
            


            t--;
        }
        s.close();  
    }
    
}
",0,Non-plagiarised
22b41936,8f855b99,"import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Collections;
import java.io.InputStreamReader;
import static java.lang.Math.*;
import static java.lang.System.*;

public class Main1 {

     static ArrayList<Integer> list1 = new ArrayList<>() ;
     static ArrayList<Integer> list2 = new ArrayList<>() ;
     static int n , m ;
     static long dp[][] ;

     static long solver(int i , int j ){
         // i = empty chairs

         if (j == m)return 0 ;
         int tt1 = n-i ;
         int tt2 = m-j ;
         if (n-i < m-j)return  Long.MAX_VALUE/2  ;
         if ( dp[i][j] != -1 )return dp[i][j] ;

        long a = solver(i+1 , j) ;
        long b = abs( list1.get(i) - list2.get(j)) + solver(i+1 , j+1) ;

        return dp[i][j] = min(a , b) ;

     }



    public static void main(String[] args) throws IOException {

//        try {


            FastScanner in = new FastScanner();
            PrintWriter out = new PrintWriter(System.out);


            int N = in.nextInt() ;
            int a[] = in.readArray(N) ;
        for (int i = 0; i <N ; i++) {
            if (a[i] == 1)list2.add(i) ;
            else list1.add(i) ;
        }

         n = list1.size() ;
         m = list2.size() ;
            dp = new long[n][m] ;


            for(int i=0 ; i<n ; i++)
                for(int j=0 ; j<m ; j++)
                    dp[i][j] = -1 ;

     
        System.out.println(solver(0 , 0 ));








            out.flush();
            out.close();

//        }
//        catch (Exception e){
//            return;
//        }

    }

    

    static ArrayList<Integer> list = new ArrayList<>();
    static boolean A[] = new boolean[2 * 90000001];


    

    

    

    


    

    

    

    

    


    


    


    


}
","import javax.print.DocFlavor;
import java.util.*;
import java.lang.*;
import java.io.*;

public class Solution {
    static int N = 5005;
    static int[] arr = new int[N];
    static long[][] memo = new long[N][N];
    static List<Integer> occupiedSeats = new ArrayList<>();
    static List<Integer> emptySeats = new ArrayList<>();
    static int n, occSize, empSize;
    public static void main(String[] args) throws java.lang.Exception {
        out = new PrintWriter(new BufferedOutputStream(System.out));
        sc = new FastReader();
        int test = 1;
        for (int t = 0; t < test; t++) {
            solve();
        }
        out.close();
    }

    private static void solve() {
        n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            arr[i] = sc.nextInt();
            if (arr[i] == 1) {
                occupiedSeats.add(i);
            }else {
                emptySeats.add(i);
            }
        }
        occSize = occupiedSeats.size();
        empSize = emptySeats.size();
        for (long[] memset : memo) {
            Arrays.fill(memset, -1);
        }
        out.println(minimumTime(0, 0));
    }

    private static long minimumTime(int occupied, int empty) {
        if (occupied == occSize) {
            return 0;
        }
        if (empty == empSize) {
            return Integer.MAX_VALUE;
        }
        if (memo[occupied][empty] != -1) {
            return memo[occupied][empty];
        }
        long curr = Math.abs(occupiedSeats.get(occupied) - emptySeats.get(empty)) + minimumTime(occupied + 1, empty + 1);
        curr = Math.min(curr, minimumTime(occupied, empty + 1));
        memo[occupied][empty] = curr;
        return curr;
    }

    public static FastReader sc;
    public static PrintWriter out;
    
}
",0,Non-plagiarised
d1cd194e,dbffab11,"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();

		}
	
}
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public  class cses
{   
    static int mod=1000000007;
    static FastReader sc=new FastReader();
    public static void main (String[] args) throws java.lang.Exception
    {
        long startTime=System.currentTimeMillis();
        int t=sc.nextInt();
        for(int y=0;y<t;++y)
        {
           int n=sc.nextInt();
           int m=sc.nextInt();
           int x=sc.nextInt();
           int arr[]=arrayintinput(n);
           //PriorityQueue<Node> pq=new PriorityQueue<>();
           int index[]=new int[n];
           
           
           PriorityQueue<Node> pq =new PriorityQueue<Node>(new comp());           
           for(int i=0;i<m;++i)
           {
               pq.add(new Node(0,i+1));
           }
           for(int i=0;i<n;++i)
           {
            Node temp=pq.remove();
            temp.sum+=arr[i];
            index[i]=temp.build;
            pq.add(new Node(temp.sum,temp.build));
           }
           System.out.println(""YES"");
            for(int i=0;i<n;++i)
            {
                System.out.print(index[i]+"" "");    
            }  
            System.out.println();
        }
    //  getExecutionTime(startTime);
    }
    

    static int[] arrayintinput(int n)
    {
        int arr[]=new int[n];
        for(int i=0;i<n;++i)
        {
            arr[i]=sc.nextInt();
        }
        return arr;
    }
    static class comp implements Comparator<Node>{ 
        
    }
   static class Node{
    int sum;
    int build;
    Node(int sum ,int build)
    {
    this.sum=sum;
    this.build=build;
    }
    }

    
      
    
   
  

}
",0,Non-plagiarised
680ba922,f3d7ce08,"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 javax.swing.plaf.IconUIResource;
import java.lang.reflect.Array;
import java.text.CollationElementIterator;
import java.util.*;
import java.io.*;
 
//Timus judge id- 323935JJ
 
 
public class Main {
 
 
 
 
    //----------------------------------------------------------------------------------------------
    
 
 
    public static int mod = (int) (1e9 + 7);
    static int ans = Integer.MAX_VALUE;
 
    public static void main(String hi[]) throws Exception {
        FastReader sc = new FastReader();
        int t =sc.nextInt();
        while(t-->0)
        {
            int n =sc.nextInt();
            String a = sc.nextLine(),b=sc.nextLine();
 
            int count1=0,count2=0,count3=0,count4=0;
 
            for(int i=0;i<n;i++)
            {
                if(a.charAt(i)=='0'&&b.charAt(i)=='0')
                    count1++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='1')
                    count2++;
                else  if(a.charAt(i)=='1'&&b.charAt(i)=='0')
                    count3++;
                else  if(a.charAt(i)=='0'&&b.charAt(i)=='1')
                    count4++;
            }
            int ans=Integer.MAX_VALUE;
 
            if(count3==count4)
                ans=Math.min(count3*2,ans);
 
            if(count2==count1+1)
                ans=Math.min(ans,2*count1+1);
 
           
            if(ans==Integer.MAX_VALUE)
                System.out.println(-1);
            else System.out.println(ans);
 
        }
 
    }
 
    
 
 
 
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
 
    // method to return LCM of two numbers
    
 
 
    
}
",0,Non-plagiarised
141effef,6653a758,"import java.util.*;

public class ArmChairs {
	static int[]arr;
	static ArrayList<Integer>a;
	static ArrayList<Integer>b;
	static int dp[][];
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int n = scn.nextInt();
		arr=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=scn.nextInt();
		}
		dp=new int[n+1][n+1];
		a =new ArrayList<>();
		b =new ArrayList<>();
		for(int i=0;i<n;i++) {
			if(arr[i]==0) {
				a.add(i);
			}else{
				b.add(i);
			}
		}
		System.out.println(solve(0,0));	
	}
	
	public static int solve(int i,int j) {
		if(i==b.size()) {
			return 0;
		}
		if(j==a.size()) {
			return 100000000;
		}

		if(dp[i][j]!=0) {
			return dp[i][j];
		}
		int x=Math.abs(a.get(j)-b.get(i))+solve(i+1,j+1);
		int y=solve(i,j+1);
		return dp[i][j]=Math.min(x, y);
	}
	

}
","import java.util.*;
public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",0,Non-plagiarised
8c011cb9,e0f6aad6,"import java.io.*;
import java.util.*;

/*
polyakoff
*/

public class Main {

    static FastReader in;
    static PrintWriter out;
    static Random rand = new Random();
    static final int oo = (int) 2e9 + 10;
    static final long OO = (long) 2e18 + 10;
    static final int MOD = 998244353;


    static void solve() {
        int n = in.nextInt();
        String[] s = new String[n];
        for (int i = 0; i < n; i++) {
            s[i] = in.next();
        }

        HashSet<String> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            if (s[i].charAt(0) == s[i].charAt(s[i].length() - 1)) {
                out.println(""YES"");
                return;
            }
            if (s[i].length() == 2) {
                String t = new StringBuilder(s[i]).reverse().toString();
                if (set.contains(t)) {
                    out.println(""YES"");
                    return;
                }
                for (char c = 'a'; c <= 'z'; c++) {
                    if (set.contains(t + c)) {
                        out.println(""YES"");
                        return;
                    }
                }
                set.add(s[i]);
            } else {
                String t = new StringBuilder(s[i]).reverse().toString();
                if (set.contains(t) || set.contains(t.substring(0, 2))) {
                    out.println(""YES"");
                    return;
                }
                set.add(s[i]);
            }
        }

        out.println(""NO"");


    }

    public static void main(String[] args) {
        in = new FastReader();
        out = new PrintWriter(System.out);

        int t = 1;
        t = in.nextInt();
        while (t-- > 0) {
            solve();
        }

        out.flush();
        out.close();
    }

    
}
","import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    

    
    
    private static LinkedList[] adj;
    
    
    

    
    
    public static void main(String[] args) throws Exception {
        // your code goes here
        FastReader sc = new FastReader();
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            Set<String> list1= new HashSet<>();
            Set<String> list2= new HashSet<>();
            Set<String> list3= new HashSet<>();
            int flag=0;
            for(int i=0;i<n;i++) {
                String s = sc.next();
                if (flag == 1) {
                   list1.add(s);
                }
                else
                {
                    if (s.length() == 1) {
                        flag = 1;
                    } else if (s.length() == 2) {
                        list2.add(s);
                        StringBuilder x = new StringBuilder();
                        x.append(s.charAt(1));
                        x.append(s.charAt(0));
                        if (list3.contains(x.toString()) || list2.contains(x.toString())) {
                            flag = 1;
                        }
                    } else {
                        list1.add(s);
                        list3.add(s.substring(0, 2));
                        StringBuilder x = new StringBuilder();
                        x.append(s.charAt(2));
                        x.append(s.charAt(1));
                        x.append(s.charAt(0));

                        if (list1.contains(x.toString())) flag = 1;
                        StringBuilder y = new StringBuilder();
                        y.append(s.charAt(2));
                        y.append(s.charAt(1));
                        if (list2.contains(y.toString())) flag = 1;

                    }


                }
            }

            if(flag!=1){
                System.out.println(""NO"");
            } else
                System.out.println(""YES"");
        }
    }

}
",0,Non-plagiarised
5ee4d2f9,b38468e8,"import java.util.*;
/**
 * Created by Brandon on 4/29/2021, 11:04 AM.
 */
public class Main {
    static long mod = 998244353;

    public static void solve() {
        // string:
        //char** vals = new char* [n];
        //for (int i = 0; i < n; i++) {
        //	string str = """";
        //	cin >> str;
        //	vals[i] = new char[n];
        //	for (int j = 0; j < n; j++) {
        //		vals[i][j] = str[j];
        //	}
        //}
        int n;
        Scanner sc = new Scanner(System.in);
        n = Integer.parseInt(sc.next());
	    int[] arr = new int[n];
        ArrayList<Integer> ones = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(sc.next());
            if (arr[i] == 1) {
                ones.add(i);
            }
        }
        if (ones.size() == 0) {
            System.out.println(""0\n"");
            return;
        }

	    int[] zeroes = new int[n - ones.size()];
        int cur = 0;
        for (int i = 0; i < n; i++) {
            if (arr[i] == 0) {
                zeroes[cur] = i;
                cur++;
            }
        }
	    int[][] dp = new int[ones.size()][n-ones.size()];
        for (int i = 1; i < ones.size(); i++) {
            dp[i][0] = 100000000;
        }
        dp[0][0] = Math.abs(ones.get(0) - zeroes[0]);
        for (int i = 1; i < n - ones.size(); i++) {
            dp[0][i] = Math.min(dp[0][i - 1], Math.abs(ones.get(0) - zeroes[i]));
        }
        // dp[i][j] is number where you only have to move first i but max position you can put is j
        for (int i = 1; i < ones.size(); i++) {
            for (int j = 1; j < n - ones.size(); j++) {
                dp[i][j] = Math.min(dp[i][j - 1], dp[i-1][j-1] + Math.abs(zeroes[j] - ones.get(i)));
            }
        }
        System.out.println(dp[ones.size()-1][n-ones.size()-1] + ""\n"");
    }
    public static void main(String[] args) {
        solve();
    }
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        DArmchairs solver = new DArmchairs();
        solver.solve(1, in, out);
        out.close();
    }

    static class DArmchairs {
        static ArrayList<Integer> empty;
        static ArrayList<Integer> chair;
        static long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] arr = in.nextIntArray(n);
            empty = new ArrayList<>();
            chair = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                int a = arr[i];
                if (a == 1) chair.add(i);
                else empty.add(i);
            }
            dp = new long[chair.size()][empty.size()];
            for (long[] row : dp) Arrays.fill(row, -1);
            long ans = rec(0, 0);
            out.println(ans);
        }

        static long rec(int i, int j) {
            if (i == chair.size()) return 0;
            int req = chair.size() - i;
            int have = empty.size() - j;
            if (req > have) return Integer.MAX_VALUE;

            if (dp[i][j] != -1) return dp[i][j];
            long opt1 = Math.abs(chair.get(i) - empty.get(j)) + rec(i + 1, j + 1);
            long opt2 = rec(i, j + 1);
            dp[i][j] = Math.min(opt1, opt2);
            return dp[i][j];
        }

    }

    

    
}
",0,Non-plagiarised
558df7d4,f0d91796,"import java.io.*;
import java.util.*;
public class Pupsen {
	public static void main(String[] args) throws Exception {
		FastIO in = new FastIO();
		int t = in.nextInt();
		for (int tc=0; tc<t; tc++) {
			int n = in.nextInt();
			int[] a = new int[n];
			for (int i=0; i<n; i++) {
				a[i] = in.nextInt();
			}
			int[] b = new int[n];
			if (n%2==0) {
				for (int i=0; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			else {
				if (a[0]+a[1]!=0) {
					b[0] = -a[2];
					b[1] = -a[2];
					b[2] = a[0]+a[1];
				}
				else if (a[0]+a[2]!=0) {
					b[0] = -a[1];
					b[2] = -a[1];
					b[1] = a[0]+a[2];
				}
				else {
					b[1] = -a[0];
					b[2] = -a[0];
					b[0] = a[1]+a[2];
				}
				for (int i=3; i<n-1; i+=2) {
					b[i] = -a[i+1];
					b[i+1] = a[i];
				}
				for (int i=0; i<n; i++) System.out.print(b[i]+"" "");
			}
			System.out.println();
		}
	}
	
}
","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() + "" "");
        }*/
///////////////////////////////////////////////////////////////////////////////////



",1,Plagiarised
4212c4b9,829d2024,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Solve {

	static int mod = 1000000000 + 7;
	static long fact[] = new long[2 * 100000 + 3];

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt(); // blocks
			int m = sc.nextInt(); // towers to build
			int x = sc.nextInt(); // maximum diff
			int heights[] = new int[n];
			int sum = 0;
			PriorityQueue<Pair> pq = new PriorityQueue<Pair>();
			for (int i = 0; i < n; i++) {
				heights[i] = sc.nextInt();
			}
			for (int i = 0; i < m; i++) {
				pq.add(new Pair(i + 1, 0));
			}
			pw.println(""YES"");

			for (int i = 0; i < n; i++) {
				Pair p = pq.poll();
				p.value += heights[i];
				pq.add(p);
				pw.print(p.tower + "" "");
			}

			pw.println();
		}
		pw.flush();
	}

	

	

	

	

}

class Pair implements Comparable<Pair> {
	int tower;
	int value = 0;

	Pair(int x, int y) {
		tower = x;
		value = y;
	}

	

}


","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();
        }
    }
}
",1,Plagiarised
810fd282,ec558d69,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main
{
	static int N=(int)2e5+10;
	static long[][] dp=new long[2][N];
	static int[][] A=new int[2][N];
	static ArrayList<ArrayList<Integer>> adj=new ArrayList<>(N);
	static
	{
		for(int i=0;i<N;i++)
			adj.add(new ArrayList<>());
	}
	
	public static void dfs(int v,int p)
	{
		dp[0][v]=dp[1][v]=0;
		for(Integer u:adj.get(v))
		{
			if(u==p)
				continue;
			dfs(u, v);
			dp[0][v]+=Math.max(Math.abs(A[0][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[0][v]-A[0][u]));
			dp[1][v]+=Math.max(Math.abs(A[1][v]-A[1][u])+dp[1][u], dp[0][u]+Math.abs(A[1][v]-A[0][u]));
		}
	}
	
	public static void main(String[] args) throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(br.readLine());
		while(t-->0)
		{
			int n=Integer.parseInt(br.readLine());
			for(int i=1;i<=n;i++)
			{
				String[] ss1=br.readLine().split("" "");
				A[0][i]=Integer.parseInt(ss1[0]);
				A[1][i]=Integer.parseInt(ss1[1]);
				adj.set(i, new ArrayList<>());
			}
			for(int i=1;i<n;i++)
			{
				String[] ss2=br.readLine().split("" "");
				int u=Integer.parseInt(ss2[0]);
				int v=Integer.parseInt(ss2[1]);
				adj.get(u).add(v);
				adj.get(v).add(u);
			}
			dfs(1, -1);
			System.out.println(Math.max(dp[0][1], dp[1][1]));
		}
    }
}
","import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Main 
{
    static int N=(int)2e5+10;
    static int[][] A=new int[2][N];
    static long[][] dp=new long[2][N];
    static ArrayList<ArrayList<Integer>> links=new ArrayList<>(N);
    static {
        for (int i=0;i<N;i++)
            links.add(new ArrayList<>());
    }
    static void dfs(int v,int p) 
    {
        dp[0][v]=dp[1][v]=0;
        for (Integer link :links.get(v))
        {
            if (link==p) continue;
            dfs(link,v);
            dp[0][v]+=Math.max(Math.abs(A[0][v]-A[0][link])+dp[0][link],Math.abs(A[0][v]-A[1][link])+dp[1][link]);
            dp[1][v]+=Math.max(Math.abs(A[1][v]-A[0][link])+dp[0][link],Math.abs(A[1][v]-A[1][link])+dp[1][link]);
        }
    }

	public static void main (String[] args) throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=Integer.parseInt(br.readLine()),n,i;
		while (t-->0)
		{
		    n=Integer.parseInt(br.readLine());
		    for (i=1;i<=n;i++)
		    {
		        String[] in=br.readLine().split("" "");
		        A[0][i]=Integer.parseInt(in[0]);
		        A[1][i]=Integer.parseInt(in[1]);
		        links.set(i,new ArrayList<>());
		    }
		    for (i=1;i<n;i++)
		    {
		        String[] in=br.readLine().split("" "");
		        int a=Integer.parseInt(in[0]);
		        int b=Integer.parseInt(in[1]);
		        links.get(a).add(b);
		        links.get(b).add(a);
		    }
		    dfs(1,-1);
		    System.out.println(Math.max(dp[0][1],dp[1][1]));
		}
	}
}
",1,Plagiarised
1dab88fb,4138b081,"import java.util.*;

public class Main
{
    static class Edge{
        public int node;
        public int index;
        public Edge(int n, int i){
            node=n;
            index=i;
        }
    }
    static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
	    
	    int test=sc.nextInt();
	    while(test-->0){
	        
	        solve();
	    }
	}
	
	static void solve(){
	    int n=sc.nextInt();
	        ArrayList<ArrayList<Edge>> graph= new ArrayList<ArrayList<Edge>>();
	        for(int i=0;i<n;i++){
	            graph.add(new ArrayList<>());
	        }
	        for (int i = 0; i < n - 1; i++) {
	            int u = sc.nextInt();
	            int v = sc.nextInt();
	            u--; v--;
	            
	            graph.get(u).add(new Edge(v, i));
	            graph.get(v).add(new Edge(u, i));
            }
            
            int start = 0;
            for (int i = 0; i < n; i++) {
                if (graph.get(i).size() > 2) {
                    System.out.println(""-1"");
                    return;
                } else if (graph.get(i).size() == 1) {
                    start = i;
                }
            }
            int[] weight = new int[n - 1];
            
            int prevNode = -1;
            int curNode = start;
            int curWeight = 2;
            
            while (true) {
                ArrayList<Edge> edges = graph.get(curNode);
                Edge next = edges.get(0);
                
                if (next.node == prevNode) {
                    if (edges.size() == 1) {
                        break;
                    } else {
                        next = edges.get(1);
                    }
                }
                weight[next.index] = curWeight;
                
                prevNode = curNode;
                curNode = next.node;
                curWeight = 5 - curWeight;
            }
            for (int i = 0; i < n - 1; i++) {
                System.out.print(weight[i]);
                System.out.print("" "");
            }
            System.out.println();
	}
}
","import java.io.*;
import java.util.*;
 
public class Contest1627C
{
    
    static InputReader r = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static long mod = 1000000007; static ArrayList<Integer>[] adj; static ArrayList<Integer>[] num; static int[] ans;
    public static void main(String[] args)
    {
    	int t = r.nextInt();
    	while (t > 0)
    	{
    		t--;
    		int n = r.nextInt();
    		adj = new ArrayList[n];
    		num = new ArrayList[n];
    		for (int i = 0; i < n; i ++)
    		{
    			adj[i] = new ArrayList<Integer>();
    			num[i] = new ArrayList<Integer>();
    		}
    		int[] deg = new int[n];
    		boolean flag = false;
    		for (int i = 0; i < n - 1; i ++)
    		{
    			int a = r.nextInt()-1;
    			int b = r.nextInt()-1;
    			adj[a].add(b);
    			adj[b].add(a);
    			num[a].add(i);
    			num[b].add(i);
    			deg[a] ++;
    			deg[b] ++;
    			if (deg[a] > 2 || deg[b] > 2)
    			{
    				flag = true;
    			}
    		}
    		if (flag)
    		{
    			pw.println(-1);
    			continue;
    		}
    		ans = new int[n];
    		for (int i = 0; i < n; i ++)
    		{
    			if (deg[i] == 1)
    			{
    				dfs(i,3,-1);
    			}
    		}
    		for (int i = 0; i < n - 1; i ++)
    		{
    			pw.println(ans[i]);
    		}
    	}
        pw.close();
    }
    static void dfs(int node, int x, int p)
    {
    	for (int j = 0; j < adj[node].size(); j ++)
    	{
    		int i = adj[node].get(j);
    		if (i == p)
    		{
    			continue;
    		}
    		ans[num[node].get(j)] = x;
    		dfs(i,5-x,node);
    	}
    }
}
",0,Non-plagiarised
46e9aed4,8ddb5587,"import java.util.*;

import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public final class Solution {
    

    public static void main(String[] args) throws Exception {
        
        Reader sc = new Reader();
        BufferedWriter op = new BufferedWriter(new OutputStreamWriter(System.out));
         
         int n=sc.nextInt();
          ArrayList<Integer> fill= new ArrayList<Integer>();
          ArrayList<Integer> unfilled= new ArrayList<>();
          for(int i=0;i<n;i++){
              int x =sc.nextInt();
              if(x==1){
                  fill.add(i);
              }else{
                  unfilled.add(i);
              }
          }
          Collections.sort(fill);
          Collections.sort(unfilled);
          
          
          long[][] dp =new long[fill.size()+1][unfilled.size()+1];
           for(int i=0;i<fill.size()+1;i++){
              for(int j=0;j<unfilled.size()+1;j++){
                  dp[i][j]=Integer.MAX_VALUE;
              }
          }
          for(int i=0;i<unfilled.size()+1;i++){
              dp[0][i]=0;
          }
        //   for(int j=0;j<fill.size()+1;j++){
        //       dp[j][0]=0;
        //   }
         

          for(int i=1;i<fill.size()+1;i++){
              for(int j=1;j<unfilled.size()+1;j++){
                  dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(fill.get(i-1)-unfilled.get(j-1)));
              }
          }
          System.out.println(dp[fill.size()][unfilled.size()]);
        //   for(int i=0;i<fill.size()+1;i++){
        //       for(int j=0;j<unfilled.size()+1;j++)
        //       {
        //           System.out.print(dp[i][j]+"" "");
        //       }
        //       System.out.println();
        //   }
         
    }




   
    }


","import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
 
public class taskd {
    public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        taskd sol = new taskd();
        sol.solve(in, out);
        out.flush();
    }

    void solve(FastScanner in, PrintWriter out) {
        int n = in.nextInt();
        ArrayList<Integer> a = new ArrayList<>();
        ArrayList<Integer> b = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (x == 1) {
                a.add(i);
            } else {
                b.add(i);
            }
        }

        long dp[][] = new long[a.size() + 5][b.size() + 5];
        for (int i = a.size()-1; i >= 0; i--) {
            dp[i][b.size()] = Integer.MAX_VALUE;
            for (int j = b.size()-1; j >= 0; j--) {
                dp[i][j] = dp[i][j + 1];
                dp[i][j] = Math.min(dp[i][j], Math.abs(a.get(i) - b.get(j)) + dp[i + 1][j + 1]);
            }
        }
        out.println(dp[0][0]);
    }

    
}
",0,Non-plagiarised
5c54f087,c6c7fa0c,"import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("""");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    
    
    int n,a,b,da,db,dist,vert;
    ArrayList<Integer>A[];
    
    void solve() throws IOException {
        for (int tc=ni();tc>0;tc--) {
            n=ni(); a=ni(); b=ni(); da=ni(); db=ni();
            A=new ArrayList[n+1];
            for (int i=1;i<=n;i++) A[i]=new ArrayList();
            for (int i=1;i<n;i++) {
                int u=ni(),v=ni();
                A[u].add(v);
                A[v].add(u);
            }
            
            dist=0;
            dfs1(a,0,0);
            if (dist<=da || db<=2*da) {
                out.println(""Alice"");
                continue;
            }
            
            dist=0;
            vert=0;
            dfs2(1,0,0);
            dist=0;
            dfs2(vert,0,0);
            
            if (dist<=2*da) out.println(""Alice"");
            else out.println(""Bob"");
        }
        out.flush();
    }
    
    void dfs2(int u,int p,int d) {
        if (d>dist) {
            dist=d;
            vert=u;
        }
        
        for (Integer v:A[u]) {
            if (v==p) continue;
            dfs2(v,u,d+1);
        }
    }
    
    void dfs1(int u,int p,int d) {
        if (u==b) dist=d;
        for (Integer v:A[u]) {
            if (v==p) continue;
            dfs1(v,u,d+1);
        }
    }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}
","import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.PI;
import static java.lang.System.in;
import static java.lang.System.out;

public class B
{
    static ArrayList<ArrayList<Integer>> adj;
    static int dis[];

    static void dfs(int s, int p, int l)
    {
        dis[s] = l;
        for(int i : adj.get(s))
        {
            if(i==p)    continue;
            dfs(i, s, l+1);
        }
    }

    public static void main(String[] args) throws Exception 
    {
        FastReader sc = new FastReader();
        PrintWriter p = new PrintWriter(out);
        int t = sc.nextInt();
        while(t--!=0)
        {
            int n = sc.nextInt(), a = sc.nextInt(), b = sc.nextInt(), da = sc.nextInt(), db = sc.nextInt();
            adj = new ArrayList<>();
            for(int i = 0; i <= n; i++)
            {
                adj.add(new ArrayList<>());
            }
            for(int i = 1; i < n; i++)
            {
                int u = sc.nextInt(), v = sc.nextInt();
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            dis = new int[n+1];
            dfs(a, 0, 0);
            if(dis[b] <= da)    //Alice reached in first move
            {
                p.println(""Alice"");
                continue;
            }
            int farthest = 0, maxDis = 0;
            for(int i = 1; i <= n; i++)
            {
                if(maxDis < dis[i])
                {
                    maxDis = dis[i];
                    farthest = i;
                }
            }
            dfs(farthest, 0, 0);
            int diameter = 0;
            for(int i = 1; i <= n; i++)
            {
                diameter = Math.max(diameter, dis[i]);
            }
            if(db > 2*da && diameter > 2*da)
            {
                p.println(""Bob"");
            }
            else
            {
                p.println(""Alice"");
            }
        }
        p.close();
    }
/* 
*/    
/*
1. Check overflow in pow function or in general
2. Check indices of read array function
3. Think of an easier solution because the problems you solve are always easy
4. Check iterator of loop
5. If still doesn't work, then jump from the 729th floor 'coz ""beta tumse na ho paayega""

    Move to top!!
*/
}
",0,Non-plagiarised
921b6e4a,e7dce35b,"import java.io.*;
import java.util.*;

public class D_Java {
	public static final int MOD = 998244353;
	
	public static int mul(int a, int b) {
		return (int)((long)a * (long)b % MOD);
	}
	
	int[] f;
	int[] rf;
	
	public int C(int n, int k) {
		return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n-k], rf[k]));
	}
	
	public static int pow(int a, int n) {
		int res = 1;
		while (n != 0) {
			if ((n & 1) == 1) {
				res = mul(res, a);
			}
			a = mul(a, a);
			n >>= 1;
		}
		return res;
	}
	
	
	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 Main {
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int n = nextInt();
        int k = nextInt();

        f = new int[n + 42];
        rf = new int[n + 42];
        f[0] = 1;
        rf[0] = 1;
        for (int i = 1; i < f.length; i++) {
            f[i] = mul(f[i - 1], i);
            rf[i] = mul(rf[i - 1], inv(i));
        }

        int[] a = new int[n * 2];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt() * 2;
            a[i + n] = nextInt() * 2 + 1;
        }
        Arrays.sort(a);

        int ans = 0;
        int curOpen = 0;
        for (int r = 0; r < 2 * n;) {
            int l = r;
            while (r < 2 * n && a[l] == a[r]) r++;
            int intersections = r - l;
            if (a[l] % 2 == 0) {
                ans += C(curOpen + intersections, k);
                if (ans >= mod) ans -= mod;
                ans += mod - C(curOpen, k);
                if (ans >= mod) ans -= mod;
                curOpen += intersections;
            } else {
                curOpen -= intersections;
            }
        }

        pw.println(ans);
        pw.close();
    }

    static int mod = 998244353;

    static int mul(int a, int b) {
        return (int) ((long) a * (long) b % mod);
    }

    static int[] f;
    static int[] rf;

    static int C(int n, int k) {
        return (k < 0 || k > n) ? 0 : mul(f[n], mul(rf[n - k], rf[k]));
    }

    static int pow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1) {
                res = mul(res, a);
            }
            a = mul(a, a);
            n >>= 1;
        }
        return res;
    }

    static int inv(int a) {
        return pow(a, mod - 2);
    }

    static StringTokenizer st = new StringTokenizer("""");
    static BufferedReader br;

    static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    

    
}




",1,Plagiarised
8be61667,ca3128ab,"import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=input.nextInt();
        while(T-->0)
        {
            int n=input.nextInt();
            int c[]=new int[n];
            for(int i=0;i<n;i++)
            {
                c[i]=input.nextInt();
            }
            long me=Integer.MAX_VALUE;
            long mo=Integer.MAX_VALUE;
            long se=0,so=0;
            long min=Long.MAX_VALUE;
            for(int i=1;i<=n;i++)
            {
                if(i%2==0)
                {
                    me=Math.min(me,c[i-1]);
                    se+=c[i-1];
                }
                else
                {
                    mo=Math.min(mo,c[i-1]);
                    so+=c[i-1];
                }
                if(i>=2)
                {
                    long sum=0;
                    long c1=i/2+i%2;
                    long c2=(i-1)/2+(i-1)%2;
                    if(i%2==0)
                    {
                        sum+=se;
                        sum+=(me)*(n-c1);
                        sum+=so;
                        sum+=mo*(n-c2);
                    }
                    else
                    {
                        sum+=so;
                        sum+=(mo)*(n-c1);
                        sum+=se;
                        sum+=me*(n-c2);
                    }
                    min=Math.min(min,sum);
                }
            }
            out.println(min);
        }
        out.close();
    }
    
}
","import java.io.*;
import java.math.*;
import java.util.*;


public class test {
	 
	   
	  
	    
	 
	   
	
	
	   public static void main(String args[]) throws Exception { 
		
		   
		   Scanner sc = new Scanner();
		   StringBuilder res = new StringBuilder();
		   
		   int tc = sc.nextInt();
		   
		   while(tc-->0) { 
			
			int n = sc.nextInt();
			
			long c[] = new long[n];
			
			for(int i=0;i<n;i++) { 
				c[i] = sc.nextLong();
			}
			
			
			long min_odd = Integer.MAX_VALUE;
			long min_even = Integer.MAX_VALUE;
		    long ans = Long.MAX_VALUE;
		    long sum = 0;
		    
			int cnt1 = n;
			
			int cnt2 = n;
			
			
		    for(int i = 0; i < n; i++){
		        sum += c[i];
		        if(i % 2 == 0){
		            cnt1--;
		            min_odd = Math.min(min_odd, c[i]);
		        }
		        else{
		            cnt2--;
		            min_even = Math.min(min_even, c[i]);
		        }
		        if(i > 0){
		            long temp = sum + (min_odd * cnt1) + (min_even * cnt2);
		            ans = Math.min(ans, temp);
		        }
		 
		    }
		    
		    System.out.println(ans);
		   }
		   
		   System.out.println(res);
	   }
}
",0,Non-plagiarised
72d9eb5b,884f5678,"import java.util.*;
import java.io.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        int T = in.nextInt();
        while(T-- > 0) {
            int n = in.nextInt();
            int[] a = new int[n];
            for(int j=0;j<n;j++) a[j] = in.nextInt();
            char[] s = in.next().toCharArray();

            List<Integer> blue = new ArrayList<>();
            List<Integer> red = new ArrayList<>();
            for(int j=0;j<n;j++) {
                if(s[j] == 'B') blue.add(a[j]);
                else red.add(a[j]);
            }

            Collections.sort(blue);
            Collections.sort(red);

            boolean p = true;
            int cur = 1;
            for(int val : blue) {
                if(val<cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            for(int val : red) {
                if(val>cur) {
                    p = false;
                    break;
                }
                else cur++;
            }
            
            if(p) System.out.println(""yes"");
            else System.out.println(""no"");
        }
    }
}
","import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class JaiShreeRam{
	static Scanner in=new Scanner();
	static long mod = 1000000007;
	static ArrayList<ArrayList<Integer>> adj;
	public static void main(String[] args) throws Exception{
		
		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;
	}
	
	
	
		
}
",0,Non-plagiarised
31f29772,d04e5afb,"import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.io.*;
 
public class PhoenixTow {
	
	
	

	public static class  Pair implements Comparable<Pair>
	{
		int x; 
		int y;
		
		Pair(int x, int y)
		{
			this.x = x;
			this.y = y;
		}
		
		
	}
	
	public static void solution(int[] arr, int n, int m, int x)
			
	{
		ArrayList<Pair> list = new ArrayList<>();
		
		for(int i = 0; i<n; i++)
		{
			list.add(new Pair(arr[i], i));
		}
		
		Collections.sort(list);
		
		long[] sum = new long[m];
		
		int[] ans = new int[n];
		
		int k = 1;
		
		for(int i = 0; i<list.size(); i++)
		{
			if(k<m)
		    { 
				if(sum[k-1]+list.get(i).x - sum[k]>x)
			      {out.println(""NO""); return; }
		      
		    }
			
			  
	    	sum[k-1]+=list.get(i).x;
	    	ans[list.get(i).y] = k;
	    	k++;
	    	
	    	if(k==(m+1))
	    		k=1;
	    	
			
		}
		
		out.println(""YES""); 
		
		for(int i = 0; i<n; i++)
			out.print(ans[i]+"" "");
		
		out.println();
		
		
	}
        
private static PrintWriter out = new PrintWriter(System.out);

public static void main (String[] args)
{
	MyScanner s =  new MyScanner();
     
    int t = s.nextInt();
    
    for(int j = 0; j<t ; j++)
    {
    	int n = s.nextInt();
    	int m = s.nextInt();
    	int x = s.nextInt();
    	
    	int[] arr = new int[n];
    	for(int i =0; i<n; i++)
    		arr[i] = s.nextInt();
    	
    	solution(arr,n,m,x);
    }
    
    out.flush();
    out.close();
    
}
}
","import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import java.util.Collections;
import java.io.InputStream;


public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CPhoenixAndTowers solver = new CPhoenixAndTowers();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class CPhoenixAndTowers {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
            ArrayList<Pair<Integer, Integer>> a = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                a.add(new Pair<>(in.nextInt(), i));
            }
            Collections.sort(a);

            int[] ans = new int[n];
            int[] sum = new int[m];
            int j = 1;

            for (int i = 0; i < n; ++i) {
                ans[a.get(i).y] = j;
                sum[j - 1] += a.get(i).x;
                j++;
                if (j == m + 1) j = 1;
            }

            for (int i = 1; i < m; ++i) {
                if (Math.abs(sum[i - 1] - sum[i]) > k) {
                    out.println(""NO"");
                }
            }

            out.println(""YES"");
            for (int e : ans) {
                out.print(e + "" "");
            }
            out.println();

        }

    }

    

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public U x;
        public V y;

        public Pair(U x, V y) {
            this.x = x;
            this.y = y;
        }

        

        

        

    }
}
",0,Non-plagiarised
201e3463,de599e42,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D
{
    public static void main(String[] args)
    {
        CP sc =new CP();
        int tt = sc.nextInt();
        while (tt-- > 0) {
            int n = sc.nextInt();
            TreeSet<Long> set = new TreeSet<>();
            long prev = -1;
            boolean flag = true;
            for (int i = 0; i < n; i++) {
                long x = sc.nextInt();
                if (i == 0) {
                    set.add(x);
                    prev = x;
                    continue;
                }
                if (x > prev) {
                    Long high = set.higher(prev);
                    if (high == null) set.add(x);
                    else if (high >= x) set.add(x);
                    else flag = false;
                } else if (x < prev) {
                    Long low = set.lower(prev);
                    if (low == null) set.add(x);
                    else if (low <= x) set.add(x);
                    else flag = false;
                }
                prev = x;
            }
            System.out.println(flag ? ""YES"" : ""NO"");
        }
    }
    /*****************************************************************************/
    
    /*****************************************************************************/
}
","import java.util.*;
import java.io.*;

public class _724 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            TreeSet<Long> set = new TreeSet<>();
            long prev = -1;
            boolean ok = true;
            for (int i = 0; i < n; i++) {
                long x = sc.nextInt();
                if (i == 0) {
                    set.add(x);
                    prev = x;
                    continue;
                }
                if (x > prev) {
                    Long high = set.higher(prev);
                    if (high == null) set.add(x);
                    else if (high >= x) set.add(x);
                    else {
                        ok = false;
                    }
                } else if (x < prev) {
                    Long low = set.lower(prev);
                    if (low == null) set.add(x);
                    else if (low <= x) set.add(x);
                    else {
                        ok = false;
                    }
                }
                prev = x;
            }
            out.println(ok ? ""YES"" : ""NO"");
        }
        out.close();
    }





    

    


    //-----------MyScanner class for faster input----------
    

}
",1,Plagiarised
cdb801a1,ed610dc9,"import java.io.*;
import java.util.*;
public class Solution {
	

	
	public static void main(String[] args) throws java.lang.Exception {
		FastReader fr = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int t = fr.ni();
		while(t-->0) {
			
			int n = fr.ni();
			long arr [] = new long[n];
			for(int i = 0 ; i < n ; i++) arr[i]= fr.nl();
			long even = arr[0];
			long odd = arr[1];
			long minEven = arr[0];
			long minOdd = arr[1];
			long ans = (minEven*n) + (minOdd*n);
			for(int i = 2 ; i < n ; i++) {
				if((i&1) == 0) {
					even += arr[i];
					minEven = Math.min(minEven, arr[i]);
					long a = (i+2)/2;
					long b = (i+1)-a;
					long temp = (even + (minEven*(n - a)));
					temp += (odd + (minOdd*(n - b)));
					ans = Math.min(ans, temp);
				}else {
					odd += arr[i];
					minOdd = Math.min(minOdd, arr[i]);
					long a = (i+2)/2;
					long b = (i+1)-a;
					long temp = (even + (minEven*(n - a)));
					temp += (odd + (minOdd*(n - b)));
					ans = Math.min(ans, temp);
					
				}
			}
			out.println(ans);
		}
		out.close();
	}
}
","import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.Random;
import java.util.Arrays;
import java.util.StringTokenizer; 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Collections;
import java.util.*;
public class C 
{ 
    public static void main(String[] args) 
	{ 
		FastReader sc=new FastReader(); 
		StringBuffer ans=new StringBuffer();
		int test=sc.nextInt();
		while(test-->0)
		{
			int n=sc.nextInt();
			long arr[]=new long[n];
			for(int i=0;i<n;i++) {
				arr[i]=sc.nextLong();
			}
			long nn=n;
			long ep=1;
			long op=1;
			
			long se=arr[0];
			long so=arr[1];
			
			long sume=se;long sumo=so;
			long minm = (se*nn) +(so*nn);
			
			for(int i=2;i<n;i++) {
				if(i%2 == 0) {
					++ep;
					sume+=arr[i];
					se=Math.min(se, arr[i]);
				}
				else {
					++op;
					sumo+=arr[i];
					so=Math.min(so, arr[i]);
				}
				
				long cost = (sume)+(se*(nn-ep));
				cost+=((sumo)+(so*(nn-op)));
				minm=Math.min(cost, minm);
			}
			ans.append(minm+""\n"");
		
		}
		
	    System.out.print(ans);
	} 
        
    static final Random random=new Random();
    
	
	
	
	
	 


}
",0,Non-plagiarised
bf0df1d5,d1cd194e,"import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import java.io.IOException;

public class C_Phoenix_and_Towers {
    

    public static class Pair implements Comparable<Pair> {
        int id, h;

        public Pair(int id, int h) {
            this.id = id;
            this.h = h;
        }

        
    }

    public static void main(String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        int t = sc.nextInt();

        while (t-- > 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int x = sc.nextInt();
            int tow[] = new int[n];
            int ans[] = new int[n];
            PriorityQueue<Pair> pq = new PriorityQueue<>();
            for (int i = 0; i < n; i++) {
                tow[i] = sc.nextInt();
            }
            for (int i = 0; i < m; i++) {
                ans[i] = i + 1;
                pq.add(new Pair(i + 1, tow[i]));
            }
            for (int i = m; i < n; i++) {
                Pair p = pq.poll();
                p.h = p.h + tow[i];
                ans[i] = p.id;
                pq.add(p);
            }
            System.out.println(""YES"");
            for (int i = 0; i < n; i++) {
                System.out.print(ans[i] + "" "");
            }
            System.out.println();
        }
    }
}
","import java.util.*;

import java.lang.*;
import java.io.*;

public class Template {
	
	
	
//	static 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
bdfe8110,c57a973e,"import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class E {

	public static void main(String[] args) {
		FastScanner fs=new FastScanner();
		int T=fs.nextInt();
		PrintWriter out=new PrintWriter(System.out);
		for (int tt=0; tt<T; tt++) {
			int n=fs.nextInt(), k=fs.nextInt();
			int[] positions=fs.readArray(k), temps=fs.readArray(k);
			int[] forced=new int[n];
			Arrays.fill(forced, Integer.MAX_VALUE/2);
			for (int i=0; i<k; i++) forced[positions[i]-1]=temps[i];
			for (int i=1; i<n; i++)
				forced[i]=Math.min(forced[i], forced[i-1]+1);
			for (int i=n-2; i>=0; i--)
				forced[i]=Math.min(forced[i], forced[i+1]+1);
			for (int i=0; i<n; i++) out.print(forced[i]+"" "");
			out.println();
			
		}
		out.close();
	}

	
	
	

	
}
","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();
		}

    }

    
}
",1,Plagiarised
6be98ece,e1c4f3db,"import java.util.*;

public class CF763C {
	private static final int MAX = 1000000001;
	private static final int MIN = 0;

	public static final void main(String ...args) {
		Scanner sc = new Scanner(System.in);

		int t = sc.nextInt();

		while (t-- > 0) {
			int n = sc.nextInt();
			int[] h = new int[n];
			int i, b = MAX, e = MIN;
			for (i = 0; i < n; i++) {
				h[i] = sc.nextInt();
				if (b > h[i])
					b = h[i];
				if (e < h[i])
					e = h[i];
			}

			int[] s = new int[n];
			int c, d, ans = b;

			// System.out.println(b + "" "" + e);

			while (b <= e) {
				c = (b + e) / 2;
				// System.out.println(c);
				// sc.next();
				for (i = 0; i < n; i++) {
					s[i] = 0;
				}

				for (i = n - 1; i >= 2; i--) {
					if (h[i] + s[i] < c) {
						e = c - 1;
						break;
					} else {
						d = Math.min(h[i], h[i] + s[i] - c) / 3;
						s[i - 1] += d;
						s[i - 2] += 2 * d;
					}
				}
				// System.out.println(i);
				if (i == 1) {
					if (h[i] + s[i] < c || h[i - 1] + s[i - 1] < c) {
						e = c - 1;
					} else {
						ans = c;
						b = c + 1;	
					}
				}
			}
			System.out.println(ans);
		}
	}
}
","import java.util.*;

public class BalancedStoneHeaps {

    public static boolean check(int n, int x, int[] h) {
        int[] c_h = new int[n];
        for (int i = 0; i < n; i++)
            c_h[i] = h[i];
        for (int i = n - 1; i >= 2; i--) {
            if (c_h[i] < x)
                return false;
            int d = Math.min(h[i], c_h[i] - x) / 3;
            c_h[i - 1] += d;
            c_h[i - 2] += 2 * d;
        }
        return c_h[0] >= x && c_h[1] >= x;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            int[] h = new int[n];
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < n; i++) {
                h[i] = sc.nextInt();
                if (h[i] > max) {
                    max = h[i];
                }
            }
            int l = 0;
            int r = max;
            while (l < r) {
                int mid = l + (r - l + 1) / 2;
                if (check(n, mid, h)) {
                    l = mid;
                } else {
                    r = mid - 1;
                }
            }
            System.out.println(l);
        }
    }
}
",0,Non-plagiarised
4138b081,f59d9b6e,"import java.io.*;
import java.util.*;
 
public class Contest1627C
{
    
    static InputReader r = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static long mod = 1000000007; static ArrayList<Integer>[] adj; static ArrayList<Integer>[] num; static int[] ans;
    public static void main(String[] args)
    {
    	int t = r.nextInt();
    	while (t > 0)
    	{
    		t--;
    		int n = r.nextInt();
    		adj = new ArrayList[n];
    		num = new ArrayList[n];
    		for (int i = 0; i < n; i ++)
    		{
    			adj[i] = new ArrayList<Integer>();
    			num[i] = new ArrayList<Integer>();
    		}
    		int[] deg = new int[n];
    		boolean flag = false;
    		for (int i = 0; i < n - 1; i ++)
    		{
    			int a = r.nextInt()-1;
    			int b = r.nextInt()-1;
    			adj[a].add(b);
    			adj[b].add(a);
    			num[a].add(i);
    			num[b].add(i);
    			deg[a] ++;
    			deg[b] ++;
    			if (deg[a] > 2 || deg[b] > 2)
    			{
    				flag = true;
    			}
    		}
    		if (flag)
    		{
    			pw.println(-1);
    			continue;
    		}
    		ans = new int[n];
    		for (int i = 0; i < n; i ++)
    		{
    			if (deg[i] == 1)
    			{
    				dfs(i,3,-1);
    			}
    		}
    		for (int i = 0; i < n - 1; i ++)
    		{
    			pw.println(ans[i]);
    		}
    	}
        pw.close();
    }
    static void dfs(int node, int x, int p)
    {
    	for (int j = 0; j < adj[node].size(); j ++)
    	{
    		int i = adj[node].get(j);
    		if (i == p)
    		{
    			continue;
    		}
    		ans[num[node].get(j)] = x;
    		dfs(i,5-x,node);
    	}
    }
}
","import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be ""Main"" only if the class is public. */
public class Codechef{
    public static class Edge{
        int node;
        int index;
        Edge(int node, int index){
            this.node = node;
            this.index = index;
        }
    }
    static Scanner scn = new Scanner(System.in);
	public static void main (String[] args) throws java.lang.Exception{
		int t = scn.nextInt();
		while(t-->0){
		    solve();
		}
	}
	public static void solve(){
	    int n = scn.nextInt();
	    ArrayList<Edge>[]graph = new ArrayList[n];
	    for(int i = 0; i < n; i++){
	        graph[i] = new ArrayList<>();
	    }
	    for(int i = 0; i < n - 1; i++){
	        int u = scn.nextInt() - 1;
	        int v = scn.nextInt() - 1;
	        graph[u].add(new Edge(v, i));
	        graph[v].add(new Edge(u, i));
	    }
	    int start = 0;
	    for(int i = 0; i < n; i++){
	        if(graph[i].size() > 2){
	            System.out.println(""-1"");
	            return;
	        }else if(graph[i].size() == 1){
	            start = i;
	        }
	    }
	    int[]weight = new int[n - 1];
	    int prevNode = -1, curNode = start, curWeight = 2;
	    while(true){
	        ArrayList<Edge>edges = graph[curNode];
	        Edge next = edges.get(0);
	        if(next.node == prevNode){
	            if(edges.size() == 1){
	                break;
	            }else{
	                next = edges.get(1);
	            }
	        }
	        weight[next.index] = curWeight;
	        prevNode = curNode;
	        curNode = next.node;
	        curWeight = 5 - curWeight;
	    }
	    for(int i = 0; i < n - 1; i++){
	        System.out.print(weight[i]);
	        System.out.print("" "");
	    }
	    System.out.println();
	}
}
",0,Non-plagiarised
1162c08f,6653a758,"import java.util.*;

public class CodeForces1525C{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
","import java.util.*;
public class D {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		ArrayList<Integer> o=new ArrayList<Integer>(), e=new ArrayList<Integer>();
		int n = sc.nextInt(),dp[][]=new int[n+1][n+1];
		for(int i=1;i<=n;i++){
			int x=sc.nextInt();
			if(x==1)o.add(i);
			else e.add(i);
		}
		for(int i=1;i<=o.size();i++){
			dp[i][i]=dp[i-1][i-1]+Math.abs(o.get(i-1)-e.get(i-1));
			for(int j=i+1;j<=e.size();j++)
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+Math.abs(o.get(i-1)-e.get(j-1)));
		}
		System.out.println(dp[o.size()][e.size()]);
	}
}
",1,Plagiarised
e431de28,eb6cfca7,"import java.io.*;
import java.lang.*;
import java.util.*;
public class MinGridPath {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int t=s.nextInt();
		while(t-->0){
			
			int n = s.nextInt();
			long[] aa =new long[n];
			for(int i=0;i<n;i++)
				aa[i]=s.nextLong();
 
			long minEven = aa[0];
			long minOdd = aa[1];
			long sum = aa[0]+aa[1];
			long best = n*minEven + n*minOdd;
			int numOdd = 1;
			int numEven = 1;
			for(int i=2; i<n; ++i) {
				if(i%2 == 0) {
					minEven = Math.min(aa[i], minEven);
					numEven++;
				}else {
					minOdd = Math.min(aa[i], minOdd);
					numOdd++;
				}
				sum += aa[i];
				long score = sum;
				score += minEven*(n-numEven);
				score += minOdd*(n-numOdd);				
				best = Math.min(best, score);
			}
			System.out.println(best);
			
		}
	}

}
","import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Main {

	public Main() throws FileNotFoundException {

//		File file = Paths.get(""input.txt"").toFile();
//		if (file.exists()) {
//			System.setIn(new FileInputStream(file));
//		}
		long t = System.currentTimeMillis();

		InputReader reader = new InputReader();

		int ttt = reader.nextInt();

		for (int tt = 0; tt < ttt; tt++) {
			int n=reader.nextInt();
			
			long[] s=new long[n];
			for(int i=0;i<n;i++) {
				s[i]=reader.nextLong();
			}
			
			long smallest1=s[0];
			long smallest2=s[1];
			long val=n*s[0]+n*s[1];
			
			int left1=n-1;
			int left2=n-1;
			long base=s[0]+s[1];
			for(int i=2;i<n;i++) {
				if(i%2==0) {
					//left1
					val=Math.min(val, base+left2*smallest2+left1*s[i]);
					base+=s[i];
					smallest1=Math.min(smallest1, s[i]);
					left1--;
				}else {
					val=Math.min(val, base+left1*smallest1+left2*s[i]);
					base+=s[i];
					smallest2=Math.min(smallest2, s[i]);
					left2--;
					//left2
				}
			}
			

			System.out.println(val);
		}

	}

	

	public static void main(String[] args) throws FileNotFoundException {
		new Main();
	}

}
",0,Non-plagiarised