data.csv

9282280,"
    #!/usr/bin/env python
    
    from collections import Counter
    
    
    def collapse(graph):
        if len(graph) == 1:
            return None
        else:
            node_degrees, edge_degrees = Counter(), Counter()
    
            for i, p in enumerate(graph):
                node_degrees[i+1] += 1
                node_degrees[p] += 1
    
            for i, p in enumerate(graph):
                edge_degrees[(i+1, p)] += node_degrees[i+1] + node_degrees[p]
    
            flags = set()
            unions = []
    
            for edge in edge_degrees.most_common()[::-1]:
                x, y = edge[0]
                if x not in flags and y not in flags:
                    unions.append((x, y))
                    flags.add(x)
                    flags.add(y)
    
            for x, y in unions:
                for i, p in enumerate(graph):
                    if p == x:
                        graph[i] = y
    
            for x, y in unions:
                graph[x-1] = -1
    
            graph = [n for n in graph if n >= 0]
    
            for x, y in unions:
                for i, p in enumerate(graph):
                    if p > x:
                        graph[i] -= 1
    
            return graph
    
    
    def solve(graph):
        i = 0
    
        while graph is not None:
            i += 1
            graph = collapse(graph)
    
        return i
    
    
    def main():
        t = int(raw_input())
    
        for _ in range(t):
            k = int(raw_input())
            graph = [int(i) for i in raw_input().split()]
    
            print solve(graph)
    
    
    if __name__ == ""__main__"":
        main()
    

",PYTH
10396567,"
    /*          ****vestovia
    */
    #include<bits/stdc++.h>
    using namespace std;
    #define mod 1000000007
    #define ll long long
    #define pb push_back
    #define mp make_pair
    #define pi pair<int,int>
    #define sc(x) scanf(""%d"",&x)
    #define sc2(x,y) scanf(""%d%d"",&x,&y)
    #define sc3(x,y,z) scanf(""%d%d%d"",&x,&y,&z)
    #define sc4(x,y,z,u) scanf(""%d%d%d%d"",&x,&y,&z,&u)
    #define scll(x) scanf(""%lld"",&x)
    #define scll2(x,y) scanf(""%lld%lld"",&x,&y)
    #define scll3(x,y,z) scanf(""%lld%lld%lld"",&x,&y,&z)
    #define pr(x) printf(""%d\n"",x)
    #define prll(x) printf(""%lld\n"",x)
    int main()
    {
        int i,j,k,s,p,n,t;
        sc(t);
        ll l,e,o,m;
        while(t--)
        {
            sc(n);
            scll2(e,o);
            l=(n*(n+1))/2;
            m=0;
            j=n;
            p=-1;s=0;
            while(e<=l&&m>=o)
            {
                if(e==l||m==o)
                {
                    for(i=0;i<n;i++)
                    {
                        if(i!=p)
                            printf(""0 "");
                        else
                            printf(""1 "");
                    }
                    printf(""\n"");
                    s=1;
                    break;
                }
                p++;
                l-=j;
                m+=j;
                j-=2;
            }
            if(s!=1)
                printf(""-1\n"");
        }
        return 0;
    }
    

",C++
5243124,"
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.FileReader;
    import java.util.Arrays;
    import java.io.BufferedReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.io.Writer;
    import java.util.StringTokenizer;
    import java.io.InputStream;
    
    /**
     * Built using CHelper plug-in
     * Actual solution is at the top
     * @author Agostinho Junior
     */
    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);
    		AndTuples solver = new AndTuples();
    		int testCount = Integer.parseInt(in.next());
    		for (int i = 1; i <= testCount; i++)
    			solver.solve(i, in, out);
    		out.close();
    	}
    }
    
    class AndTuples {
    	OutputWriter out;
    	InputReader in;
    	long N;
    	int K;
    	long[][] memo = new long[63][10];
    	final long MOD = (long)1e9 + 9;
    	public void solve(int testNumber, InputReader in, OutputWriter out) {
    		this.in = in; this.out = out;
    		K = in.readInt();
    		N = in.readLong();
    		for (long[] a: memo) Arrays.fill(a, -1);
    		out.println(dfs(0, 0));
    	}
    	private long dfs(int highest, int last) {
    		if (last < 0 || last % 2 > 0) {
    			return 0;
    		}
    		if (highest == 10) {
    			return last == 0 ? 1 : 0;
    		}
    		if (memo[highest][last] == -1) {
    			long res = 0;
    			for (int k = 0; k <= K; k++) {
    				int take = (N & (1L << highest)) == 0 ? 0 : 1;
    				res += dfs(highest + 1, k + (last >> 1) - take);
    				if (res > MOD) {
    					res -= MOD;
    				}
    			}
    			memo[highest][last] = res;
    		}
    		return memo[highest][last];
    	}
    }
    
    class OutputWriter {
    	private PrintWriter output;
    	public OutputWriter(OutputStream out) {
    		output = new PrintWriter(out);
    	}
    	public void println(Object o) {
    		output.println(o);
    	}
    	public void close() {
    		output.close();
    	}
    }
    
    class InputReader {
    	private BufferedReader input;
    	private StringTokenizer line = new StringTokenizer("""");
    	public InputReader(InputStream in) {
    		input = new BufferedReader(new InputStreamReader(in));
    	}
    	public void fill() {
    		try {
    			if(!line.hasMoreTokens()) line = new StringTokenizer(input.readLine());
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	public String next() {
    		fill();
    		return line.nextToken();
    	}
    	public int readInt() {
    		fill();
    		return Integer.parseInt(line.nextToken());
    	}
    	public long readLong() {
    		fill();
    		return Long.parseLong(line.nextToken());
    	}
    }
    
    

",JAVA
7265453,"
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <queue>
    #include <deque>
    #include <stack>
    #include <bitset>
    #include <algorithm>
    #include <functional>
    #include <numeric>
    #include <utility>
    #include <sstream>
    #include <iostream>
    #include <iomanip>
    #include <cstdio>
    #include <cmath>
    #include <cstdlib>
    #include <ctime>
    #include <cstring>
    #include <climits>
    #include <cctype>
    #include <cassert>
    #include <complex>
    
    using namespace std;
    
    #define ull unsigned long long
    #define lld long long int
    #define pii pair<int,int>
    #define F(i,a,n) for(int i=(a);i<(n);++i)
    #define REP(i,a,n) for(i=(a);i<(n);++i)
    #define FD(i,a,n) for(int i=(a);i>=(n);--i)
    #define FE(it,x) for(it=x.begin();it!=x.end();++it)
    #define V(x) vector<x>
    #define S(x) scanf(""%d"",&x)
    #define Sl(x) scanf(""%llu"",&x)
    #define M(x,i) memset(x,i,sizeof(x))
    #define debug(i,sz,x) F(i,0,sz){cout<<x[i]<<"" "";}cout<<endl
    #define MAX(a,b) ((a)>(b)?(a):(b))
    lld ABS(lld a) { if ( a < 0 ) return (-a); return a; }
    #define vi vector<int>
    #define mp make_pair
    #define fr first
    #define se second
    #define pb push_back
    #define maxn 300010
    #define inf 1000000000
    #define mod 1000000007
    
    map < lld, lld > map1;
    lld fact[maxn], ifact[maxn];
    
    lld powmod(lld a, lld b) {
    	if(b==0) return 1;
    
    	lld tres=powmod(a, b/2);
    	tres=tres*tres%mod;
    	if(b&1) return tres*a%mod;
    	return tres;
    }
    
    void init() {
    	fact[0]=1;
    	for(int i=1;i<maxn;i++) fact[i]=fact[i-1]*i;
    	ifact[maxn-1]=powmod(fact[maxn-1], mod-2);
    	for(int i=maxn-2;i>=0;i--) {
    		ifact[i]=powmod(fact[i], mod-2);
    	}
    }
    
    int main() {
    
    	init();
    	int t; S(t);
    	while(t-->0) {
    		int n; S(n);
    		for(int i=0;i<n;i++) {
    			lld a; Sl(a); map1[a]++;
    		}
    		if(map1[1]==n) {
    			if(n%2==1) printf(""1\n"");
    			else printf(""0\n"");
    			map1.clear();
    		}
    		else {
    			int num=n-map1[1], num1=map1[1]; lld totalways=fact[n];
    			map< lld, lld >::iterator it; lld ways=1;
    			for(it=map1.begin(); it!=map1.end();it++) {
    				lld a=it->first; if(a==1) { totalways=totalways*ifact[it->second]%mod;  continue; }
    				ways = ways*ifact[it->second]%mod;	
    				totalways = totalways*ifact[it->second]%mod;
    			}
    			lld res1=0;
    			for(int i=1;i<=num1;i+=2) {
    				int rem=num1-i; if(rem==0) { res1+=ways*fact[num]%mod; res1%=mod; continue; }
    				/*lld ways1=fact[num+rem-1]; ways1=ways1*ways%mod*ifact[rem-1]%mod;
    				lld ways2=fact[num+rem]; ways2=ways2*ways%mod*ifact[rem]%mod;
    				ways2 = ways2-ways1+mod; ways2%=mod; res1+=ways2; res1%=mod;*/
    				res1  = res1 + fact[num+rem-1]*num%mod*ifact[rem]%mod; res1%=mod;
    			}
    			lld result = totalways - res1; result=result+mod; result%=mod;
    			printf(""%lld\n"", result);
    			map1.clear();
    		}
    	}
    
    	return 0;
    }

",C++
7202509,"
    #include <bits/stdc++.h>
    
    using namespace std;
    
    const int HASH_MAXN=100001;
    const int X=129;
    const int MOD1=1000000009;
    const int MOD2=1000000021;
    int P1[HASH_MAXN];
    int P2[HASH_MAXN];
    
    struct Hash
    {
        int len, val0, val1;
        Hash()
        {
            //
        }
        Hash(int val):
            len(1),
            val0(val),
            val1(val)
        {
            //
        }
        Hash operator+ (const Hash& other) const
        {
            Hash ret;
            ret.len=len+other.len;
            ret.val0=(other.val0+1LL*P1[other.len]*val0)%MOD1;
            ret.val1=(other.val1+1LL*P2[other.len]*val1)%MOD2;
            return ret;
        }
        Hash operator- (const Hash& other) const
        {
            Hash ret;
            ret.len=len-other.len;
            ret.val0=val0-1LL*P1[len-other.len]*other.val0%MOD1;
            if(ret.val0<0)
                ret.val0+=MOD1;
            ret.val1=val1-1LL*P2[len-other.len]*other.val1%MOD2;
            if(ret.val1<0)
                ret.val1+=MOD2;
            return ret;
        }
        bool operator< (const Hash& other) const
        {
            if(len!=other.len)
                return len<other.len;
            if(val0!=other.val0)
                return val0<other.val0;
            return val1<other.val1;
        }
        bool operator== (const Hash& other) const
        {
            return len==other.len && val0==other.val0 && val1==other.val1;
        }
        bool operator!= (const Hash& other) const
        {
            return !(*this==other);
        }
    };
    
    Hash make_hash(int v)
    {
        Hash ret;
        ret.val0=ret.val1=v;
        ret.len=1;
        return ret;
    }
    
    void init_hash()
    {
        P1[0]=1;
        for(int i=1; i<HASH_MAXN; i++)
            P1[i]=1LL*P1[i-1]*X%MOD1;
        P2[0]=1;
        for(int i=1; i<HASH_MAXN; i++)
            P2[i]=1LL*P2[i-1]*X%MOD2;
    }
    
    static int _hash_initialized=(init_hash(), 0);
    
    int N, Q;
    char S[100003];
    Hash L[100003], R[100003];
    
    void answer(bool b)
    {
        if(b)
            printf(""Yes\n"");
        else
            printf(""No\n"");
    }
    
    Hash getLR(int a, int b)
    {
        return L[b]-L[a-1];
    }
    
    Hash getRL(int a, int b)
    {
        return R[a]-R[b+1];
    }
    
    int main()
    {
        scanf(""%s"", S+1);
        N=strlen(S+1);
        for(int i=1; i<=N; i++)
            L[i]=L[i-1]+make_hash(S[i]);
        for(int i=N; i>=1; i--)
            R[i]=R[i+1]+make_hash(S[i]);
        scanf(""%d"", &Q);
        int a, b, c, d;
        while(Q--)
        {
            scanf(""%d%d%d%d"", &a, &b, &c, &d);
            int l=d-c+1;
            if(b<c || d<a)
                answer((L[c+l/2-1]-L[c-1])==(R[d-l/2+1]-R[d+1]));
            else if(c<=a && b<=d)
            {
                int a0=a-c;
                int a1=l/2-a0;
                Hash x=L[c+a0-1]-L[c-1];
                x=x+(R[b-a1+1]-R[b+1]);
                int a2=d-b;
                int a3=l/2-a2;
                Hash y=R[d-a2+1]-R[d+1];
                y=y+(L[a+a3-1]-L[a-1]);
                answer(x==y);
            }
            else if(c<=a && a<=d && d<=b)
            {
                Hash x, y;
                int e=c+l/2-1;
                int f=d-l/2+1;
                if(a<=f)
                {
                    int a0=f-a;
                    int a1=d-a;
                    y=getLR(b-a1, b-a0);
                }
                else
                    y=getLR(b-(d-a)+1, b)+getRL(f, a-1);
                if(a<=f)
                    x=getLR(c, a-1)+getRL(b-(e-a), b);
                else
                    x=getLR(c, e);
                answer(x==y);
            }
            else if(a<=c && c<=b && b<=d)
            {
                Hash x, y;
                int e=c+l/2-1;
                int f=d-l/2+1;
                if(b>=e)
                {
                    int a0=b-e;
                    int a1=b-c;
                    x=getLR(a+a0, a+a1);
                }
                else
                {
                    int a0=e-b;
                    int a1=b-c;
                    x=getRL(a, a+a0)+getLR(b+1, e);
                }
                if(b>=f)
                    y=getRL(b+1, d)+getLR(a, a+b-f);
                else
                    y=getRL(f, d);
                answer(x==y);
            }
        }
        return 0;
    }
    

",C++
3923622,"
    #include <bits/stdc++.h>
    using namespace std;
    #define debug(arr,sz) for(int i = sz-1; i >= 0 ; --i) cerr << arr[i] << "" ""; cerr << endl;
    typedef long long LL;
    LL A[100],sum[100],N,Num,ans;
    
    LL power(LL a,LL b){
        LL res = (b == 0) ? 1 : power(a,b/2);
        res *= res, res *= (b & 1) ? a : 1;
        return res;
    }
    
    LL func(LL st,LL id,LL strict,LL val,bool isValid){
        if (id == 0) return 0LL;
        if (st != 0) isValid = true;
        if (isValid and st == val){
            LL res;
            if (strict) res = (sum[id-1]+1LL);
            else res = power(10LL,id-1);
            //cerr << st << "" "" << id << "" "" << strict << "" returning "" << res << endl;
            return res;
        }
    
        LL Mem = 0;
        LL mx = (strict) ? A[id-1] : 9;
    
        LL new_st = (val == 1) ? 2 : 1;
        if (strict == 0){
            Mem += func(0,id-1,0,val,isValid);
            LL ct = mx - (val != 0);
            Mem += (ct)*func(new_st,id-1,0,val,isValid);
            if (val != 0)
                Mem += func(val,id-1,0,val,isValid);
        } else {
            if (mx > 0){
                Mem += func(0,id-1,0,val,isValid);
                LL ct = 0,nw;
                for(int i = 1; i < mx; ++i)
                    if (i != val) ++ct, nw = i;
                if (ct != 0)
                    Mem += ct*(func(nw,id-1,0,val,isValid));
                if (val != 0 and val < mx)
                    Mem += func(val,id-1,0,val,isValid);
            }
            Mem += func(mx,id-1,1,val,isValid);
        }
        //cerr << st << "" "" << id << "" "" << strict << "" returning "" << Mem << endl;
        return Mem;
    }
    
    LL Brute(LL num,LL id){
        LL ct = 0;
        for(LL i = 1; i <= num; ++i){
            LL k = i;
            while(k > 0)
                if (k%10 == id){
                    ++ct; break;
                } else k /= 10;
        }
        return ct;
    }
    
    void solve(){
        cin >> Num;
        int sz = 1;
        ans = 0;
        for(LL i = Num; i > 0; i /= 10, ++sz)
            A[sz] = i%10;
        sum[1] = A[1];
    
        LL pro = 10LL;
        for(int i = 2; i < sz; ++i, pro *= 10LL)
            sum[i] = A[i]*pro + sum[i-1];
        //debug(sum,sz);
        --sz;
        LL x = 0, y = Num*10LL;
        for(LL i = 0; i < 10; ++i){
            ans = 0;
            for(LL j = 0; j < A[sz]; ++j)
                ans += func(j,sz,0,i,false);
            ans += func(A[sz],sz,1,i,false);
            x += ans;
            //cerr << ""For "" << i << "" "" << ans << endl;
            //LL chk = Brute(Num,i);
            //if (chk != ans)
            //    cerr << ""Error for value "" << i << "" "",
            //    cerr << ""Expected "" << chk << "" Found "" << ans << endl;
            //cerr << ans << "" AT "" << i << endl;
        }
    
        LL g = __gcd(x,y);
        x /= g, y /= g;
        cout << x << ""/"" << y << endl;
    }
    
    int main()
    {
        int t; cin >> t;
        while(t--) solve();
        return 0;
    }
    

",C++
7265003,"
    #include <bits/stdc++.h>
    #define INF 1000000000
    #define MOD 1000000007
    #define MAXN 1000005
    #define ins insert
    #define pb push_back
    #define mp make_pair
    #define sz size
    #define rep(i, n) for(int i = 0; i < n; ++i)
    #define sd(n) scanf(""%d"",&n)
    #define sll(n) scanf(""%I64d"",&n)
    #define pdn(n) printf(""%d\n"",n)
    #define plln(n) printf(""%I64d\n"",n)
    #define pd(n) printf(""%d "",n)
    #define nl() printf(""\n"")
    using namespace std;
    
    typedef long long ll;
    typedef unsigned long long ull;
    typedef vector<ll> vi;
    typedef vector<vi> vii;
    typedef pair<ll, ll> pii;
    
    int t, k, cc; string s;
    
    bool isbal() {
        stack<char> st;
        for(int i = 0; i < s.sz(); ++i) {
            if(s[i] == '(')
                st.push(s[i]);
            else
                st.pop();
            if(st.empty())
                ++cc;        
        }
        if(st.empty())
            return true;
        return false;
    }
    
    int main() {
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        cin >> t;
        while(t--) {
            cin >> s;
            cin >> k;
            cc = 0;
            if(!isbal()) {
                if(k == 1)
                    cout << s << '\n';
                else
                    cout << -1 << '\n';
            }
            else {
                if(cc == 1) {
                    if(k > 2)
                        cout << -1 << '\n';
                    else if(k == 1) {
                        bool rem = false;
                        for(int i = 0; i < s.sz(); ++i) {
                            if(s[i] == ')' && (rem == false))
                                rem = true;
                            else
                                cout << s[i];
                        }
                        cout << '\n';
                    }
                    else {
                        for(int i = 1; i < s.sz(); ++i)
                            cout << s[i];
                        cout << '\n';
                    }
                }
                else {
                    int l = 0;
                    rep(i, s.sz()) {
                        if(s[i] == ')')
                            ++l;
                    }
                    int r = l;
                    if(k > (l+r))
                        cout << -1 << '\n';
                    else {
                        if(k <= l) {
                            int tl = 0;
                            for(int i = 0; i < s.sz(); ++i) {
                                if(s[i] == ')') {
                                    ++tl;
                                    if(tl == k) {
                                        continue;
                                    }
                                }
                                cout << s[i];
                            }
                            cout << '\n';
                        }
                        else {
                            int tr = 0;
                            k -= l;
                            //cout << ""k: "" << k << endl;
                            int xx = s.sz();
                            --xx; string ans;
                            for(int i = xx; i >= 0; --i) {
                                if(s[i] == '(') {
                                    ++tr;
                                    if(tr == k) {
                                        continue;
                                    }
                                }
                                ans += s[i];
                            }
                            reverse(ans.begin(), ans.end());
                            cout << ans;
                            cout << '\n';    
                        }
                    }
                }
            }
        }
        return 0;
    }
    
    /*
    ()()
    ()( 2
    ()) 3
    (() 1
    )() 4
    
    
    ((()))
    ((())
    (()))
    
    
    (())
    
    (()
    
    */

",C++
3472052,"
    package codechef;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.math.BigInteger;
    
    public class challenge1 {
    	int count=0,a,mark;
    	 String logical,status,newstatus;
    BufferedReader rd=new BufferedReader(new InputStreamReader(System.in));
    public int testCases() throws IOException
    {
    	System.out.println(""enter the testcases""); 
        int testcases=rd.read();
        return testcases;
    }
    public String statuscheck(String logical,int a,int no)
    {
      
    	if(logical.equals(""<"")  )
    	{
    		if(a<no)
    		{
    			newstatus=""yes"";
    		}
    		 else
    		   {
    			   newstatus=""no"";
    		   }
      }
    	  
    	 if(logical.equals("">""))
    	{
    		 if(a>no)
    		 {
    		  newstatus=""yes"";
    		 }
    		 else
    		   {
    			   newstatus=""no"";
    		   }
    	}
    	  
       if(logical.equals(""="") )
    	{
    	   if(a==no)
    	   {
    		 newstatus=""yes"";
    	   }
    	   else
    	   {
    		   newstatus=""no"";
    	   }
    	}
        
    	return newstatus;
    	}
    public void computeValue() throws IOException
    {
    	String line=rd.readLine();
    	int testcase=Integer.parseInt(line);
    	 
    	for (int i=0;i<testcase;i++)
    	{
    		String line2=rd.readLine();
    		int hintno=Integer.parseInt(line2);
    		for(int j=0;j<hintno;j++)
    		{
    			String conseline=rd.readLine();
    			String st[]=conseline.split("" "");
                 logical=st[0];
                String no=st[1];
                 mark=Integer.parseInt(no);
    		    String status=st[2];
                 a=100;
                String stat= statuscheck(logical,a,mark);
                if(stat.equals(status))
                {
                	count=0;
                }
                else
                {
                	count++;
                }
    		}
    			  System.out.println(count);
    		   
    		
    	}
    }
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
      challenge1 ch=new challenge1();
      ch.computeValue();
      
    	}
    
    }
    

",JAVA
9254797,"
    #include <cmath>
    #include <cstdio>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <iostream>
    #include <string>
    #include <algorithm>
    #define MAXISLAND 1000
    #define INF 99999999
     
    using namespace std;
     
    template<typename T>
    T getNum(){
    	T res=0;
    	char c;
    	while(1){
    		//c=getchar();
    		c = getchar_unlocked();
    		if(c==' ' || c=='\n') continue;
    		else break;
    	}
    	res=c-'0';
    	while(1){
    		//c=getchar();
    		c = getchar_unlocked();
    		if(c>='0' && c<='9') res=10*res+c-'0';
    		else break;
    	}
    	return res;
    }
     
    string getString()
    {
        string i = """";
        while(1)
        {
        	char t = getchar_unlocked();
        	if(t == '\n' || t == ' '){
        		break;
        	}
        	i += t;
        }
        return i;
    }
     
    struct Point_t {
    	int x, y, batas, typePoint;
    	//typePoint 1: point rect
    	//			2: terminal
    	string namePoint;
    };
    struct Point_tComparer
    {
        bool operator()(Point_t const &e1, Point_t const &e2)
    	{
    		return e1.namePoint < e2.namePoint;
    	}
    };
     
    struct Line_t {Point_t A, B;};
    struct RestrictedArea_t {Line_t line1, line2, line3, line4;};
    struct Graph_t {double weight; string nameDestination; vector<Point_t> listPointSelected;};
    struct Graph_tComparer {
    	bool operator()(Graph_t const &e1, Graph_t const &e2)
    	{
    		return e1.weight < e2.weight;
    	}
    };
    map< string, vector<Graph_t> > G;
    set<Point_t,Point_tComparer> listPoint[MAXISLAND+2];
    int nIsland;
    double resultDist, weight[MAXISLAND+2];
     
    Point_t getPoint(string name)
    {
    	for (int i = 0; i < nIsland; ++i)
    	{
    		Point_t pointTemp;
    		pointTemp.namePoint = name;
    		set<Point_t>::iterator it;
    		it = listPoint[i].find(pointTemp);
    		if(it->namePoint == name){
    			//cout << ""yang dicari "" << name << "" , ketemunya "" << listPoint[i][idx].namePoint << endl;
    			return *it;
    		}
    	}
    	//return *listPoint[0].begin();
    }
     
    int getIdxIslandPoint(string name)
    {
    	for (int i = 0; i < nIsland; ++i)
    	{
    		Point_t pointTemp;
    		pointTemp.namePoint = name;
    		set<Point_t>::iterator it;
    		it = listPoint[i].find(pointTemp);
    		if(it->namePoint == name){
    			//cout << ""yang dicari "" << name << "" , ketemunya "" << listPoint[i][idx].namePoint << endl;
    			return i;
    		}
    	}
    	//return 0;
    }
     
    void dijkstra(string s, string t, vector<Point_t> &listLocalPointSelected)
    {
    	map<string, double> tentative;
    	map<string, double> weightOriginal;
    	map<string, bool> visited;
    	map<string, string> prev;
    	int size;
     
    	for(int i = 0; i < nIsland; i++)
    	{
    		for (set<Point_t>::iterator it = listPoint[i].begin(); it != listPoint[i].end(); ++it)
    	    {
    	    	tentative[it->namePoint] = INF;
    	    	visited[it->namePoint] = false;
    	    }
    	}
        
    	prev[s] = ""-"";
    	tentative[s] = 0.0;
    	Graph_t current;
    	visited[s] = true;
    	
    	priority_queue<Graph_t,vector<Graph_t>,Graph_tComparer> Q;
    	Q.push({0.0, s});
    	
    	while(1)
    	{
    		if(Q.empty())
    			break;
    		current = Q.top();
    		Q.pop();
    		
    		string nowV = current.nameDestination;
    		double nowW = -current.weight;
    		//cout << ""nowV "" << nowV << "" nowW "" << nowW << "" idxIsland: "" << getIdxIslandPoint(nowV) << endl;
    		size = G[nowV].size();
    		if(tentative[nowV] != nowW)
    			continue;
    		
    		for(int i = 0; i < size; i++)
    		{
    			string d = G[nowV][i].nameDestination;
    			if(visited[d])
    				continue;
    				
    			double tmp = nowW + G[nowV][i].weight;
    			//cout << ""cek "" << d << "" w "" << tmp << endl;
    			if(tentative[d] > tmp)
    			{
    				tentative[d] = tmp;
    				Q.push({-tmp,d});
    				prev[d] = nowV;
    				//cout << ""kepilih "" << d << "" w "" << tmp << endl;
    			}
    		}	
    		visited[nowV] = true;
    		if(nowV == t)
    			break;
    	}
    	
    	string namePoint = t;
    	Point_t point;
    	int idxBefore, idxAfter;
    	
    	while(namePoint != ""-""){
    		point = getPoint(namePoint);
    		listLocalPointSelected.insert(listLocalPointSelected.begin(),point);
    		idxAfter = getIdxIslandPoint(namePoint), idxBefore = getIdxIslandPoint(prev[namePoint]);
    		double w1 = tentative[namePoint], w2 = (prev[namePoint] == ""-"" ? 0 : tentative[prev[namePoint]]);
    		if(idxAfter == idxBefore){
    			weight[idxAfter] += w1 - w2;
    			//cout << ""yyy "";
    		} else {
    			resultDist += w1 - w2;
    			//cout << ""zzz "";
    		}
    		//cout << namePoint << ""-"" << prev[namePoint] << "": "" << w1-w2 << endl;
    		idxBefore = idxAfter;
    		namePoint = prev[namePoint];
    	}
    	//resultDist = tentative[t];
    }
     
    double eucledian_dist(Point_t point1, Point_t point2)
    {
    	return sqrt((point1.x - point2.x)*(point1.x - point2.x) + 
    				(point1.y - point2.y)*(point1.y - point2.y));
    }
     
    bool equalPoint(Point_t point1, Point_t point2)
    {
    	if(point1.x == point2.x && point1.y == point2.y)
    	{
    		return true;
    	}
    	return false;
    }
     
    bool equalLine(Line_t line1, Line_t line2)
    {
    	if( (equalPoint(line1.A,line2.A) && equalPoint(line1.B,line2.B)) ||
    		(equalPoint(line1.B,line2.A) && equalPoint(line1.A,line2.B)) )
    	{
    		return true;
    	}
    	return false;
    }
     
    Point_t decreasePoint(Point_t point1, Point_t point2)
    {
    	Point_t pointRes;
     
    	pointRes.x = point1.x - point2.x;
    	pointRes.y = point1.y - point2.y;
     
    	return pointRes;
    }
     
    double multiplyPoint(Point_t point1, Point_t point2)
    {
    	return point1.x * point2.x + point1.y * point2.y;
    }
     
    bool intersectDistance(Line_t line1, Line_t line2)
    {
    	Point_t P1;
    	P1.x = -(line1.B.y-line1.A.y);
    	P1.y = line1.B.x - line1.A.x;
     
    	Point_t P2 = decreasePoint(line2.B,line2.A);
     
    	double Denominator = P2.x * P1.x + P2.y * P1.y;
     
    	if (Denominator == 0.0)
    	{
    		return false;
    	}
     
    	double IntersectDistance = (multiplyPoint(decreasePoint(line1.A,line2.A),P1)) / Denominator;
    	if (0.0 < IntersectDistance && IntersectDistance < 1.0)
    	{
    		P1.x = -(line2.B.y-line2.A.y);
    		P1.y = line2.B.x - line2.A.x;
    		IntersectDistance = (multiplyPoint(decreasePoint(line2.A,line1.A),P1)) / (multiplyPoint(decreasePoint(line1.B,line1.A),P1));
    		if (0.0 < IntersectDistance && IntersectDistance < 1.0)
    		{
    			return true;
    		}
    	}
    	return false;
    }
     
    void generateEdgeInIsland(vector<RestrictedArea_t> listRestrictedArea, int idxIsland)
    {
    	for (set<Point_t>::iterator it = listPoint[idxIsland].begin(); it != listPoint[idxIsland].end(); ++it)
    	{
    		for (set<Point_t>::iterator it2 = it; it2 != listPoint[idxIsland].end(); ++it2)
    		{
    			if(it->namePoint == it2->namePoint) continue;
    			
    			//cek per pair point,
    			bool isValid = true;
    			//dengan tiap restricted area,
    			for (vector<RestrictedArea_t>::iterator it3 = listRestrictedArea.begin(); it3 != listRestrictedArea.end(); ++it3)
    			{
    				//cek dengan tiap garisnya
    				Line_t lineNew;
    				lineNew.A = *it;
    				lineNew.B = *it2;
     
    				if( equalLine(lineNew, it3->line1) ||
    					equalLine(lineNew, it3->line2) ||
    					equalLine(lineNew, it3->line3) ||
    					equalLine(lineNew, it3->line4))
    				{
    					break;
    				}
     
    				if ( (equalPoint(lineNew.A,(it3->line1).A) && equalPoint(lineNew.B,(it3->line3).B)) ||
    					 (equalPoint(lineNew.A,(it3->line2).B) && equalPoint(lineNew.B,(it3->line1).B)) ||
    					 (equalPoint(lineNew.A,(it3->line3).B) && equalPoint(lineNew.B,(it3->line1).A)) ||
    					 (equalPoint(lineNew.A,(it3->line1).B) && equalPoint(lineNew.B,(it3->line2).B)) )
    				{
    					isValid = false;
    					break;
    				}
     
    				if ( (intersectDistance(lineNew,it3->line1)) ||
    					 (intersectDistance(lineNew,it3->line2)) || 
    					 (intersectDistance(lineNew,it3->line3)) || 
    					 (intersectDistance(lineNew,it3->line4)))
    				{
    					isValid = false;
    					break;
    				}
    			}
    			if(isValid)
    			{
    				//bikin edge baru berdasarkan line tsb
    				double w = eucledian_dist(*it,*it2);
    				G[it->namePoint].push_back({w, it2->namePoint});
    				G[it2->namePoint].push_back({w, it->namePoint});
    				//cout << it->namePoint << "" "" << it2->namePoint << "" "" << w << endl;
    			}
    		}
    	}
    }
     
    void addPoint(string str, int x, int y, int batas, int typePoint, int idxIsland)
    {
    	//int x, y, batas, typePoint;
    	//typePoint 1: point rect
    	//			2: terminal
    	listPoint[idxIsland].insert({x, y, batas, typePoint, str});
    }
     
    int main()
    {
    	int T, t, w, h, nTerminal, nRestrictedArea, nEdgeNew, x1, y1, x2, y2;
    	string nameIsland;
    	vector<Point_t> listPointTemp;
     
    	T = getNum<int>();
    	for (int t = 1; t <= T; t++)
    	{
    		G.clear();
    		resultDist = 0.0;
    		
    		nIsland = getNum<int>();
    		
    		for(int i = 0; i < nIsland; i++)
    			if(!listPoint[i].empty())
    				listPoint[i].clear();
    			
    		for(int i = 0; i < nIsland; i++)
    		{
    			weight[i] = 0.0;
    			nameIsland = getString();
    			w = getNum<int>();
    			h = getNum<int>();
    			nTerminal = getNum<int>();
    			
    			for(int j = 0; j < nTerminal; j++)
    			{
    				string nameTerminal;
    				int x, y;
     
    				nameTerminal = getString();
    				x = getNum<int>();
    				y = getNum<int>();
     
    				addPoint(nameIsland + nameTerminal, x, y, nameIsland.length(), 2, i);
    			}
     
    			nRestrictedArea = getNum<int>();
     
    			vector<RestrictedArea_t> listRestrictedArea;
     
    			for(int j = 0; j < nRestrictedArea; j++)
    			{
    				//x1,y1
    				//--------------- 1
    				//| 2 			 | 3
    				//|  			 |
    				//|  			 |
    				//---------------- 4	x2,y2
    				x1 = getNum<int>();
    				y1 = getNum<int>();
    				x2 = getNum<int>();
    				y2 = getNum<int>();
     
    				Line_t lineNew1, lineNew2, lineNew3, lineNew4;
     
    				lineNew1.A.x = x1;
    				lineNew1.A.y = y1;
    				lineNew1.B.x = x2;
    				lineNew1.B.y = y1;
     
    				lineNew2.A.x = x1;
    				lineNew2.A.y = y1;
    				lineNew2.B.x = x1;
    				lineNew2.B.y = y2;
     
    				lineNew3.A.x = x2;
    				lineNew3.A.y = y1;
    				lineNew3.B.x = x2;
    				lineNew3.B.y = y2;
     
    				lineNew4.A.x = x1;
    				lineNew4.A.y = y2;
    				lineNew4.B.x = x2;
    				lineNew4.B.y = y2;
    				
    				listRestrictedArea.push_back({lineNew1, lineNew2, lineNew3, lineNew4});
     
    				string strRestrictedArea;
    				strRestrictedArea += '0' + j;
     
    				addPoint(""PointOfRect"" + nameIsland + strRestrictedArea + ""1"", lineNew1.A.x, lineNew1.A.y, 11, 1, i);
    				addPoint(""PointOfRect"" + nameIsland + strRestrictedArea + ""2"", lineNew1.B.x, lineNew1.B.y, 11, 1, i);
    				addPoint(""PointOfRect"" + nameIsland + strRestrictedArea + ""3"", lineNew3.B.x, lineNew3.B.y, 11, 1, i);
    				addPoint(""PointOfRect"" + nameIsland + strRestrictedArea + ""4"", lineNew4.A.x, lineNew4.A.y, 11, 1, i);
    			}
     
    			generateEdgeInIsland(listRestrictedArea, i);
    		}
     
    		nEdgeNew = getNum<int>();
     
    		string terminal1, terminal2, island1, island2;
    		double w;
    		
    		listPointTemp.clear();
    		
    		for (int j = 0; j < nEdgeNew; j++)
    		{
    			terminal1 = getString();
    			island1 = getString();
    			terminal2 = getString();
    			island2 = getString();
    			w = getNum<double>();
    			
    			island1 += terminal1;
    			island2 += terminal2;
    			
    			G[island1].push_back({w, island2});
    			G[island2].push_back({w, island1});
    		}
    		terminal1 = getString();
    		island1 = getString();
    		terminal2 = getString();
    		island2 = getString();
     
    		island1 += terminal1;
    		island2 += terminal2;
     
    		printf(""case %d Y\n"", t);
    		dijkstra(island1,island2,listPointTemp);
    		//printf(""%.0lf\n"", resultDist);
    		//cout << ""aaa"" << endl;
    		for(int i = 0; i < nIsland; i++)
    		{
    			//cout << i << "", the weight for that: "" << weight[i] << endl;
    			weight[i] = ceil(weight[i]);
    			resultDist += weight[i];
    		}
    		//cout << ""bbb"" << endl;
    		printf(""%.0lf\n"", resultDist);
    		for (vector<Point_t>::iterator it = listPointTemp.begin(); it != listPointTemp.end(); ++it)
    		{
    			if(it->typePoint == 1)
    				printf(""%d %d\n"", it->x, it->y);
    			else
    			{
    				int nTemp = it->namePoint.length();
    				for (int i = it->batas; i < nTemp; ++i)
    				{
    					printf(""%c"", (it->namePoint)[i]);
    				}
    				printf("" "");
    				for (int i = 0; i < it->batas; ++i)
    				{
    					printf(""%c"", (it->namePoint)[i]);
    				}
    				puts("""");
    			}
    		}
    		puts("""");
    	}
    	return 0;
    }  

",C++
6608111,"
    #include <vector>
    #include <queue>
    #include <map>
    #include <set>
    #include <utility> //Pair
    #include <algorithm>
    #include <sstream> // istringstream>> ostring stream<<
    #include <iostream>
    #include <iomanip>
    //setbase - cout << setbase (16); cout << 100 << endl; Prints 64
    //setfill - cout << setfill ('x') << setw (5); cout << 77 << endl; prints xxx77
    //setprecision - cout << setprecision (4) << f << endl; Prints x.xxxx
    #include <cstdio>
    #include <cmath>
    #include <cstdlib>
    #include <ctime>
    #include <cstring>
    #include <limits>
    using namespace std;
     
    
    typedef long long ll;
    typedef vector <int> vi;
    typedef pair< int ,int > pii;
    typedef istringstream iss;
    typedef ostringstream oss;
    #define pb push_back
    #define mp make_pair
    #define ff first
    #define ss second
    #define sz size()
    #define ln length()
    #define rep(i,n) for(int i=0;i<n;i++)
    #define fu(i,a,n) for(int i=a;i<=n;i++)
    #define fd(i,n,a) for(int i=n;i>=a;i--)
    #define all(a) a.begin(),a.end()
    #define ESP (1e-9)
     
    #define gi(n) scanf(""%d"",&n)
    #define gl(n) cin >> n
    #define pi(n) printf(""%d"",n)
    #define pl(n) cout << n
    #define ps printf("" "")
    #define pn printf(""\n"")
    #define dg(n,s); printf(""%s %d"",s,n)
    #define imax numeric_limits<int>::max()
    #define imin numeric_limits<int>::min()
    #define lmax numeric_limits<ll>::max()
    #define lmin numeric_limits<ll>::min()
    
    vector<pair<ll,ll> > dish;
    vector<pair<ll,pair<ll,ll> > > clan;
    
    bool whetherpossible(ll start){
    	ll itr1=0,itr2=0;
    	while(itr1 < (ll)dish.size() && itr2 < (ll)clan.size()){
    		if(dish[itr1].first < clan[itr2].first){
    			start-=dish[itr1].second;
    			itr1+=1;
    			if(start < 0){
    				return false;
    			}
    		}
    		else{
    			if(start>=clan[itr2].second.first){
    				start+=clan[itr2].second.second;
    			}
    			itr2+=1;
    		}
    	}
    	while(itr1 < (ll)dish.size()){
    		start-=dish[itr1].second;
    		itr1+=1;
    		if(start < 0){
    			return false;
    		}
    	}
    	if(start >=1){
    		return true;
    	}
    	else{
    		return false;
    	}
    
    }
    
    int main(){
    	ll t;
    	cin >> t;
    	while(t--){
    		//clear
    		dish.clear();
    		clan.clear();
    		ll X,B,maxreq=1;
    		cin >> X;
    		cin >> B;
    		while(B--){
    			ll xi,yi;
    			cin >> xi >> yi ;
    			dish.pb(mp(xi,yi));
    			maxreq+=(yi);
    		}
    		ll C;
    		cin >> C;
    		while(C--){
    			ll pi,qi,ri;
    			cin >> pi >> qi >> ri;
    			clan.pb(mp(pi,mp(qi,ri)));
    		}
    		//check by binary search for the first a belonging to 1 to maxreq that satisfies the condition
    		sort(dish.begin(),dish.end());
    		sort(clan.begin(),clan.end());
    		ll left=0,right=maxreq;
    		ll ans = maxreq;
    		while(left <= right){
    			ll mid = (right + left)/2;
    			if(whetherpossible(mid)){
    				ans=min(ans,mid);
    				right=mid -1;
    			}
    			else{
    				left=mid+1;
    			}
    		}
    	cout << ans <<endl;
    
    	}
    	return 0;
    }
    

",C++
3269546,"
    #include<iostream.h>
    #include<conio.h>
    #include<math.h>
    void calc()
    {
      int x,k,rem,j,c;
      long n;
     int a[50];
     cout<<""enter a number along with  digits you want to display ""<<endl;
     cin>>x>>k;
     n=pow(x,x);
      int i=0;
      while(n>0)
      {
      rem=n%10;
      n=n/10;
      a[i]=rem;
      i++;
      }
      j=k-1;
      c=k;
      i=i-1;
     while(k>0)
     {
      cout<<a[i];
     k--;
     i--;
     }
     cout<<""   "" ;
     while(c>0)
     {
      cout<<a[j];
      j--;
      c--;
    
     }
    
     }
    void main()
    {
     clrscr();
     int t;
     cout<<""enter test cases""<<endl;
     cin>>t;
     for(int i=0;i<t;i++)
     {
       calc();
       cout<<endl;
     }
     getch();
     }
    
    
    

",C++
7476243,"
    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    
    long int lazy[1000005];
    
    struct use
    {
        long long int mul;
        long long int add;
        long long int node_val;
    }st[1000000];
    
    long long int M=1000000007;
    long int n,x,max_size;
    
    
    
    void build_tree(long long int A[],long int index,long int start,long int _end)
    {
        if(start==_end)
        {
            st[index].node_val=A[start];
            return ;
        }
        build_tree(A,index*2+1,start,(start+_end)/2);
        build_tree(A,index*2+2,(start+_end)/2+1,_end);
        st[index].node_val=st[index*2+1].node_val+st[index*2+2].node_val;
    }
    
    void update_tree1(long int index,long int x,long int y,long int start,long int _end,long long int v)
    {
    	if (lazy[index]!=0)
    	{
    		st[index].node_val=((st[index].node_val*st[index].mul)%M+(st[index].add*(_end-start+1))%M)%M;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=((st[index*2+1].add*st[index].mul)%M+st[index].add)%M;
    			st[index*2+1].mul=(st[index*2+1].mul*st[index].mul)%M;
    			st[index*2+2].add=((st[index*2+2].add*st[index].mul)%M+st[index].add)%M;
    			st[index*2+2].mul=(st[index*2+2].mul*st[index].mul)%M;
    		}
    		st[index].add=0;
    		st[index].mul=1;
    		lazy[index]=0;
    	}
    	if(start>y||_end<x) return;
    
    	if (start>=x && _end<=y)
    	{
            st[index].add+=v;
            st[index].add%=M;
            st[index].node_val=(((st[index].node_val%M)*(st[index].mul%M))%M+((st[index].add%M)*((_end-start+1)%M))%M)%M;
            st[index].add=0;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add+=v;
    			st[index*2+1].add%=M;
    			st[index*2+2].add+=v;
    			st[index*2+2].add%=M;
    		}
    		return;
    	}
        update_tree1(index*2+1,x,y,start,(start+_end)/2,v);
        update_tree1(index*2+2,x,y,(start+_end)/2+1,_end,v);
        st[index].node_val=st[index*2+1].node_val+st[index*2+2].node_val;
        st[index].node_val%=M;
    }
    
    void update_tree2(long int index,long int x,long int y,long int start,long int _end,long long int v)
    {
        if (lazy[index]!=0)
    	{
    		st[index].node_val=((st[index].node_val*st[index].mul)%M+(st[index].add*(_end-start+1))%M)%M;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=((st[index*2+1].add*st[index].mul)%M+st[index].add)%M;
    			st[index*2+1].mul=(st[index*2+1].mul*st[index].mul)%M;
    			st[index*2+2].add=((st[index*2+2].add*st[index].mul)%M+st[index].add)%M;
    			st[index*2+2].mul=(st[index*2+2].mul*st[index].mul)%M;
    		}
    		st[index].add=0;
    		st[index].mul=1;
    		lazy[index]=0;
    	}
    	if(start>y||_end<x) return;
    
    	if (start>=x && _end<=y)
    	{
    		st[index].mul=((st[index].mul%M)*(v%M))%M;
    		st[index].add=((st[index].add%M)*(v%M))%M;
    		st[index].node_val=(((st[index].node_val%M)*(st[index].mul%M))%M+((st[index].add%M)*((_end-start+1)%M))%M)%M;
    		st[index].mul=1;
    		st[index].add=0;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=(st[index*2+1].add%M+((st[index*2+1].add%M)*(v%M))%M)%M;
    			st[index*2+1].mul=(st[index*2+1].mul%M+((st[index*2+1].mul%M)*(v%M))%M)%M;
    			st[index*2+2].add=(st[index*2+2].add%M+((st[index*2+2].add%M)*(v%M))%M)%M;
    			st[index*2+2].mul=(st[index*2+2].mul%M+((st[index*2+2].mul%M)*(v%M))%M)%M;
    		}
    		return;
    	}
            update_tree2(index*2+1,x,y,start,(start+_end)/2,v);
            update_tree2(index*2+2,x,y,(start+_end)/2+1,_end,v);
            st[index].node_val=st[index*2+1].node_val+st[index*2+2].node_val;
            st[index].node_val%=M;
    }
    
    void update_tree3(long int index,long int x,long int y,long int start,long int _end,long long int v)
    {
        if (lazy[index]!=0)
    	{
    		st[index].node_val=((st[index].node_val*st[index].mul)%M+(st[index].add*(_end-start+1))%M)%M;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=(st[index*2+1].add*st[index].mul)%M+st[index].add;
    			st[index*2+1].mul=(st[index*2+1].mul*st[index].mul)%M;
    			st[index*2+2].add=(st[index*2+2].add*st[index].mul)%M+st[index].add;
    			st[index*2+2].mul=(st[index*2+2].mul*st[index].mul)%M;
    		}
    		st[index].add=0;
    		st[index].mul=1;
    		lazy[index]=0;
    	}
    	if(start>y||_end<x) return;
    
    	if (start>=x && _end<=y)
    	{
    		st[index].mul=0;
    		st[index].add=v;
    		st[index].node_val=(((st[index].node_val%M)*(st[index].mul%M))%M+((st[index].add%M)*((_end-start+1)%M))%M)%M;
    		st[index].mul=1;
    		st[index].add=0;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=v;
    			st[index*2+2].add=v;
    			st[index*2+1].add%=M;
    			st[index*2+2].add%=M;
    		}
    		return;
    	}
    	update_tree3(index*2+1,x,y,start,(start+_end)/2,v);
            update_tree3(index*2+2,x,y,(start+_end)/2+1,_end,v);
            st[index].node_val=st[index*2+1].node_val+st[index*2+2].node_val;
        st[index].node_val%=M;
    }
    
    long long int query_tree(long int index,long int left,long int right,long int start,long int _end)
    {
        long long int a1,a2,ans;
        if(left>_end || right<start)
            return 0;
        if (lazy[index]!=0)
    	{
    		st[index].node_val=((st[index].node_val*st[index].mul)%M+(st[index].add*(_end-start+1))%M)%M;
            if (start!=_end)
    		{
    			lazy[index*2+1]=1;
    			lazy[index*2+2]=1;
    			st[index*2+1].add=(st[index*2+1].add*st[index].mul)%M+st[index].add;
    			st[index*2+1].mul=(st[index*2+1].mul*st[index].mul)%M;
    			st[index*2+2].add=(st[index*2+2].add*st[index].mul)%M+st[index].add;
    			st[index*2+2].mul=(st[index*2+2].mul*st[index].mul)%M;
    		}
    		st[index].add=0;
    		st[index].mul=1;
    		lazy[index]=0;
    	}
        if(left<=start && right>=_end)
            return st[index].node_val;
        a1=query_tree(index*2+1,left,right,start,(start+_end)/2);
        a2=query_tree(index*2+2,left,right,(start+_end)/2+1,_end);
        ans=a1+a2;
        ans%=M;
        return ans;
    }
    
    int main()
    {
        long int q,i,x,y;
        int first;
        scanf(""%ld %ld"",&n,&q);
        x = (long int)(ceil(log2(n)));
        max_size = 2*(long int)pow(2, x) - 1;
        long long int A[100005],ans,v;
        memset(lazy,0,sizeof lazy);
        for(i=0;i<n;i++)
            scanf(""%lld"",&A[i]);
        build_tree(A,0,0,n-1);
        for(i=0;i<max_size;i++)
        {
            st[i].mul=1;
            st[i].add=0;
        }
        while(q--)
        {
            scanf(""%d"",&first);
            if(first==1)
            {
                scanf(""%ld %ld %lld"",&x,&y,&v);
                update_tree1(0,x-1,y-1,0,n-1,v);
                /*for(i=0;i<7;i++)
                    printf(""%lld "",st[i].node_val);
                printf(""\n"");
                for(i=0;i<7;i++)
                    printf(""%lld "",lazy[i]);
                printf(""\n"");*/
            }
            else if(first==2)
            {
                scanf(""%ld %ld %lld"",&x,&y,&v);
                update_tree2(0,x-1,y-1,0,n-1,v);
                /*for(i=0;i<7;i++)
                    printf(""%lld "",st[i].node_val);
                printf(""\n"");
                for(i=0;i<7;i++)
                    printf(""%lld "",lazy[i]);
                printf(""\n"");*/
            }
            else if(first==3)
            {
                scanf(""%ld %ld %lld"",&x,&y,&v);
                update_tree3(0,x-1,y-1,0,n-1,v);
            }
            else
            {
                scanf(""%ld %ld"",&x,&y);
                ans=query_tree(0,x-1,y-1,0,n-1);
                printf(""%lld\n"",ans%M);
                /*printf(""%ld %ld %ld %ld %ld\n"",st[0],st[1],st[2],st[3],st[4],st[5]);
                printf(""%ld %ld %ld %ld %ld\n"",last[0],last[1],last[2],last[3],last[4],last[5]);*/
            }
        }
        return 0;
    }
    

",C++
2838453,"
    #include<iostream>
    #include<cstdio>
    #include<vector>
    #include<iomanip>
    #include<algorithm>
    using namespace std;
    int main()
    {
    
        int t;
        cin>>t;
    
        while(t--)
        {
            int n;
            cin>>n;
            vector<int> a;
            vector<int> b;
            for(int i=0;i<n;i++)
                {
                    int temp;
                    cin>>temp;
                    if(temp!=1)
                        a.push_back(temp);
                }
                int b1=0,b2=0,b3=0,b4=0;
            for(int i=0;i<n;i++)
                {int temp;
                    cin>>temp;if(temp==1) b1++;
                    else if(temp==2) {b2++; b.push_back(temp);}
                    else if(temp==3) {b3++; b.push_back(temp);}
                    else if(temp==4) {b4++; b.push_back(temp);}
                else
                    b.push_back(temp);
                }
    
            sort(a.begin(),a.end());
            sort(b.begin(),b.end());
            double total = b1*a.size();//for all pairs where b[i] = 1
            if(b.size())
            for(int i=0;i<a.size() && a[i]<=b[b.size()-1];i++)
            {
    
                if(a[i]==2)
                {
                    int bcount = b.end()- upper_bound(b.begin(),b.end(),4);//valid only for greater than 5
                    int acount=0;
                    while(a[i]==2 && i<a.size()){acount++;i++;}
                    i--;
                    total=total + (long long)(bcount)*(long long)(acount);
                }
                else if(a[i]==3)
                {
                    int bcount = b.size()-b3; //for  a[i]=3 any b[i] except 3 will work
                    int acount = 0;
                    while(a[i]==3 && i<a.size()){acount++;i++;}
                    i--;
                    total=total + (long long)(bcount)*(long long)(acount);
                }
                else
                {
                    int bcount;
                    if(b[b.size()-1]<=a[i])
                        break;
                    else if(a[i]<b[0])
                        bcount = b.size();
                    else
                    bcount = b.end() - upper_bound(b.begin(),b.end(),a[i]); //for other values valid only when y>x
                    int acount = 0;int temp = a[i];
                     while(a[i]==temp && i<a.size()){acount++;i++;}
                     i--;
                    total=total + (long long)(bcount)*(long long)(acount);
    
                }
            }
    
            cout<<std::setprecision(6)<<total/double(n)<<endl;
        }
    
        return 0;
    }
    
    

",C++
2830667,"
    #include<stdio.h>
    #include<math.h>
    int main()
    {
        int t,n,i,j,k,l,m,a[100000],b[100000];
        float count=0,avgcount=0;
        scanf(""%d"",&t);
    
        for(i=0;i<t;i++)
        {
            l=0;
            scanf(""%d"",&n);
            for(j=0;j<(n+n);j++)
            {
                if(j<n)
                scanf(""%d"",&a[j]);
                else
                {
                  scanf(""%d"",&b[l]);
                  l++;
                }
    
            }
            for(m=0;m<n;m++)
            {
            for(k=0;k<n;k++)
                {
                    if(pow(a[m],b[k])>pow(b[k],a[m]))
                    avgcount++;
                }
            }
            printf(""%f\n"",avgcount/n);
            avgcount=0;
        }
         return 0;
        }
    

",C
10261071,"
    #include <iostream>
    using namespace std;
    int main(){
        int t,m,n;
        cin>>t;
        for(int i=0;i<t;i++){
            cin>>m>>n;
            double A[m+1][n+1],res=0;
            for(int j=0;j<n+1;j++)
                A[0][j]=0;
            for(int j=0;j<m+1;j++)
                A[j][0]=0;
            if(m == 1)
                res = n;
            else if(n == 1)
                res = m;
            else{
            for(int j=1;j<=m;j++){
                for(int k=1;k<=n;k++){
                    if((j == 1 && k == 1) || (j == m && k == n)){
                        A[j][k]=1;
                        res+=A[j][k];
                    }
                    else if(j == m){
                        A[j][k]=A[j-1][k]/2+A[j][k-1];
                        res+=A[j][k];
                    }
                    else if(k == n){
                        A[j][k]=A[j-1][k]+A[j][k-1]/2;
                        res+=A[j][k];
                    }
                    else{
                        A[j][k]=(A[j-1][k]+A[j][k-1])/2;
                        res+=A[j][k];
                    }
                }
            }
            }
            cout<<res<<endl;
        }
    }
    

",C++
6304678,"
    #include <stdio.h>
    #include <iostream>
    using namespace std;
    
    double dp[1005][1005];
    
    int main() {
    	// your code goes here
    	
    	int t;
    	cin>>t;
    	while(t--)
    	 {
    	     int n,m;
    	     cin>>n>>m;
    	     dp[1][1] = 1.0;
    	     bool flag = true;
    	     for(int i= 1;i<=n;i++)
    	      {
    	          for(int j=1;j<=m;j++)
    	           {
    	               
    	               int ni = i+1,nj = j+1; 
    	               if(ni<=n && nj<=m) // 11
    	                {
    	                    dp[i][nj] += dp[i][j]/2;
    	                    dp[ni][j] += dp[i][j]/2;
    	                    
    	                }
    	                else if(ni <= n && nj>m) //10
    	                 {
    	                     dp[ni][j] += dp[i][j];
    	                 }
    	                 else if(ni>n && nj<=m) // 01
    	                 {
    	                     dp[i][nj] += dp[i][j];
    	                 }
    	           }
    	      }
    	     
    	     double ans = 0;
    	     for(int i= 1;i<=n;i++)
    	      {
    	          for(int j=1;j<=m;j++)
    	           {
    	              ans += dp[i][j];
    	              dp[i][j] = 0;
    	           }
    	      }
    	     printf(""%.6f\n"",ans);
    	 }
    	
    	
    	
    	return 0;
    }
    

",C++
5936619,"
    #include<stdio.h>
     
    int main(void)
    {
    	int t;
    	scanf(""%d"",&t);	
    	while(t--)
    	{
    		int n,m;
    		scanf(""%d %d"",&n,&m);
    		double ans;
    		ans = (double)n+m;
    		ans--;
    		printf(""%.8lf\n"",ans);
    	}
    	return 0;
    }
     

",C++
3647218,"
    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    #include<bitset>
    #include<vector>
    using namespace std;
    bitset<102> bvec[58],bcom[3000];
    bitset<102> temp,set;
    int flag[3000];
    inline int Scan_f()
    {
        register int noRead=0;
        register char p=getchar_unlocked();
        //register char p=getc(stdin);
        for(;p<48 || p>57;p=getchar_unlocked());
        //for(;p<48 || p>57;p=getc(stdin));
        while(p>47 && p<58){ noRead = (noRead << 3) + (noRead << 1) + (p - '0');p=getchar_unlocked();}
        //while(p>47 && p<58){ noRead = (noRead << 3) + (noRead << 1) + (p - '0');p=getc(stdin);}
        return noRead;
    }; 
    
    
    int main()
    {
      int n,i,j,m,T,v,ans,tmp,k,ncm,l,sm,flag;
      T = Scan_f();
      while(T > 0)
      {
       ans = 0;
       ncm = 0;
       set.reset();
       n = Scan_f();
       m = Scan_f();
      for(j=0;j<m;j++)
      {
        v = Scan_f();
        for(i=0;i<v;i++)
        {
    	 tmp = Scan_f();
    	 bvec[j][tmp] = 1;
        }
      }  
     for(i=0;i<m;i++)
     {
      for(j=i+1;j<m;j++)
      {
       temp = bvec[i];  
       temp = temp&bvec[j];
       bcom[ncm++] = temp;
      }
     }
     temp.reset();
     k = 0;
     l = m-1;
     sm = m-1;
     for(i=0;i<ncm;i++)
     {
      if(i == l)
      {
       k += l;
       l += --sm; 
      } 	    
      for(j=k;j<l;j++)
      {
    
       temp = bcom[i];				  
       temp = temp&bcom[j];
       if(temp != 0)
        bcom[i] = temp;
      }  
     }
     temp.reset();
     for(i=0;i<ncm;i++)
     {
      temp = temp|bcom[i];
      if(temp != bcom[i] && bcom[i].any())
       ans++;
      if(ans == 0 && temp != 0)
       ans++; 
     }
     set = temp;
     for(i=0;i<m;i++)
     {
      for(j=i+1;j<m;j++)
      {
       for(k=0;k<n;k++)
       {
       	if(set[k] == 0 && bvec[j][k] == 1 && bvec[i][k] == 1)	
    	{
    	 ans++;
    	 set[k] = 1;
        }
       }
      }
     }      				   
     for(i=0;i<m;i++)
     {
      flag = 0;
      for(j=0;j<n;j++)
      {  	  
       if(bvec[i][j] == 1 && temp[j] == 0 && set[j] == 0)
       {
        flag = 1;
        set[j] = 1;
       }
      }
      if(flag)
       ans++;
      if(set.count() == n)
       break; 
     }
     for(j=0;j<m;j++)
     {
      bvec[j].reset();
     }  
      
      printf(""%d\n"",ans);
      T--;
     } 
     return 0;
    }
     
    

",C++
7079162,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.StringTokenizer;
    
    public class Main{
     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) {
                t--;
                StringTokenizer st = new StringTokenizer(br.readLine());
                int n = Integer.parseInt(st.nextToken());
                int m = Integer.parseInt(st.nextToken());
                int max[] = new int[n];
                int maxm = 0, minm = 0;
                StringTokenizer ss = new StringTokenizer(br.readLine());
                for (int i = 0; i < m; i++) {
                    int x = Integer.parseInt(ss.nextToken());
                    if (i == 0) {
                        maxm = x;
                        minm = x;
                    } else {
                        if (x > maxm) {
                            maxm = x;
                        }
                        if (minm > x) {
                            minm = x;
                        }
                    }
    
                }
                int diff = (maxm - minm) / 2;
                if (diff == 0) {
                    for (int i = 0; i < n; i++) {
                        if (i < maxm) {
                            System.out.print(Math.abs(i - maxm)+"" "");
                        } else {
                            System.out.print(Math.abs(i - minm)+"" "");
                        }
                    }
                    
                    
                    
                } else {
                    for (int i = 0; i < n; i++) {
                        if (i < diff) {
                            System.out.print(Math.abs(i - maxm)+"" "");
                        } else {
                            System.out.print(Math.abs(i- minm)+"" "");
                        }
                    }
                }
    System.out.println();
            }
        }
    }

",JAVA
6773886,"
    #include<bits/stdc++.h>
    #define M 1000000007
    #define pb push_back
    #define mp make_pair
    #define ff first
    #define ss second
    using namespace std;
    typedef long long ll;
    typedef pair<int,int> pii;
    int main()
    {
    	ios_base::sync_with_stdio(false);
    	cin.tie(NULL);
    	int t,n,m,mi,ma,a,i;
    	cin>>t;
    	while(t--)
    	{
    		cin>>n>>m;
    		mi=INT_MAX;
    		ma=INT_MIN;
    		while(m--)
    		{
    			cin>>a;
    			mi=min(mi,a);
    			ma=max(ma,a);
    		}
    		for(i=0;i<n;i++)
    		{
    			if(i<=mi)
    				cout<<ma-i<<' ';
    			else if(i>mi && i<=ma)
    				cout<<max(i-mi,ma-i)<<' ';
    			else if(i>=ma)
    				cout<<i-mi<<' ';
    		}
    		cout<<'\n';
    	}
    	return 0;
    }
    

",C++
6382114,"
    #include <stdio.h>
    #define N 100100
    
    int a[N];
    
    int abs(int x) {
        return x >= 0 ? x : -x;
    }
    
    int main() {
        int t, n, i, k, l, r, x, y, m;
        
        scanf(""%d"", &t);
        while(t--) {
            scanf(""%d%d"", &n, &m);
            for(i=0; i<n; i++)
                a[i] = 0;
            for(i=0; i<m; i++) {
                scanf(""%d"", &k);
                a[k] = 1;
            }
            l = 0;
            while(!a[l]) l++;
            r = n-1;
            while(!a[r]) r--;
            //printf(""%d %d\n"", l, r);
            for(i=0; i<n; i++) {
                x = abs(i-l);
                y = abs(r-i);
                if(x > y)
                    printf(""%d "", x);
                else
                    printf(""%d "", y);
            }
            printf(""\n"");
        }
        
    	return 0;
    }
    

",C
6329903,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int t,n,m,l,r,arr[100000],i,j,arr1[100000],arr2[100000];
    
    	cin >> t;
    	for(i=0;i<t;i++)
    	{
    		cin >> n >> m;
    		r=0;
    		l=0;
    
    		for(j=0;j<n;j++)
    		{
    			arr1[j]=0;
    			arr2[j]=0;
    		}
    
    
    		for(j=0;j<m;j++)
    		{
    			cin >> arr[j];
    
    			if(n-1-arr[j]>r)
    			{
    				r=n-1-arr[j];
    			}
    			if(arr[j]>l)
    			{
    				l=arr[j];
    			}
    		}
    
    		if(n==1)
    		{
    			cout << ""0"" << endl;
    			continue;
    		}
    		//cout << l << "" "" << r ;
    		for(j=0;j<n;j++)
    		{
    			arr1[j]=l;
    			l--;
    			if(l==0)
    				break;
    		}
    		for(j=n-1;j>=0;j--)
    		{
    
    			arr2[j]=r;
    			r--;
    			if(r==0)
    				break;
    		}
    
    		for(j=0;j<n;j++)
    		{
    			if(arr1[j]>=arr2[j])
    				cout << arr1[j] << "" "";
    
    			else
    				cout << arr2[j] << "" "";
    		}
    
    		cout << endl;
    	}
    	return 0;
    }
    

",C++
11291642,"
    import java.util.Scanner;
    
    class Alpahbet{
           public static void main(String args[]){
           
           Scanner scan = new Scanner(System.in);
           
           String S = scan.next();
           int len = S.length();
           int count = scan.nextInt();
           while(count!=0){
           String word = scan.next();
           for(int i=0;i<word.length();i++)
           {
            int c=0;
            char s = word.charAt(i);
            if(S.contains(s)){
               count++;
               }
            if(count>=len)
            System.out.println(""Yes"");
            else
            System.out.println(""No"");
            }
            count--;
          }
         }
        }    
               
               

",JAVA
11280261,"
    import java.util.Scanner;
    class Alpha
    {
    public static void main(String[] arr)
    {
    
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=sc.nextInt();
    for(int i=1;i<=n;i++)
    {
    int l=0;
    String w=sc.next();
    for(int j=0;j<w.length();j++)
    {
    for(int k=0;k<s.length();k++)
    {
    if(w.charAt(j)==s.charAt(k))
    l++;
    }
    }
    if(l==w.length())
    System.out.println(""Yes"");
    else
    System.out.println(""No"");
    }
    }
    }
    

",JAVA
5651483,"
    #include<stdio.h>
    int main(){
        int t,k,b;
        unsigned int temp,i,in;
        char s[65537],ch;
        scanf(""%d"",&t);
        while(t--){
            scanf(""%d %s"",&k,s);
            for(i=0;s[i];i++){
                in=0;
                for(b=0;b<k;b++)
                    if(i&1<<b) in=in|1<<(k-b-1);
                if(in>i){
                    ch=s[in];
                    s[in]=s[i];
                    s[i]=ch;
                }
            }
            printf(""%s\n"",s);
        }
        return 0;
    }
    

",C
1058549,"
    import java.io.IOException;
    import java.util.Scanner;
    
    
    class ArrangingTheAppetite2 {
    
    	
    	public static void main(String[] args)throws IOException {
    
    		int t;
    		Scanner obj=new Scanner(System.in);
    		
    		t=obj.nextInt();
    		while(t>0){
    			int k=obj.nextInt();
    			String str=obj.next();
    			if(k==1){
    				System.out.println(str);
    			}
    			else
    				if(k==2){
    					System.out.print(str.charAt(0));
    					System.out.print(str.charAt(2));
    					System.out.print(str.charAt(1));
    					System.out.print(str.charAt(3));
    					System.out.println();
    				}
    				
    				else
    					if(k==3){
    						System.out.print(str.charAt(0));
    						System.out.print(str.charAt(4));
    						System.out.print(str.charAt(2));
    						System.out.print(str.charAt(6));
    						System.out.print(str.charAt(1));
    						System.out.print(str.charAt(5));
    						System.out.print(str.charAt(3));
    						System.out.print(str.charAt(7));
    					    System.out.println();
    					}
    			
    					else
    					{
    						int pow=(int) Math.pow(2,k);
    						int pos[]=new int[17];
    						pos[1]=1;pos[2]=9;pos[3]=5;pos[4]=13;pos[5]=3;pos[6]=11;pos[7]=7;pos[8]=15;
    				pos[15]=8;  pos[9]=2;pos[10]=10;pos[11]=6;pos[12]=14;pos[13]=4;pos[14]=12; pos[16]=16;
    				int rem=k%4+1;
    				int posi[]=new int[pow+1];
    				int j=0;
    				int k1=0,k2=0;
    				for(int i=1;i<=16;i++){
    					for( j=1;j<=rem;j++){
    						posi[k2+1]=(j-1)*16+pos[k1+1];
    				
    					k2++;
    					
    					}
    					k1++;
    				}
    				
    				
    				
    						
    					for(int i=1;i<=str.length();i++){
    			
    						System.out.print(str.charAt(posi[i]-1));
    					
    					
    					}
    					
    					}
    		t--;}
    
    	}
    
    }
    
    

",JAVA
333975,"
    #include<iostream>
    #include<math.h>
    using namespace std;
    
    int inverted(int x,int n)
    {int a[n],p,res=0,pro=1;
    
    for(int i=0;i<n;i++)
    {
    a[n-i-1]=(x%2);
    x/=2;
    }
    
    for(int i=0;i<n/2;i++)
    {
    p=a[i];
    a[i]=a[n-i-1];
    a[n-i-1]=p;
    }
    
    for(int i=0;i<n;i++)
    {
    res+=pro*a[n-i-1];
    pro*=2;
    }
    return res;
    }
    
    int main()
    {
    int t;
    cin>>t;
    char res[t][70000];
    
    for(int o=0;o<t;o++)
    {
    int n,rn;
    cin>>n;
    rn=pow(2,n);
    char temp[70000],k;
    
    for(int i=0;i<rn;i++)
    cin>>temp[i];
    
    for(int i=0;i<rn;i++)
    {
    k=inverted(i,n);
    res[o][i]=temp[k];
    }
    }
    
    for(int o=0;o<t;o++)
    cout<<res[o]<<""\n"";
    
    return 0;
    }

",C++
8166453,"
    #include <cmath>
    #include <cstdio>
    #include <vector>
    #include <iostream>
    #include <algorithm>
    #include <string>
    using namespace std;
    
    #define MAX 1e9
    #define max(a, b) ((a>b)?a:b)
    #define min(a, b) ((a<b)?a:b)
    
    int main (){
    	int T, M, t;
    	double p, mny, chef, opp, nxt;
    	scanf (""%d"", &T);
    	while (T--){
    		scanf (""%d %lf"", &M, &p);
    		t = M-1;
    		mny = MAX*pow (p, t);
    		if (t%2){
    			opp = mny;
    			chef = 0;
    		}
    		else{
    			opp = 0;
    			chef = mny;
    		}
    		nxt = mny/p;
    		t--;
    		while (t>=0){
    			if (t%2){
    				if (nxt-chef>opp)
    					opp = nxt-chef;
    			}
    			else{
    				if (nxt-opp>chef)
    					chef = nxt-opp;
    			}
    			mny = nxt;
    			nxt = mny/p;
    			t--;
    		}
    		printf(""%lf %lf\n"", chef, opp);
    	}
    	return 0;
    }
    

",C++
6308439,"
    #include <bits/stdc++.h>
    using namespace std;
    
    #ifndef ONLINE_JUDGE
    	#define gc getchar
    #else
    	#define gc getchar_unlocked
    #endif
    
    #ifndef ONLINE_JUDGE
    	#define pc putchar
    #else
    	#define pc putchar_unlocked
    #endif
    
    #define ll long long int
    #define rep(i, a, b) for(i = a; i<b; i++)
    ll arr[30];
    
    inline void inp(ll &x) {
    
        register int c = gc();
        x = 0;
        for(;(c<48 || c>57);c = gc());
        for(;c>47 && c<58;c = gc()) {x = (x<<1) + (x<<3) + c - 48;}
    }
    
    inline void write(ll a) {
    
    	register char c;
    	char snum[20];
    	ll i=0;
    	
    	do
    	{
    		snum[i++]=a%10+48;
    		a=a/10;
    	}while(a!=0);
    	
    	i=i-1;
    	
    	while(i>=0)
    		pc(snum[i--]);
    	//pc('\n');
    }
    
    inline ll abs(ll a, ll b) {
    	
    	return (a-b)>0?(a-b):(b-a);
    }
    
    int main() {
    
    	ios_base::sync_with_stdio(false);
    	
    	ll t, n, k, i, ways, sum;
    	
    	vector<ll> arr;
    	vector<ll> :: iterator it,it1, beg, end;
    	
    	inp(t);
    	
    	while(t--) {
    		
    		inp(n);
    		inp(k);
    		
    		arr.resize(n);
    		beg = arr.begin();
    		end = arr.end();
    		
    		rep(it,beg,end)
    			inp(*it);
    		
    		if(n==2) {
    		
    			ways = 1;
    			sum = abs(k,arr[0] + arr[1]);
    		}
    		else {
    		
    			sort(arr.begin(),arr.end());
    			
    			sum = abs(k,arr[0] + arr[1]);
    			
    			rep(it,beg,end) {
    				
    				rep(it1,it+1,end) {
    				
    					if(sum == abs(k, *it + *it1))
    						ways++;
    					else if(sum > abs(k, *it + *it1)) {
    					
    						sum = abs(k, *it + *it1);
    						ways = 1;
    					} 
    				}
    			}
    		}
    		
    		write(sum);
    		pc(' ');
    		write(ways);
    		pc('\n');
    	}
    	
    	return 0;
    }

",C++
4117546,"
    #include<stdio.h>
    int main()
    {
        int t;
        scanf(""%d"",&t);
        while(t--)
        {
            int n,k,i,j,count=1,min=99999999999;
            scanf(""%d%d"",&n,&k);
            int arr[n];
            for(i=0;i<n;i++)
            {
                scanf(""%d"",&arr[i]);
            }
            for(i=0;i<n;i++)
            {
                for(j=i+1;j<n;j++)
                {
                    int temp;
                    temp=arr[i]+arr[j]-k;
                    if(temp<0)
                        temp=-1*temp;
                    if(temp<min)
                    {
                        count=1;
                        min=temp;
                    }
                    else if(temp==min)
                    {
                        count++;
                    }
                }
            }
            printf(""%d %d\n"",min,count);
        }
        return 0;
    }
    

",C
8665381,"
    #include<stdio.h>
    int main()
    {
        int t,i,q,j,n;
        scanf(""%d"",&q);
        while(q--)
        {
            scanf(""%d"",&n);
            int a[n],sum=0;
            for(i=0;i<n;i++)
                scanf(""%d"",&a[i]);
                if(n<=2)
                {
                    for(i=0;i<n;i++)
                        sum=sum+a[i];
                    printf(""%d\n"",sum);
                    sum=0;
                }
                else
            {
            for(i=0;i<n;i++)
            {
              for(j=i;j<n;j++)
             {
                if(a[i]>a[j])
                {
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }
             }
            }
            if(n%4==3 || n%4==0 || n%4==2)
            {
                for(i=n-1;i>=0;i=i-4)
            {
                sum=sum+a[i]+a[i-1];
            }
            }
            if(n%4==1)
            {
                i=n-1;
                while(i!=0)
                {
                    sum=sum+a[i]+a[i-1];
                    i=i-4;
                }
                sum=sum+a[0];
            }
            printf(""%d\n"",sum);
            }
        }
        return 0;
    }
    

",C
5940784,"
    # your code goes here
    t=int(input())
    #a=[]
    while t:
    	n=int(input())
    	b=input()
    	a=list(map(int,b.split()))
    
    	#del a[:]
    	
    	#a =map(int,b.split())
    	cost=0
    	a.sort()
    	a.reverse()
    	
    	"""""" i in range(0,n):
    		print(a[i])""""""
    	
    	for i in range(0,n,4):
    		for j in range(0,4,1):
    			if j<2 and (j+i)<n:
    				cost+=a[i+j]
    				#print(cost)
    				#cost+=c
    				
    			#j+=1
    		#i+=4
    		
    	#del a[:]	
    	print(cost)
    	t=t-1
    		
    		

",PYTH
5936102,"
    #include<stdio.h>
    int a[1009],n;
    
    void cal(){
    	int i,sum=0;
    	i=1000;
    	while(i){
    		while((a[i]<=0) && (i>0))i--;
    		sum+=i;
    		a[i]--;
    		while((a[i]<=0) && (i>0))i--;
    		sum+=i;
    		a[i]--;
    		
    		while(a[i]<=0 && i>0)i--;
    		a[i]--;
    		while(a[i]<=0 && i>0)i--;
    		a[i]--;
    		
    	}	
    	printf(""%d\n"",sum);
    }
    
    int main(){
    	int t,k,i;
    	scanf(""%d"",&t);
    	while(t--){
    		scanf(""%d"",&n);
    		for(i=0;i<=1000;i++){
    			a[i]=0;
    		}
    		for(i=1;i<=n;i++){
    			scanf(""%d"",&k);
    			a[k]++;
    		}
    		cal();
    	}
    	return 0;
    }
    

",C
7627172,"
    #include <cstdio>
     
    typedef long long LL;
     
    int N,M,Q;
    int Sx,Sy;
    int p[6][2];
    int NM; // the product N * M
     
    void read() {
    	scanf(""%d %d %d %d %d"", &N, &M, &Q, &Sx, &Sy);
    	--Sx; --Sy;
    	for (int k = 0; k < 6; ++k)	{
    		scanf(""%d %d"", &p[k][0], &p[k][1]);
    	}
    	NM = N * M;
    }
     
    //U=0, D=1, L=2, R=3
    int dx[4] = {-1, 1, 0, 0}; // dx[h] is the change of the row index by h-th direction
    int dy[4] = {0, 0, -1, 1}; // dy[h] is the change of the column index by h-th direction
     
    // dir[0] is P1, dir[1] is P2 from the problem statement
    int dir[6][2] = {
    	{0, 1},
    	{2, 3},
    	{0, 3},
    	{3, 1},
    	{1, 2},
    	{2, 0}
    };
     
    const int maxNM = 34;
    // move[M * i + j][k] the bit-mask of cells where images appear
    // from the cell (i, j) if F(i, j) mod 6 = k
    LL move[maxNM][6];
    const int H = maxNM / 2;
    const int HALF = (1 << H) - 1;
    int bitcnt[1 << H]; // bitcnt[x] is the number of ones in binary in x
    LL cross[maxNM]; // cross[M * i + j] is the bit-mask of cells in the cross of the cell (i,j)
    int r6[maxNM]; // residues modulo 6, it speeds up the program a bit
     
    void precalc()
    {
    	// residues modulo 6 precalc
    	for (int i = 0; i < M + N; ++i) {
    		r6[i] = i % 6;
    	}
     
    	// precalc of 'move[M * i + j][k]'
    	for (int i = 0; i < N; ++i) {
    		for (int j = 0; j < M; ++j) {
    			for (int k = 0; k < 6; ++k) {
    				// the variable where bit-mask of cells with images will be stored
    				LL grid = 1LL << (M * i + j); // initialize by the cell (i, j)
    				// h=0 <-> (D1,P1); h=1 <-> (D2,P2)
    				for (int h = 0; h < 2; ++h) {
    					int x = i, y = j;
    					while (true) {
    						x += dx[dir[k][h]] * p[k][h];
    						y += dy[dir[k][h]] * p[k][h];
    						if (!(0 <= x && x < N && 0 <= y && y < M)) {
    							break;
    						}
    						grid |= 1LL << (M * x + y);
    					}
    				}
    				move[M * i + j][k] = grid;
    			}
    		}
    	}
     
    	// bitcnt precalc
    	bitcnt[0] = 0;
    	for (int i = 1; i < (1 << H); ++i) {
    		bitcnt[i] = bitcnt[i / 2] + i % 2;
    	}
     
    	// cross precalc
    	for (int i = 0; i < N; ++i) {
    		for (int j = 0; j < M; ++j) {
    			int u = M * i + j;
    			cross[u] = 0;
     
    			// add all cells in the same column
    			for (int k = 0; k < N; ++k) {
    				cross[u] |= 1LL << (M * k + j);
    			}
     
    			// add all cells in the same row
    			for (int k = 0; k < M; ++k) {
    				cross[u] |= 1LL << (M * i + k);
    			}
    		}
    	}
    }
     
    // return the number of ones in numbers up to 2^34
    // as a sum of bitcnt for lower and higher groups of bits
    int BITCNT(LL grid) {
    	return bitcnt[grid & HALF] + bitcnt[grid >> H & HALF];
    }
     
    const int PER = 350000; // some upper bound on the index of the first repetition
    const int SIZE = 700001; // the next prime after 2 * PER
    LL grid; // the grid of the current move
    int len; // the index of the current move
    LL grids[PER]; // grids[i] is the grid at the i-th move
    int ind[SIZE]; // contains indexes of the grids in some tricky way
    int sum[PER]; // sum[n] = CNT(G0) + ... + CNT(Gn) from the editorial
     
     
    void init() {
    	// -1 denotes the empty slot 
    	for (int i = 0; i < SIZE; ++i) {
    		ind[i] = -1;
    	}
    	// initial grid composed of just one cell
    	grid = 1LL << (M * Sx + Sy);
     
    	ind[grid % SIZE] = 0;
    	grids[0] = grid;
    	sum[0] = 1;
    	len = 1;
    }
     
    int main() {
    /*#ifndef ONLINE_JUDGE
    	freopen(""in.txt"",""r"",stdin);
    	freopen(""1.in"",""r"",stdin);
    	freopen(""1_my.out"",""w"",stdout);
    #endif*/
    	read();
    	precalc();
    	init();
     
    	int q = 0, p = 0;
    	while (p == 0) {
     
    		LL new_grid=0;
    		for (int u = 0; u < NM; ++u) {
    			// check whether 'grid' have cell 'u'
    			if (grid & 1LL << u) {
    				// bit-mask magic:
    				// 'grid & cross[u]' is the bit-mask of cells with images in the grid
    				// in the cross of the cell 'u'
    				// 'BITNCT()' counts the number of these images
    				// 'r6[]' takes the residue modulo 6
    				// 'move[u][]' is the bit-mask of the images that appear from the cell 'u'
    				// ^= performs one on one fight
    				new_grid ^= move[u][BITCNT(grid & cross[u])%6];
    			}
    		}
    		grid = new_grid;
     
    		// update 'grids' and 'sum' by the new grid
    		grids[len] = grid;
    		sum[len] = sum[len - 1] + BITCNT(grid);
     
    		// 'pos' is the position in 'ind' where we try to put 'grid'
    		int pos = grid % SIZE;
    		for(;;)
    		{
    			// if this position is free we assign 'ind[pos] = len'
    			// which means that the grid of the 'len'-th move
    			// is stored at 'pos'-th slot of 'ind'
    			if (ind[pos] < 0) {
    				ind[pos] = len;
    				++len;
    				break;
    			} else {
    				// if this position is already occupied by exactly this grid
    				// then we met a repetition in the sequence of moves;
    				// we calculate p and q and stop performing the moves
    				if (grids[ind[pos]] == grid) {
    					q = ind[pos];
    					p = len;
    					break;
    				} else {
    					// otherwise it is a bad luck - we should seek for another position
    					// but due to randomness of moves and the fact that SIZE is prime
    					// this happens very rarely - no more then 'len' times for the first 'len' moves
    					// that is why this approach is very fast
    					++pos;
    					// we consider 'ind' as a cyclic array, so if we reach the end
    					// we jump to the start
    					if (pos == SIZE) {
    						pos = 0;
    					}
    				}
    			}
    		}
    	}
     
    	int w = p - q; // period
    	LL period_sum = sum[p] - sum[q];
    	for (int i = 0; i < Q; ++i) {
    		LL T;
    		scanf(""%lld"", &T);
     
    		// all this made exactly as in editorial
    		LL ans;
    		if (T <= p) {
    			ans=sum[T]; 
    		} else {
    			LL L = (T - q) / w;
    			int r = T - L * w;
    			ans = sum[r] + L * period_sum;
    		}
    		printf(""%lld\n"", ans);
    	}
    	return 0;
    }
     

",C++
2350741,"
    import java.io.*;
    import java.util.*;
    import java.math.*;
    public class Main
    {
        static BufferedReader s=new BufferedReader(new InputStreamReader(System.in));
        static PrintWriter p=new PrintWriter(new OutputStreamWriter(System.out));
        public static void main(String[] args) throws IOException
        {
            int a=f();
            while(a-->0)
            {
                int b=f();
                p.print(3);
                if(b>0)
                    p.print(""."");
                int c=46870;
                while(b-->0)
                {
                    p.print(c/33102);
                    c=(c%33102)*10;
                }
                p.println();
            }
            p.flush();
        }
        static int f() throws IOException
        {
            int b=s.read()-48;
            int a=0;
            while((b>=0)&(b<=9))
            {
                a=a*10+b;
                b=s.read()-48;
            }
            return a;
        }
    }

",JAVA
8845271,"
    /**************************************************
        _||||||_    ¯||||||||_    ¯|||    |||¯   _|
       _||    ||_    |||    ||     |||    |||   |||
       |||    |||    |||    ||     |||    |||   |||
       |||    |||    |||___||¯     |||____|||   |||
       ||||||||||    |||¯¯¯||_     |||¯¯¯¯|||   |||
       |||    |||    |||    ||     |||    |||   |||
       |||    |||    |||    ||     |||    |||   |||
      _|||    |||_  _||||||||¯    _|||    |||_  |¯
      
      
    ////////// ||||||||||||||||||||||||
    ***************************************************/
    #include <cstdio>
    #include <cstdlib>
    #include <cctype>
    #include <cmath>
    #include <cstring>
    #include <iostream>
    #include <iomanip>
    #include <vector>
    #include <list>
    #include <stack>
    #include <queue>
    #include <map>
    #include <set>
    #include <string>
    #include <utility>
    #include <sstream>
    #include <algorithm>
    #include <ctime>
    #include <cassert>
    #include <limits>
    using  namespace  std;
    
    #define PI acos(-1.0)
    #define mem(a,b) memset(a,b,sizeof(a))
    #define gcd(a,b) __gcd(a,b)
    #define pb push_back
    #define mp make_pair
    #define x first
    #define y second
    #define Sort(x) sort(x.begin(),x.end())
    #define FOR(i, b, e) for(int i = b; i <= e; i++)
    #define FORR(i, b, e) for(int i = b; i >= e; i--)
    #define FORI(i, s) for (__typeof ((s).end ()) i = (s).begin (); i != (s).end (); ++i)
    #define pr(x) cout<<x<<""\n""
    #define pr2(x,y) cout<<x<<"" ""<<y<<""\n""
    #define pr3(x,y,z) cout<<x<<"" ""<<y<<"" ""<<z<<""\n"";
    #define ppr(a) cout<<a.x<<"" ""<<a.y<<""\n""
    #define READ(f) freopen(f, ""r"", stdin)
    #define WRITE(f) freopen(f, ""w"", stdout)
    
    typedef  long long ll;
    typedef  pair <int, int> pii;
    typedef  pair <double , double> pdd;
    typedef  pair <ll , ll > pll;
    typedef  vector <int> vi;
    typedef  vector <pii> vpii;
    typedef  vector <ll > vl;
    
    //int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction
    //int dx[]={1,1,0,-1,-1,-1,0,1};
    //int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction
    //int dx[]={2,1,-1,-2,-2,-1,1,2};
    //int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction
    
    #define MAX 100007
    #define EPS 1e-9
    int g[105][105];
    int v[105],n;
    int DFS(int s,int par)
    {
        int ans=0;
        v[s]=1;
        FOR(i,1,n)
        {
            if(g[s][i]!=-1&&!v[i]&&i!=par){
                ans=g[s][i]+DFS(i,s);}
        }
        return ans;
    }
    int main()
    {
        //READ(""in.in"");
        //WRITE(""out.out"");
        int T,u,vv,c;
        scanf(""%d"",&T);
        FOR(cs,1,T)
        {
            scanf(""%d"",&n);
            FOR(i,1,n)v[i]=0;
            FOR(i,1,n)
            FOR(j,1,n)g[i][j]=-1;
    
            FOR(i,1,n)
            {
                scanf(""%d %d%d"",&u,&vv,&c);
                g[u][vv]=0;
                g[vv][u]=c;
            }
            int ans=10000000;
            FOR(i,1,n)
            {
                if(g[1][i]!=-1)
                {
                            FOR(i,1,n)v[i]=0;
                   // pr3(1,""->"",i);
                    ans=min(ans,g[1][i]+DFS(i,1));
                }
            }
            printf(""Case %d: %d\n"",cs,ans);
        }
        return 0;
    }
    

",C++
8660783,"
    #include<bits/stdc++.h>
    
    using namespace std;
    long int a[1000003];
    int b[1000003]={0};
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int n,i,j,c=0;
            scanf(""%d"",&n);
            for(i=0;i<n;i++)
                scanf(""%ld"",&a[i]);
            for(i=0;i<n-1;i++)
            {
                if(a[i]>a[i+1] && b[i]==1)
                {
                    c=1;
                    break;
                }
                else if(a[i]>a[i+1])
                {
                    swap(a[i],a[i+1]);
                    b[i+1]=1;
                }
            }
            if(c==0)
            {
               for(i=0;i<n-1;i++)
              {
                if(a[i]>a[i+1])
                {
                    c=1;
                    break;
                }
              }
            }
    
          if(c==0)
            printf(""YES\n"");
          else
            printf(""NO\n"");
    
        }
    
           return 0;
    }
    
    

",C++
8646979,"
    #include<bits/stdc++.h>
    using namespace std;
    int a[1000009],b[1000009];
    int main()
    {
    	int i,n,test;
    	scanf(""%d"",&test);
    	while(test--){
    	
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&a[i]);
    		b[i]=a[i];
    	}
    	sort(a,a+n);
    	int count=0;
    	for(i=0;i<n;i++)
    	{
    		if(b[i]==a[i]||(i<=n-2&&(b[i]==a[i]+1))||(i>=1&&(b[i]==a[i-1])))
    		{
    			count++;
    		}
    	}
    	//cout<<count<<endl;
    	if(count==n)
    	{
    		printf(""YES\n"");
    	}
    	else
    	{
    		printf(""NO\n"");
    	}
    }
    	return 0;
    }

",C++
8599241,"
    #include <iostream>
    #include<cstdio>
    #include<cmath>
    using namespace std;
    
    int main() {
    	// your code goes here
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    	long long int a[1000001],n,temp,i,flag=0;
    	scanf(""%lld"",&n);
    	for(i=0;i<n;i++)
    	{
    	scanf(""%d"",&temp);
    	if(flag==0 && abs(temp-(i+1))>1)
    	flag=1;
    
    	}
    	if(flag)
    	printf(""NO\n"");
    	else
    	printf(""YES\n"");
    
    	}
    	return 0;
    }

",C++
8583542,"
    #include <iostream>
    #include<algorithm>
    #include<math.h>
    using namespace std;
     int gh[1000005];
    int main ()
    {
        int u;
        scanf(""%d"",&u);
        while (u--)
        {
           int  k = 0;
         int siz,j,i;
        int p;
            
            scanf(""%d%d"",&siz,&gh[0]);
            for (j=1 ; j<siz ; j++)
            {
                scanf(""%d"",&gh[j]);
                
            }
            for(j=1;j<siz;j++)
            {
             if (gh[j-1] > gh[j])
                {
                    p = gh[j-1];
                    gh[j-1] = gh[j];
                    gh[j] = p;
                    j++;
                }
            }
            for (i=0 ; i<siz-1 ; i++)
            {
                if (gh[i] > gh[i+1])
                {
                    k = 1;
                    break;
                }
            }
            if(k==1)
            printf(""NO\n"");
            else
            printf(""YES\n"");
            
     
        }
        return 0;
    } 

",C++
3943636,"
    long long int a[500010],b[100010];
    #include<stdio.h>
    int main()
    {
        long long int n,k,i,j,m,max1,max2,max11,max21,max,max3;
        scanf(""%lld %lld"",&n,&k);
        for(i=1;i<=n;i++)
        {
            scanf(""%lld %lld"",&a[i],&b[i]);
        }
        a[0]=0;
        b[0]=0;
        for(i=n-k;i>=0;i--)
        {
            for(j=i+1;j<=i+k;j++)
            {
                if(a[j]>=a[i])
                max11=a[j];
                else
                max11=a[i];
                if(b[j]>=b[i])
                max21=b[j];
                else
                max21=b[i];
                max=max11*max21;
                if(max<max3)
                {
                    max3=max;
                    max1=max11;
                    max2=max21;
                }
            }
            a[i]=max1;
            b[i]=max2;
        }
        printf(""%lld"",(a[0]*b[0]));
        return 0;
    }
    

",C
11993555,"
    import java.io.*;
    import java.util.*;
    class BGQRS
    {
        static int TWO[];
        static int FIVE[];
        public static void main(String args[])throws IOException
        {
            //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            BufferedReader br = new BufferedReader(new FileReader(""testcase.txt""));
            
            int t = Integer.parseInt(br.readLine());
            StringTokenizer st;
            while(t-- > 0)
            {
                st = new StringTokenizer(br.readLine());
                int n = Integer.parseInt(st.nextToken());
                int m = Integer.parseInt(st.nextToken());
                int a[] = new int[n];
                int two[] = new int[n];
                int five[] = new int[n];
                st = new StringTokenizer(br.readLine());
                int ans = 0;
                compute(n);
                for(int i = 0 ; i < n ; i++){
                    a[i] = Integer.parseInt(st.nextToken());
                    two[i] = findTwo(a[i]);
                    five[i] = findFive(a[i]);
                }
                
                for(int i = 0 ; i < m ; i++)
                {
                    st = new StringTokenizer(br.readLine());
                    
                    int c = Integer.parseInt(st.nextToken());
                    if(c==1)
                    {
                        int L = Integer.parseInt(st.nextToken());
                        int R = Integer.parseInt(st.nextToken());
                        int X = Integer.parseInt(st.nextToken());
                        int tw = findTwo(X);
                        int fiv = findFive(X);
                        
                        for(int k = L-1 ; k < R ; k++)
                        {
                            two[k] += tw;
                            five[k] += fiv;
                        }
                        
                        
                    }
                    else if(c==2)
                    {
                        int L = Integer.parseInt(st.nextToken());
                        int R = Integer.parseInt(st.nextToken());
                        int Y = Integer.parseInt(st.nextToken());
                        int tw = findTwo(Y);
                        int fiv = findFive(Y);
                        int count = 1;
                        
                        for(int k = L-1 ; k < R ; k++,count++)
                        {
                            two[k] = tw+TWO[count];
                            five[k] = fiv+FIVE[count];
                        }
                    }
                    else
                    {
                        int L = Integer.parseInt(st.nextToken());
                        int R = Integer.parseInt(st.nextToken());
                        int numTwo = 0;
                        int numFive = 0;
                        
                        for(int k = L-1 ; k < R ; k++)
                        {
                            numTwo += two[k];
                            numFive += five[k];
                        }
                        ans += Math.min(numTwo,numFive);                    
                    }
                }
                System.out.println(ans);
            }
        }
        public static int findTwo(int a)
        {
            int c = 0;
            while(a%2 == 0)
            {
                c++;
                a /= 2;
            }
            return c;
        }
        
        
        public static int findFive(int a)
        {
            int c = 0;
            while(a%5 == 0)
            {
                c++;
                a /= 5;
            }
            return c;
        }
        public static void compute(int n)
        {
            TWO = new int[n+1];
            FIVE = new int[n+1];
            for(int i = 1 ; i <= n ; i++)
            {
                TWO[i] = findTwo(i);
                FIVE[i] = findFive(i);            
            }
        }
    }

",JAVA
8967440,"
    #include <algorithm>
    #include <iostream>
    #include <utility>
    #include <cstdlib>
    #include <cstring>
    #include <fstream>
    #include <cassert>
    #include <iomanip>                          
    #include <vector>
    #include <string>
    #include <cstdio>
    #include <cmath>
    #include <queue>
    #include <ctime>
    #include <stack>
    #include <set>
    #include <map>
     
    using namespace std;
     
    #define name """"
    #define ll long long
    #define ull unsigned ll
    #define inf 2000000000
    #define INF 2000000000000000000ll
    #define F first
    #define S second
    #define mp make_pair
    #define pb push_back
     
    const int N = 2015;
     
    int w, h, d, n;
    int base = 1001;
    int sum[N][N];
    
    int get(int x, int y, int x2, int y2){
    	int res = sum[x2][y2];
    	if(x)
    		res -= sum[x - 1][y2];
    	if(y)
    		res -= sum[x2][y - 1];
    	if(x && y)
    		res += sum[x - 1][y - 1];
    	return res;
    }
    
    int main (){	
        #ifndef ONLINE_JUDGE
        freopen (""in"", ""r"", stdin);
        freopen (""out"", ""w"", stdout);
        #endif
        scanf(""%d%d%d%d"", &w, &h, &d, &n);
        ++ w;
        ++ h;
        for(int i = 1;i <= n;++ i){
        	int x, y, c;
        	scanf(""%d%d%d"", &x, &y, &c);
        	++ x;
        	++ y;
        	int x2 = x + y;
        	int y2 = x - y + h;
    		sum[x2][y2] = c;
        }
        for(int i = 0;i <= 2 * base;++ i){
        	for(int j = 0;j <= 2 * base;++ j){
        		if(i)
        			sum[i][j] += sum[i - 1][j];
        		if(j)
        			sum[i][j] += sum[i][j - 1];
        		if(i && j)
        			sum[i][j] -= sum[i - 1][j - 1];
        	}
        }
        int mn = inf;
        for(int i = d;i <= w - d - 1;++ i){
        	for(int j = d;j <= h - d - 1;++ j){
        		int i2 = i + j + d + 2;
        		int j2 = i - j + h + d;
        		mn = min(mn, get(i2 - 2 * d, j2 - 2 * d, i2, j2));
        	} 
        }
        printf(""%d\n"", mn);
    	return 0;
    } 

",C++
11020845,"
    #pragma warning(disable:4786)
    #pragma warning(disable:4996)
    #include<list>
    #include<iostream>
    #include<cstdio>
    #include<algorithm>
    #include<vector>
    #include<set>
    #include<map>
    #include<functional>
    #include<string>
    #include<cstring>
    #include<cstdlib>
    #include<queue>
    #include<utility>
    #include<fstream>
    #include<sstream>
    #include<cmath>
    #include<stack>
    #include<assert.h>
    using namespace std;
     
    #define MEM(a, b) memset(a, (b), sizeof(a))
    #define CLR(a) memset(a, 0, sizeof(a))
    #define MAX(a, b) ((a) > (b) ? (a) : (b))
    #define MIN(a, b) ((a) < (b) ? (a) : (b))
    #define ABS(X) ( (X) > 0 ? (X) : ( -(X) ) )
    #define S(X) ( (X) * (X) )
    #define SZ(V) (int )V.size()
    #define FORN(i, n) for(i = 0; i < n; i++)
    #define FORAB(i, a, b) for(i = a; i <= b; i++)
    #define ALL(V) V.begin(), V.end()
    #define IN(A, B, C)  ((B) <= (A) && (A) <= (C))
     
    typedef pair<int,int> PII;
    typedef pair<double, double> PDD;
    typedef vector<int> VI;
    typedef vector<PII > VP;
     
    #define AIN(A, B, C) assert(IN(A, B, C))
     
    //typedef int LL;
    typedef long long int LL;
    //typedef __int64 LL;
     
    LL MOD = 1000000009;
    LL fact[1100000];
     
    LL bigmod(LL a, LL b)
    {
    	if(b == 0) return 1;
    	LL x = bigmod(a, b / 2);
    	x = (x * x) % MOD;
    	if(b & 1) x = (x * a) % MOD;
    	return x;
    }
     
    int main()
    {
    	LL ans;
    	int k, n, i;
     
    	scanf(""%d"", &k);
    	n = 1<<k;
     
    	fact[0] = 1;
    	for(i = 1; i <= n; i++)
    		fact[i] = (fact[i - 1] * i) % MOD;
     
    	for(i = 1; i <= n; i++)
    	{
    		if(i < n/2 - 1) 
    		{
    			printf(""0\n"");
    			continue;
    		}
     
    		ans = (fact[i - 1] * bigmod(fact[n/2 - 1], MOD - 2)) % MOD;
    		ans = (ans * bigmod(fact[i - n/2], MOD - 2)) % MOD;
    		ans = (ans * 2) % MOD;
    		ans = (ans * fact[n/2]) % MOD;
    		ans = (ans * fact[n/2]) % MOD;
     
    		printf(""%lld\n"", ans);
    	}
     
    	return 0;
    }
     

",C++
5209687,"
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.Reader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeSet;
     
    public class Main {
    	
    	/**
    	 * @param args the command line arguments
    	 */
    	public static void main(String[] args) throws IOException {
    		//BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(args[0])), 1024 * 1024 * 10);
    		BufferedReader r = new BufferedReader(new InputStreamReader(System.in), 1024 * 1024 * 10);
    		
    		int cityCount = readInt(r);
    		ArrayList<HashSet<Integer>> matrix = new ArrayList<>(cityCount);
    		for(int i = 0; i < cityCount; ++i) {
    			matrix.add(new HashSet<Integer>());
    		}
    		
    		for(int i = 1, n = cityCount - 1; i <= n; ++i) {
    			int a = readInt(r) - 1;
    			int b = readInt(r) - 1;
    			
    			matrix.get(a).add(b);
    			matrix.get(b).add(a);
    		}
    		
    		int dayCount = readInt(r);
    		
    		for(int i = 1; i <= dayCount; ++i) {
    			int guardCount = readInt(r);
    			TreeSet<GuardInfo> guardInfoSet = new TreeSet<>(new GuardInfoComparator());
    			
    			for(int k = 0; k < guardCount; ++k) {
    				guardInfoSet.add(new GuardInfo((char)(readInt(r) - 1), (char)readInt(r)));
    			}
    			
    			System.out.println(solve(matrix, cityCount, guardInfoSet));
    		}
    	}
    	
    	private static int[] protectedCities = null;
    	private static IntSet citiesToCheck;
    	private static IntSet pendingCitiesToCheck;
    	
    	public static int solve(ArrayList<HashSet<Integer>> matrix, int cityCount,
    			TreeSet<GuardInfo> guardInfoSet) {
    		if(protectedCities == null || protectedCities.length != cityCount) {
    			protectedCities = new int[cityCount];
    			citiesToCheck = new IntSet(cityCount);
    			pendingCitiesToCheck = new IntSet(cityCount);
    		}
    		
    		if(matrix.isEmpty()) {
    			return guardInfoSet.isEmpty() ? 0 : 1;
    		}
    		
    		if(guardInfoSet.isEmpty()) {
    			return 0;
    		}
    		
    		Arrays.fill(protectedCities, -1);
    		citiesToCheck.clear();
    		pendingCitiesToCheck.clear();
    		
    		int count = 0;
    		
    		char protectionDistance = guardInfoSet.first().getProtectionDistance();
    		
    		while (true) {
    			while(!guardInfoSet.isEmpty()) {
    				GuardInfo guardInfo = guardInfoSet.first();
    
    				if(guardInfo.getProtectionDistance() == protectionDistance) {
    					guardInfoSet.remove(guardInfo);
    
    					char city = guardInfo.getCity();
    					citiesToCheck.add(city);
    					protectedCities[city] = protectionDistance;
    					++count;
    				}
    				else {
    					break;
    				}
    			}
    
    			if(count >= cityCount) {
    				return cityCount;
    			}
    
    			int city = citiesToCheck.first();
    			if(city < 0) {
    				return count;
    			}
    			
    			pendingCitiesToCheck.clear();
    			while(city >= 0) {
    				if(protectedCities[city] == -1) {
    					protectedCities[city] = protectionDistance;
    					++count;
    
    					if(count >= cityCount) {
    						return cityCount;
    					}
    				}
    				else if(protectedCities[city] < protectionDistance) {
    					protectedCities[city] = protectionDistance;
    				}
    
    				if(protectionDistance == 0) {
    					city = citiesToCheck.next(city);
    					continue;
    				}
    
    				Set<Integer> neighbourCities = matrix.get(city);
    				if(neighbourCities == null) {
    					continue;
    				}
    
    				if(protectionDistance == 1) {
    					for(int cityToVerify : neighbourCities) {
    						if(protectedCities[cityToVerify] == -1) {
    							protectedCities[cityToVerify] = 0;
    							++count;
    						}
    					}
    
    					if(count >= cityCount) {
    						return cityCount;
    					}
    				}
    				else {
    					for(int cityToVerify : neighbourCities) {
    						if(protectedCities[cityToVerify] < protectionDistance - 1) {
    							pendingCitiesToCheck.add(cityToVerify);
    						}
    					}
    				}
    
    				city = citiesToCheck.next(city);
    			}
    
    			if(--protectionDistance < 1) {
    				return count;
    			}
    			
    			IntSet tempIntSet = citiesToCheck;
    			citiesToCheck = pendingCitiesToCheck;
    			pendingCitiesToCheck = tempIntSet;
    		}
    		
    		//return count;
    	}
     
    	static public int readInt(BufferedReader r) throws IOException {
    		int c = r.read();
    		while(!('0' <= c && c <= '9')) {
    			c = r.read();
    		}
    		
    		int i = c - '0';
    		c = r.read();
    		while('0' <= c && c <= '9') {
    			i = 10 * i + (c - '0');
    			
    			c = r.read();
    		}
    		
    		return i;
    	}
    }
    
    class GuardInfo {
    	private char city;
    	private char protectionDistance;
    	
    	public GuardInfo(char city, char protectionDistance) {
    		this.city = city;
    		this.protectionDistance = protectionDistance;
    	}
    	
    	public char getCity() {
    		return city;
    	}
    	
    	public char getProtectionDistance() {
    		return protectionDistance;
    	}
    	
    	@Override
    	public boolean equals(Object other) {
    		if(other == null || !(other instanceof GuardInfo)) {
    			return false;
    		}
    		
    		GuardInfo otherGuardInfo = (GuardInfo)other;
    		return city == otherGuardInfo.getCity() && protectionDistance == otherGuardInfo.getProtectionDistance();
    	}
    
    	@Override
    	public int hashCode() {
    		return this.city << 16 + this.protectionDistance;
    	}
    }
    
    class GuardInfoComparator implements Comparator<GuardInfo> {
    
    	@Override
    	public int compare(GuardInfo t1, GuardInfo t2) {
    		if(t1 == null && t2 == null) {
    			return 0;
    		}
    		
    		if(t1 == null) {
    			return -1;
    		}
    		
    		if(t2 == null) {
    			return 1;
    		}
    		
    		if(t1.getProtectionDistance() > t2.getProtectionDistance()) {
    			return -1;
    		}
    		
    		if(t1.getProtectionDistance() < t2.getProtectionDistance()) {
    			return 1;
    		}
    		
    		if(t1.getCity() < t2.getCity()) {
    			return -1;
    		}
    		
    		if(t1.getCity() > t2.getCity()) {
    			return 1;
    		}
    		
    		return 0;
    	}
    	
    }
    
    class IntSet {
    	private int capacity;
    	private byte[] elements;
    	private int[] nextLinks;
    	private int[] prevLinks;
    	private int startIndex, endIndex;
    	private int count;
    	
    	public IntSet(int initialCapacity) {
    		this.capacity = initialCapacity;
    		elements = new byte[capacity];
    		
    		nextLinks = new int[capacity];
    		Arrays.fill(nextLinks, -1);
    		
    		prevLinks = new int[capacity];
    		Arrays.fill(prevLinks, -1);
    		
    		startIndex = -1;
    		endIndex = -1;
    		count = 0;
    	}
    	
    	public boolean add(int element) {
    		if(elements[element] > 0) {
    			return false;
    		}
    		
    		elements[element] = 1;
    		
    		if(count > 0) {
    			if(element < startIndex) {
    				nextLinks[element] = startIndex;
    				prevLinks[startIndex] = element;
    			}
    			else if(element > endIndex) {
    				prevLinks[element] = endIndex;
    				nextLinks[endIndex] = element;
    			}
    			else if(count < (endIndex - startIndex) / 2) {
    				int i = startIndex;
    				while(i <= element && nextLinks[i] <= element && nextLinks[i] >= 0) {
    					i = nextLinks[i];
    				}
    				
    				int temp = nextLinks[i];
    				nextLinks[i] = element;
    				nextLinks[element] = temp;
    				prevLinks[element] = i;
    				prevLinks[temp] = element;
    			}
    			else {
    				if(element - startIndex < endIndex - element) {
    					int i;
    					for(i = element - 1; i >= startIndex && elements[i] == 0; --i) {
    					}
    					
    					int temp = nextLinks[i];
    					nextLinks[i] = element;
     
    					prevLinks[temp] = element;
     
    					prevLinks[element] = i;
    					nextLinks[element] = temp;
    				}
    				else {
    					int i;
    					for(i = element + 1; i <= endIndex && elements[i] == 0; ++i) {
    					}
     
    					int temp = prevLinks[i];
    					prevLinks[i] = element;
     
    					if(temp >= 0) {
    						nextLinks[temp] = element;
    					}
     
    					nextLinks[element] = i;
    					prevLinks[element] = temp;
    				}
    			}
    		}
    		
    		if(count == 0) {
    			startIndex = element;
    			endIndex = element;
    		}
    		
    		if(element < startIndex) {
    			startIndex = element;
    		}
    		
    		if(element > endIndex) {
    			endIndex = element;
    		}
    		
    		++count;
    		
    		return true;
    	}
    	
    	public boolean exists(int element) {
    		return elements[element] == 1;
    	}
    	
    	public void clear() {
    		if(count > 0) {
    			Arrays.fill(elements, startIndex, endIndex + 1, (byte)0);
    			Arrays.fill(nextLinks, startIndex, endIndex + 1, -1);
    			Arrays.fill(prevLinks, startIndex, endIndex + 1, -1);
    			count = 0;
    			startIndex = -1;
    			endIndex = -1;
    		}
    	}
    	
    	public int first() {
    		return startIndex;
    	}
    	
    	public int next(int element) {
    		if(element < 0) {
    			return -1;
    		}
    		
    		return nextLinks[element];
    	}
    	
    	public int getCapacity() {
    		return capacity;
    	}
    } 

",JAVA
5150682,"
    #include <stdio.h>
    #include <stdlib.h>
    #define MAX 1000
    
    long int count[500000]; 
    long int mat[MAX][MAX];
    //long int level[MAX];
    // structure to represent adjacency list node
    struct AdjListNode
    {
        int dest;
        struct AdjListNode* next;
        
    };
     
    // structure to represent adjacency list
    struct AdjList
    {
        struct AdjListNode *head;  // pointer to head node of list
    };
     
    // A structure to represent a graph. A graph is an array of adjacency lists.
    // Size of array will be V (number of vertices in graph)
    struct Graph
    {
        long int v;
        struct AdjList* array;
    };
     
    typedef struct AdjListNode NODE;
    typedef struct Graph GRAPH;
    typedef struct AdjList LIST;
    // function to create new node
    NODE* newAdjListNode(int dest)
    {
        
        NODE* newNode =(NODE*) malloc(sizeof(NODE));
        newNode->dest = dest;
        newNode->next = NULL;
        return newNode;
    }
    struct Graph* graph; 
    // function to create graph
    GRAPH* createGraph(long int V)
    {
        GRAPH* graph = (GRAPH*) malloc(sizeof(GRAPH));
        graph->v = V;
     
        //array of adjacency lists.  Size of array will be V
        graph->array = (LIST*) malloc(V * sizeof(LIST));
     
         // Initialize each adjacency list as empty by making head as NULL
        int i;
        for (i = 1; i <=V; ++i)
            graph->array[i].head = NULL;
     
        return graph;
    }
     
    // Adds an edge to an undirected graph
    void addedge(GRAPH* graph, int src, int dest)
    {
        // Add an edge from src to dest.  A new node is added to the adjacency
        // list of src.  The node is added at the begining
        
        NODE* newNode = newAdjListNode(dest);
        newNode->next = graph->array[src].head;
        graph->array[src].head = newNode;
     
        // Since graph is undirected, add an edge from dest to src also
        newNode = newAdjListNode(src);
        newNode->next = graph->array[dest].head;
        graph->array[dest].head = newNode;
    
    }
    
    
     
    void bfs(long int V)
    {
        int i,t,j,l=0,c,k,next[V],temp[V],s;
        long int level[V];
    	NODE* frontier;
    	
    	for(t=1;t<=V;t++)
    	{
    	
    	for(j=1;j<=V;j++)
    	level[j]=0;
    	s=t;
    	frontier=graph->array[s].head;
    	c=1;
    	k=1;
    	level[s]=1;
    	next[1]=s;i=2;
    	while(frontier)
    	{
    		while(k<=c)
    		{
    		frontier=graph->array[next[k++]].head;
    		
    		while(frontier!=NULL)
    		{
    		
    		if(level[frontier->dest]==0)
    		{
    			level[frontier->dest]=i;
    			temp[++l]=frontier->dest;
    			
    		}
    		frontier=frontier->next;	
    		}
    		}
    		for(j=1;j<=l;j++)
    		next[j]=temp[j];
    		c=l;
    		if(l==0)
    		frontier=NULL;
    		else
    		frontier=graph->array[next[c]].head;
    		
    		l=0;
    		k=1;
    		i++;
    	
    	}
    	
    	
    	for(j=1;j<=V;j++)
    	{
    	mat[t][j]=level[j]-1;
    	}
    	
    	}
    
    }
    
    void guard(int a,int t,long int V)
    {
    	int i,j,k=0,x,y;
    	long int protect[V];
    	for(i=1;i<=V;i++)
    	protect[i]=0;
    	for(i=0;i<a;i++)
    	{
    		scanf(""%d%d"",&x,&y);
    		for(j=1;j<=V;j++)
    		if((mat[x][j]>=0)&&(mat[x][j]<=y)&&(protect[j]==0))
    		{
    			protect[j]=1;
    			k++;
    		}
    	}
    count[t]=k;
    }
    int main()
    {
        
        
        int a,b,j,i,n,m;
        long int V;
    	scanf(""%d"",&V);
    	graph = createGraph(V);
    	for(i=0;i<V-1;i++)
        {
        	
    		scanf(""%d%d"",&a,&b);
        	addedge(graph,a,b);
        }
    	
    	bfs(V);
    	scanf(""%d"",&a);
    	for(i=0;i<a;i++)
    	{
    	
    	scanf(""%d"",&b);
    	guard(b,i,V);
    	}
        for(i=0;i<a;i++)
        printf(""%d\n"",count[i]);
        
        return 0;
    }

",C
272453,"
    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    int main()
    {
       unsigned int n,k,p;
       cin>>n>>k>>p;
    
       unsigned int *arr = new unsigned int[n];
    
       for(int i=0;i<n;i++)
       {
         unsigned int temp;
         cin>>temp;
         arr[i]=temp%p;
         if(arr[i] == k)
         {
           cout<<k<<endl;
           exit(0);
         }
         if(arr[i] == 0)
         {
            i--;
            n--;
         }
       }
    
       int found=(int)pow(2,(double)(sizeof(unsigned)*8));
    
       for(int i=0;i<n;i++)
       {
          int sum=0;
          for(int j=i;j<n;j++)
          {
             sum+=arr[j];
             int mod=sum%p;
             if(mod == k)
             {
                cout<<k<<endl;
                exit(0);
             }
             else if((mod > k ) && (mod < found))
             {
                found = mod;
             }
          }
       }
       cout<<found<<endl;
    }
    

",C++
5546407,"
    #include<stdio.h>
    int main()
    	{
    		int a;
    		c:
    		scanf(""%d"",&a);
    		if(a!=42)
    			goto c;
    	}

",C++
1526875,"
    #include<stdio.h>
    int main()
    {	
    while(1){}
    }

",C
11953395,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    
        int t,n,i;
        cin>>t;
    
        while(t--)
        {
            cin>>n;
            int a[n],s[n];
            for(i=0;i<n;i++)
                cin>>a[i];
                s[n-1]=1;
    
            for(i=n-2;i>=0;i--)
            {
                if(a[i]<0)
                {
                    if(a[i+1]>0)
                        s[i]=s[i+1]+1;
                        else
                            s[i]=1;
                }
                if(a[i]>0)
                {
                    if(a[i+1]<0)
                        s[i]=s[i+1]+1;
                        else s[i]=1;
                }
    
            }
            for(i=0;i<n;i++)
            {
                cout<<s[i]<<"" "";
            }
            cout<<endl;
        }
    }
    

",C++
10457510,"
    #include <iostream>
    using namespace std;
    int main(){
    int t ;
    cin >> t;
    while(t--){
    	int size;
    	cin >> size;
    	int a[size];
    	for(int i=0; i< size; i++){
    		cin>> a[i];
    	}
    	int len=1;
    	for(int i=0; i<size; i++){
    		for(int j=i; j<size-1;j++){
    			if(a[j]*a[j+1]<0){
    			len++;
    		} else break;
    		}
    		cout << len << "" "" ;
    		len=1;
    	}
    	cout << """" << endl;
    }
    }

",C++
10092147,"
    #include <iostream>
    using namespace std;
    
    int main(){
        int T;
        cin>>T;
        while(T--){
            int N,i;
            cin>>N;
            int a[N],b[N];
            for(int i=0;i<N;++i){
                cin>>a[i];
            }
            b[N-1]=1;
            for(i=N-2;i>=0;--i){
                if((a[i]>0 && a[i+1]<0) || (a[i]<0 && a[i+1]>0))
                    b[i]=b[i+1]+1;
                else b[i]=1;
            }
            for(int j=0;j<N;++j){
                cout<<b[j]<<"" "";
            }
            cout<<""\n1
            1"";1
        }
    }
    

",C++
9963970,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    
    class AlternatingSubarray {
        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());
            do
            {
                int n=Integer.parseInt(br.readLine());
                int res[]=new int[n];
                String[] str = br.readLine().trim().split("" "");
                long arr[]=new long[n];
                for(int j=0;j<n;j++)
                {
                    arr[j]=Integer.parseInt(str[j]);
                }
                int c=1;
                res[n-1]=c;
                long temp=arr[n-1];
                for(int k=n-2;k>=0;k--)
                {
                       if(temp*arr[k]<0)
                       {
                            c++;
                       }
                       else
                          c=1;
                       res[k]=c;        
                       temp=arr[k];
                }
                for(int l=0;l<n;l++)
                pw.print(res[l]+"" "");
                pw.println();
            }
            while(--t>0);
                pw.flush();
                pw.close();
            
       }
    }
    

",JAVA
11545702,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    
        int t,i,m=0,k[100],l=0;
        cin>>t;
        for(i=0;i<t;i++)
        {
            cin>>k[i];
    
        }
        for(i=0;i<t;i++)
        {
            if(k[i]%2==0)
                m++;
            else
                l++;
        }
        if(m>l)
           cout<<""READY FOR BATTLE""<<endl;
        else
        cout<<""NOT READY""<<endl;
    
    
    }
    

",C++
11242604,"
    #include<stdio.h>
    
    int main()
    {
    	int n,a[100],countO=0,countE=0,i;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&a[i]);
    
    		if(a[i]%2==0)
    		
    			countE++;
    		
    		else
    			countO++;
    		
    	}
    	if(countE>countO)
    	
    		printf(""READY FOR BATTLE"");
    	
    	else
    	
    		printf(""NOT READY"");
    	
    }

",C
10579494,"
    #include<stdio.h>
    #include<conio.h>
    int main()
    {
    int a[101],even=0,odd=0,i,t;
    scanf(""%d"",&t);
    for(i=0;i<t;i++)
    {
    scanf(""%d"",&a[i]);
    if(a[i]%2==0)	
    even++;
    else
    odd++;
    }
    if(even>odd)
    printf(""READY FOR BATTLE"");
    else
    printf(""NOT READY"");
    return 0;
    } 
    
    

",ADA
10516626,"
    #include <iostream>
    using namespace std;
    
    int main()
    {
        int i,a[100],n,no=0,ne=0;
        cin>>n;
        for(i=0;i<n;i++)
        {
            cin>>a[i];
        }
        for(i=0;i<n;i++)
        {
            if(a[i]%2==0)
            {
                ne++;
            }
            else
            {
                no++;
            }
        }
        if(ne>no)
        {
            cout<<""READY FOR BATTLE""<<endl;
        }
        else
        {
            cout<<""NOT READY""<<endl;
        }
        return 0;
    }
    

",C++
9751348,"
    #include<stdio.h>
    int main()
    {
    int s,w[100],i,eve=0,od=0;
    printf(""enter the number of soilders"");
    scanf(""%d"",&s);
    printf(""enter number of weapons"");
    for(i=0;i<s;i++)
    {scanf(""%d"",&w[i]);
    if(w[i]%2==0)
    eve++;
    else
    od++;
    }
    if(eve>od)
    printf(""ready for war"");
    else
    printf(""not ready"");
    }

",ADA
9689583,"
    #include<stdio.h>
    int main()
    {
        int i,a[100],N,even=0,odd=0;
        scanf(""%d"",&N);
        for(i=0;i<N;i++)
        {
            scanf(""%d"",&a[i]);
            if(a[i]%2==0)
                even++;
            else
                odd++;
        }
        if(even>odd)
            printf(""READY FOR BATTLE"");
        else
            printf(""NOT READY"");
        return 0;
    }
    

",C++
9689239,"
    #include<stdio.h>
    
    void main(){
    
    int n,i,lucky=0,unlucky=0,a[100];
    
    scanf(""%d"",&n);		
    if(n <=100)
    {
    for(i=1;i<=n;i++)
     {
    	scanf(""%d"",&a[i]);		
    	if(a[i] % 2 ==0)
    		lucky++;
    	else
    		unlucky++;
    	
     }
    }
    if(lucky > unlucky)
    	printf(""READY FOR BATTLE"");
    else
    	printf(""NOT READY"");
    }

",C
9670393,"
    #include<stdio.h>
    int main()
    {
    	int a,b,luck,badluck;
    	scanf(""%d"",&a);
    	luck=0,badluck=0;
    	while(a--)
    	{
    		scanf(""%i"",&b);
    		if(b%2==0){
    			luck++;
    			}
    		else{
    			badluck++;
    			}
    	}
    	luck>badluck?puts(""READY FOR BATTLE""):puts(""NOT READY"");
    	
    	return 0;
    }

",C
11880001,"
    /*
              ______      
    ||  //   | _____|   ||  //
    || //    ||         || //
    ||//     ||_____    ||//
    ||\\     | _____|   ||\\
    || \\    ||         || \\   
    ||  \\   ||_____    ||  \\  
    ||   \\  |______|   ||   \\ 
                         
    */
    #include<bits/stdc++.h>
    
    using namespace std;
    const int N = 500, N6 = 1e6 + 6, N3 = 1e3 + 6, oo = 1e9 + 9, base = 1e9 + 7;
    const long long ool = 1e18 + 9;
    
    typedef unsigned long long ull;
    typedef long long ll;
    typedef double ld;
    typedef pair <int, int> PII;
    typedef pair <ll, ll> PLL;
    
    #define F first
    #define S second
    #define pb push_back
    #define right(x) x << 1 | 1
    #define left(x) x << 1  
    #define forn(x, a, b) for (int x = a; x <= b; ++x)
    #define for1(x, a, b) for (int x = a; x >= b; --x)
    #define mkp make_pair
    
    int n, a[N], b[N];
    queue < int > q;
    unordered_map < int, int > d;
    unordered_map < int, bool > u;
    
    int main() {
        ios_base :: sync_with_stdio(0);
        cin.tie(0);     
    
        scanf(""%d"", &n);
        forn(i, 1, n + 1) {
            scanf(""%d%d"", &a[i], &b[i]);
        }    
        forn(i, 1, n) {
            d[a[i] * b[n + 1] - b[i] * a[n + 1]] = 1;
            u[a[i] * b[n + 1] - b[i] * a[n + 1]] = 1;
            q.push(a[i] * b[n + 1] - b[i] * a[n + 1]);
        }
    
        while(q.size()) {
            int v = q.front();
            q.pop();
            forn(i, 1, n) {
                int to = v + (a[i] * b[n + 1] - b[i] * a[n + 1]);
                if (abs(to) > N * N)
                    continue;
                if (!u[to]) {
                    u[to] = 1;
                    d[to] = d[v] + 1;
                    q.push(to);
                }
            }
        }
    
        printf(""%d\n"", (d.count(0) ? d[0] : -1));
    
        return 0;
    }

",C++
9860139,"
    #include<iostream>
    #include<string.h>
    using namespace std;
    int main()
    {
    	int p;
    	cin>>p;
    	while(p--)
    	{
    		char str[1001];
    		cin>>str;
    		int d=strlen(str);
    		long long unsigned int n=0;
    		for(int i=0;i<d;i++)
    		{
    			n=n*10+str[i]-48;
    		}
    		long long unsigned int k=0,b=1,a=0;
    		if(n==0 || n==1)
    		cout<<""YES\n"";
    		else
    		{
    		for(int i=2;i<=5000;i++)
    		{
    			k=a+b;
    			if(k==n)
    			{
    				cout<<""YES\n"";
    				break;
    			}
    			a=b;
    			b=k;
    		}
    		if(n<k)
    		cout<<""NO\n"";
    	  
    	  }}
    }

",C++
8131330,"
    #include<iostream>
    #include<cstring>
    using namespace std;
    
    class big_num {
    	string data;
    public:
    	friend istream & operator >>(istream & is, big_num & b) {
    		string s;
    		b.data.clear();
    		getline(is, s);
    
    		for (int i = s.length() - 1; i >= 0; i--) {
    			if (s[i] >= '0' && s[i] <= '9')
    				b.data += s[i] - '0';
    		}
    		while (!b.data[b.data.length() - 1])
    			b.data.erase(b.data.length() - 1);
    
    		return is;
    	}
    
    	friend ostream & operator <<(ostream & os, big_num & b) { //static use inside and outside class of friend function
    		for (int i = b.data.length() - 1; i >= 0; i--)
    			os << char(b.data[i] + '0');
    		os << endl;
    		return os;
    	}
    
    	big_num() {
    	}
    
    	big_num(long long n) {
    		if (n == 0)
    			return;
    		while (n) {
    			data += n % 10;
    			n /= 10;
    		}
    	}
    
    	big_num(const big_num &b) {
    		data.clear();
    		data.append(b.data);
    	}
    
    	big_num operator +(big_num &b) { // what if there is no copy constructor and i use by value passing
    		if (b.data.length() <= 0)
    			return *this;
    		if (this->data.length() == 0) {
    			data.assign(b.data);
    			return *this;
    		}
    		big_num t = *this;
    		char carry = 0;
    		for (unsigned i = 0; i < b.data.length() || i < t.data.length(); i++) {
    			char d1 = 0;
    			if (i < b.data.length())
    				d1 = b.data[i];
    			if (i < t.data.length()) {
    				carry = t.data[i] + carry + d1;
    				t.data[i] = carry % 10;
    			} else {
    				carry += d1;
    				t.data += char(carry % 10);
    			}
    			carry /= 10;
    		}
    		if (carry > 0)
    			t.data += carry;
    		return t;
    	}
    
    	bool operator <(const big_num &b) const {
    		if (data.length() == b.data.length()) {
    			int i;
    			for (i = data.length() - 1; i >= 0; i--) {
    				if (data[i] != b.data[i])
    					break;
    			}
    			if (i < 0)
    				return false;
    			return data[i] < b.data[i];
    
    		} else
    			return data.length() < b.data.length();
    	}
    
    	bool operator ==(const big_num & b) const {
    
    		return this->data == b.data;
    	}
    
    	const big_num& operator =(const big_num & b) {
    		data.assign(b.data);
    		return b;
    	}
    
    	void set_num(long long n) {
    		data.clear();
    		data.append(big_num(n).data);
    	}
    };
    
    int main(int argc, char **argv) {
    	int T;
    	big_num num, a, b, c;
    	cin >> T;
    	string s;
    	getline(cin, s);
    
    	while (T--) {
    		cin >> num;
    		a.set_num(0), b.set_num(1);
    		if (num == big_num(0) || num == b) {
    			cout << ""YES"" << endl;
    			continue;
    		}
    		c.set_num(0);
    		c = b + a;
    		while (c < num) {
    			a = b;
    			b = c;
    			c = a + b;
    		}
    		cout << (c == num ? ""YES"" : ""NO"") << endl;
    	}
    	return 0;
    }
    

",C++
6308038,"
    # include <iostream>
    # include <math.h>
    using namespace std;
    int isfibo(int);
    int isperfectsqrt(int);
    int main(){
    	int t;
    	cin>>t;
    	for(int j = 0; j < t; j++){
    	int n;
    	cin>>n;
    	isfibo(n) ? cout<<""YES""<<endl : cout<<""NO""<<endl;
    	}
    	return 0;
    }
    int isfibo(int n){
    	return(isperfectsqrt(5*n*n + 4) || isperfectsqrt(5*n*n - 4));
    }
    int isperfectsqrt(int n){
    	int s = sqrt(n);
    	return(s*s == n);
    }
    

",C++
5263484,"
    #include<stdio.h>
    #define max 100001
    int f(int n)
    {int flag=0;int a[max];
    	int i=2;
    	a[0]=0;
    	a[1]=1;
    
    	if (n == 0 || n==1 ||n ==2 || n==3)
    	flag=1;
    	else 
    	{
    	
    	while(i<=50001)
    	{
    		a[i]=a[i-1]+a[i-2];
    		if (a[i] == n)
    	{
    		flag=1;printf(""%d"",flag);
    		break;}
    	
    	else if (a[i] != n)
    	{
    	flag=0;
    
    }
    i++;}} return flag;
    	
    	
    }
    int main()
    {
        long long m, t, n, i;
        scanf(""%lld"", &t);
        while(t--)
        {
            scanf(""%d"",&n);
            if (f(n))
    printf(""YES\n"");
    else
    printf(""NO\n"");        
        }
        return 0;
    }
     

",C
4734078,"
        #include <iostream>
        #include<math.h>
        using namespace std;
         
        int main() {
        int n,i,a,p,q;
        scanf(""%d"",&n);
        for(i=0;i<n;i++){
        int sq;
        scanf(""%d"",&a);
        p=5*a*a-4;
        q=5*a*a+4;
        int p1=sqrt(p);
        int q1=sqrt(q);
        if((p1*p1==p)||(q1*q1==q))
        printf(""YES\n"");
        else
        printf(""NO\n"");
        }
        return 0;
        }

",C++
2999358,"
    //import java.io.*;	 // .BufferedReader, .InputStreamReader
    import java.util.*;  // .Scanner
    import java.math.BigInteger;
    
    class cc2013_11_A_AMIFIB {
    
    	//Java version takes 1/2 the time of the C# version (0.96 vs. 2.12 sec),
    	//when programming the actual addition steps for really long numbers.
    	//However, using BigInteger addition and storing as List of strings takes 6.97 sec.
    	//but storing BigIntegers in List takes only 3.84 sec.
    	//static ArrayList<String> fib;
    	 
        public static void main(String[] args) throws Exception
        {
             //4789 Fibinocci numbers having at most 1000 digits
             //fib = new ArrayList<String>();
        	 ArrayList<BigInteger> fib = new ArrayList<BigInteger>();    	 
             GenerateFibs(fib);
    
             Scanner sc = new Scanner(System.in);
             int T = sc.nextInt();         
             //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));    
             //int T = Integer.parseInt(br.readLine());
    
             BigInteger bigNum;
             for (int t = 0; t < T; t++)
             {
            	 //String s = br.readLine();
            	 String s = sc.next();
            	 bigNum = new BigInteger(s);
                 if (fib.contains(bigNum))
                     System.out.println(""YES"");
                 else
                	 System.out.println(""NO"");
             }
             sc.close();
             //br.close();
        }
    
        static void GenerateFibs(ArrayList<BigInteger> fib)
        {
             BigInteger f1 = new BigInteger(""0"");
             BigInteger f2 = new BigInteger(""1"");
             fib.add(f1); //0 element
             fib.add(f1);
             fib.add(f2);
             BigInteger temp;
             int n = 2;
             //while (f2.toString().length() <= 1000)
             while (n <= 4789)
             {
                 temp = f2;
                 f2 = f1.add(f2);
                 f1 = temp;
                 fib.add(f2);
                 n++;
             }
        }
     }
    

",JAVA
272236,"
    #include <stdio.h> 
    #define MAX(a,b) (a)>(b)?(a):(b)
    #define MAXN 110000
     
    int d[MAXN];
    int n;
    int prev[MAXN];
    int v[MAXN];
    int szpm, szv;
    void mergesort(int low, int high)
    {
    	int i, temp;
    	int mid;
    	int p1,p2;
    	int tn;
    	int pmax;
    	if(low == high)
    	{
    		return;
    	}
    	if(high - low == 1)
    	{
    		if(d[low] > d[high] + 1)
    		{
    			temp = d[low];
    			d[low] = d[high];
    			d[high] = temp;
    		}
    		return;
    	}
    	mid = (low + high) / 2;
    	mergesort(low, mid);
    	mergesort(mid + 1, high);
    	p1 = mid, p2 = high;
    	pmax = -1;
    	szpm = 0;
    	for(i = mid + 1; i <= high; i++)
    	{
    		prev[szpm++] = pmax;
    		pmax = MAX(pmax, d[i]);
    	}
    	szv = 0;
    	while(p1 >= low && p2 > mid)
    	{
    		if(d[p1] <= d[p2] + 1)
    		{
    			v[szv++] = (d[p2--]);
    		}
    		else
    		{
    			if(prev[szpm - 1 -high + p2] + 1 >= d[p1])
    			{
    				v[szv++] = (d[p2--]);
    			}
    			else
    			{
    				v[szv++] = (d[p1--]);
    			}
    		}
    	}
    	while(p1 >= low)
    	{
    		v[szv++] = (d[p1--]);
    	}
    	while(p2 > mid)
    	{
    		v[szv++] = (d[p2--]);
    	}
    	tn = szv;
    	for(i = 0; i < tn; i++)
    	{
    		d[high - i] = v[i];
    	}
    	return;
    }
    
    
    int main()
    {
    	int i;
    	int cases;
    	scanf(""%d"", &cases);
    	while(cases --)
    	{
    		scanf(""%d"", &n);
    		for(i = 0; i < n; i++)
    		{
    			scanf(""%d"", &d[i]);
    		}
    		mergesort(0, n - 1);
    		for(i = 0; i < n; i++)
    		{
    			printf(""%d "", d[i]);
    		}
    		printf(""\n"");
    	}
    	return 0;
    }
    

",C
4108454,"
    #include<stdio.h>
    int main()
     {
     	long int T;
     	int N;
     	int i,sum=0;
     	scanf(""%d"",&T);
     	while(T--)
     	 {
     	 	scanf(""%d"",&N);
     	 	// first conditon
     	 	if(360%N==0)
     	 	 printf(""y""); 
     	 	else
    		  printf(""n"");
    		 // second condition
    		 if(N<=360) 
    		  printf(""y"");
    		 else
    		  printf(""n"");
    		  if(N*(N-1)/2<=360)
    		  printf(""y"");
    		  else
    		   printf(""n"");
    		  
    		  // third condition
    		 // sum = 0;
    		  /*for(i=1; i<=N; i++)
    		   {
    		   	if(i==N)
    		   	 {
    		   	 	 sum = sum+(360-sum);
    		   	 	 break;
    		   	 }
    		   	 else
    		   	  {
    		   	  	  if(sum<360)
    		   	  	   sum+=i;
    		   	  	   if(sum>=360)
    		   	  	    break;
    		   	  }
    		   	
    		   }
    		   if(sum==360&&i==N)
    		    printf(""y"");
    		    else
    		    printf(""n"");
    		   */ 
     	 	
     	 }
     	 return 0;
     }

",C
3973623,"
    #include<iostream>
    using namespace std;
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int n;
            cin>>n;
            if(360%n==0)
                cout<<""y "";
            else cout<<""n "";
            if(n<=360)
                cout<<""y "";
            else cout<<""n "";
            if(n*(n+1)/2<=360)
                cout<<""y\n"";
            else cout<<""n\n"";
        }
    }
    

",C++
292429,"
    tests = int(raw_input())
    for i in range(tests):
            tmp = raw_input().split(' ')    
            a = int(tmp[0])
            b = int(tmp[1])
            tot = a*b
            ans = tot*(tot-1)
            if a>2:
                    if b>1: 
                            ans -= 4*(a-2)*(b-1)
            if a>1:
                    if b>2:
                            ans -= 4*(a-1)*(b-2)
            print (ans)

",PYTH
4172469,"
    f=input()
    n=int(f.readline())
    nk=[]
    for i in range(n):
      nk.append([])
      x=int(f.readline())
      y=[]
      for j in range(x):
        y.append(f.readline().split())
        y[j][0]=int(y[j][0])
        y[j][1]=int(y[j][1])
      nsol=1
      for j in range(x):
        count = 0
        for k in range(x):
          if y[k][0] <= j+1 and y[k][1] >= j+1:
            count = count +1
        if count==j+1:
          nk[i].append(j+1)
          nsol=nsol+1
      p=0
      for l in range (x):
        if y[l][0]==0:
          nsol=nsol-1
          p=1
      print(nsol%1000000007)
      if p==0:
        print('0'*x,end='')
      else:
        for z in range(x):
          if y[z][0] <= nk[i][0] and y[z][1] >= nk[i][0]:
            print('1',end='')
          else:
            print('0',end='')
      print()

",PYTH
2898872,"
    int
    a[300] = {0,0,1,2,3,4,4,5,5,5,5,6,6,7,7,7,7,8,8,9,9,9,9,10,10,10,10,10,10,
    11,11,12,12,12,12,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
    16,16,16,16,17,17,17,17,17,17,18,18,19,19,19,19,19,19,20,20,
    20,20,21,21,22,22,22,22,22,22,23,23,23,23,24,24,24,24,24,24,
    25,25,25,25,25,25,25,25,26,26,26,26,27,27,28,28,28,28,29,29,
    30,30,30,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,32,32,32,32,
    33,33,33,33,33,33,34,34,35,35,35,35,35,35,35,35,35,35,36,36,37,37,
    37,37,37,37,38,38,38,38,38,38,39,39,39,39,40,40,40,40,40,40,41,41,41,
    41,41,41,42,42,43,43,43,43,43,43,43,43,43,43,44,44,45,45,45,45,46,46,
    47,47,47,47,47,47,47,47,47,47,47,47,48,48,48,48,48,48,48,48,48,48,48,
    48,49,49,49,49,50,50,51,51,51,51,52,52,52,52,52,52,53,53,
    54,54,54,54,54,54,54,54,54,54};
    int
    main()
    {
            int tc,i,j,m,n;
            char s[501][501];
            char l[501][501];
            char r[501][501];
            char t[501][501];
            char b[501][501];
            int cnt;
            scanf(""%d"", &tc);
            while (tc--) {
                    scanf(""%d%d"", &n, &m);
                    for(i = 0 ; i < n; i++) {
                            scanf(""%s"", s[i]);
                    }
                    for(i = 0; i < n; i++) {
                            if (s[i][0] == '#') {
                                    l[i][0] = -1;
                            } else {
                                    l[i][0] = 0;
                            }
                            for(j = 1; j < m; j ++) {
                                    if (s[i][j] == '#') 
                                            l[i][j] = -1;
                                    else
                                            l[i][j] = l[i][j-1] + 1;
                            }
                    }
                    for(i = 0; i < n; i++) {
                            if (s[i][m-1] == '#') {
                                    r[i][m-1] = -1;
                            } else {
                                    r[i][m-1] = 0;
                            }
                            for(j = m-2; j >= 0; j --) {
                                    if (s[i][j] == '#') 
                                            r[i][j] = -1;
                                    else
                                            r[i][j] = r[i][j+1] + 1;
                            }
                    }
                    for(j = 0; j< m; j++) {
                            if (s[0][j] == '#') {
                                    b[0][j] = -1;
                            } else {
                                    b[0][j] = 0;
                            }
                            for(i = 1; i < n; i ++) {
                                    if (s[i][j] == '#') 
                                            b[i][j] = -1;
                                    else
                                            b[i][j] = b[i-1][j] + 1;
                            }
                    }
                    for(j = 0; j < m; j++) {
                            if (s[n-1][j] == '#') {
                                    t[n-1][j] = -1;
                            } else {
                                    t[n-1][j] = 0;
                            }
                            for(i = n-2; i >= 0; i --) {
                                    if (s[i][j] == '#') 
                                            t[i][j] = -1;
                                    else
                                            t[i][j] = t[i+1][j] + 1;
                            }
                    }
                    cnt = 0;
                    for(i = 0 ; i < n; i++) {
                            for(j = 0; j < m; j ++) {
                                    if (l[i][j] <= r[i][j] &&
                                            l[i][j] <= b[i][j] &&
                                            l[i][j] <= t[i][j]) {
                                            cnt += a[l[i][j]];
                                    } else if (r[i][j] <= b[i][j] &&
                                                    r[i][j] <= t[i][j]) {
                                            cnt += a[r[i][j]];
                                    } else if (b[i][j] <= t[i][j]) {
                                            cnt += a[b[i][j]];
                                    } else {
                                            cnt += a[t[i][j]];
                                    }
    
                            //      printf(""%d%d%d%d\t"", l[i][j],r[i][j],t[i][j],b[i][j]);
                            }
                    //      printf(""\n"");
                    }
                            printf(""%d\n"", cnt);;
            }
            return 0;
    }
    

",C
6772909,"
    #include<iostream>
    #include<algorithm>
    #define infinity 9999
    using namespace std;
    int DP[200005][205], weight[205][205], word[200005], M, N;
    
    int RECURSE(int current_position, int previous){
    
    	if(current_position == N)
    		return 0;
    
    	if(DP[current_position][previous - 1] != infinity)
    		return DP[current_position][previous - 1];
    	
    	int k = 0, i;
    	int *count2 = new int[205];
    	for(i = 0; i < 205; i ++)
    		count2[i] = infinity;
    	for(i = previous - 1; i < M; i ++)
    			if(weight[word[current_position] - 1][i] < infinity){
    				count2[k] = weight[word[current_position] - 1][i] + RECURSE(current_position + 1, i + 1);
    				k ++;
    			}
    	DP[current_position][previous - 1] = *min_element(count2, count2 + 205);
    	delete [] count2;
    	return DP[current_position][previous - 1];
    }
    int main(){
    	int T;
    	cin>>T;
    	while(T --){
    		int K, i, k, j;
    		for(i = 0; i < 200005; i ++)
    			for(j = 0; j < 205; j ++){
    				DP[i][j] = infinity;
    			}
    		
    		for(i = 0; i < 205; i ++)
    			for(j = 0; j < 205; j ++)
    				weight[i][j] = infinity;
    			
    		cin>>M>>K>>N;
    		
    		for(i = 0; i < K; i ++){
    			int x, y;
    			cin>>x>>y;
    			weight[x - 1][y - 1] = weight[y - 1][x - 1] = 1;
    		}
    		
    		for(i = 0; i < N; i ++)
    			cin>>word[i];
    		
    		for(i = 0; i < M; i ++)
    			weight[i][i] = 0;
    			
    		for(k = 0; k < M; k ++)
    			for(i = 0; i < M; i ++)
    				if(weight[i][k] != infinity)
    					for(j = 0; j < M; j ++)
    						if(weight[k][j] != infinity)
    							weight[i][j] = 1;
    		
    		for(i = 0; i < M; i ++)
    			weight[i][i] = 0;
    		
    		int count1 = RECURSE(0, 1);
    		if(count1 >= infinity)
    			cout<<-1<<endl;
    		else
    			cout<<count1<<endl;
    	}
    	return 0;
    }

",C++
10004838,"
    #include <bits/stdc++.h>
    using namespace std;
    
    #define in(a) scanf(""%d"",&a)
    
    struct node {
        int val, priority, size;
        bool rev;
        node *l,*r;
        
    };
    
    node* init(int x)   {
        node* t=new node;
        t->val=x;
        t->rev=0;
        t->priority=rand()%1000;
        t->size=1;
        t->l=NULL;
        t->r=NULL;
        return t;
    }
    
    int sz(node* t) {
        if(!t) return 0;
        else return t->size;
    }
    
    void update_sz(node* t) {
        if(t) t->size=1+sz(t->l)+sz(t->r);
    }
    
    void lazy(node* t) {
        if(!t) return;
        else if(t->rev) {
            t->rev^=1;
            swap(t->l, t->r);
            if(t->l) t->l->rev^=1;
            if(t->r) t->r->rev^=1;
        }
    }
    
    void split(node* T, node* &L, node* &R, int k)     {
        lazy(T);
        if(!T) L=R=NULL;
        else if(1+sz(T->l)<=k) split(T->r, T->r, R, k-1-sz(T->l)), L=T;
        else split(T->l, L, T->l, k), R=T;
        update_sz(T);
    }
    
    void merge(node* &T, node* L, node* R)  {
        lazy(L), lazy(R);
        if(!L) T=R;
        else if(!R) T=L;
        else if(L->priority>R->priority) merge(L->r, L->r, R), T=L;
        else merge(R->l, L, R->l),T=R;
        update_sz(T);
    }
    
    void Traverse(node* x) {
        if(!x)return;
        Traverse(x->l);
        cout<<x->val<<"" "";
        Traverse(x->r);
    }
    
    
    
    int main() {
        srand(42);
        node* root=init(1);
        int N,M;
        in(N); in(M);
        for(int i=2;i<=N;i++)   {
    //        Traverse(root);
    //        cout<<endl;
            merge(root, root, init(i));
        }
    //    Traverse(root);
        int a, b, c;
        while(M--)  {
            in(a); in(b); in(c);
            node *A, *B, *C;
            split(root, A, root, a);
            split(root, B, root, b);
            merge(root, A, root);
            split(root, C, root, c);
            if(B) B->rev^=1;
            merge(root, B, root);
            merge(root, C, root);
        }
        Traverse(root);
        cout<<endl;
        
        return 0;
    }
    

",C++
6068300,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int test,R,C,i,j;
    	char grid[51][51];
    	int l[51][51],r[51][51],t[51][51],b[51][51];
    	
    	cin>>test;
    	while(test--)
    	{
    		cin>>R>>C;
    		for(i=1;i<=R;i++)
    		{
    			//for(j=1;j<=C;j++)
    			//{
    			//	cin>>grid[i][j];
    			//}
    			cin>>grid[i];
    		}
    		for(i=1;i<=R;i++)
    		l[i][1]=0;
    		for(i=1;i<=R;i++)
    		{
    			for(j=2;j<=C;j++)
    			{
    				if(grid[i][j]=='^' && grid[i][j-1]=='^')
    				l[i][j]=l[i][j-1]+1;
    				else
    				l[i][j]=0;
    			}
    		}
    		for(i=1;i<=R;i++)
    		r[i][C]=0;
    		for(i=1;i<=R;i++)
    		{
    			for(j=C-1;j>=1;j--)
    			{
    				if(grid[i][j]=='^' && grid[i][j+1]=='^')
    				r[i][j]=r[i][j-1]+1;
    				else
    				r[i][j]=0;
    			}
    		}
    		for(i=1;i<=C;i++)
    		t[1][i]=0;
    		for(i=2;i<=R;i++)
    		{
    			for(j=1;j<=C;j++)
    			{
    				if(grid[i][j]=='^' && grid[i-1][j]=='^')
    				t[i][j]=t[i-1][j]+1;
    				else
    				t[i][j]=0;
    			}
    		}
    		for(i=1;i<=C;i++)
    		b[R][i]=0;
    		for(i=R-1;i>=1;i--)
    		{
    			for(j=1;j<=C;j++)
    			{
    				if(grid[i][j]=='^' && grid[i+1][j]=='^')
    				b[i][j]=b[i+1][j]+1;
    				else
    				t[i][j]=0;
    			}
    		}
    		int count=0;
    		for(i=1;i<=R;i++)
    		{
    			for(j=1;j<=C;j++)
    			{
    				if(l[i][j]==0||l[i][j]==1||r[i][j]==0||r[i][j]==1||t[i][j]==0||t[i][j]==1||b[i][j]==0||b[i][j]==0)
    				continue;
    				else
    				count++;
    			}
    		}
    		cout<<count<<""\n"";
    	}
    }
    

",C++
11511946,"
    mlmmlm;m;

",ADA
11870629,"
    #include<bits/stdc++.h>
    using namespace std;
    int n,q,cnt,L[200010],st[200010],nd[200010];
    long long A[200010],F[200010],mod=1e9+7;
    vector<int>g[200010],updates[200010];
    vector<pair<int,int> >buf;
    void dfs(int u,int p)
    {
    	int i;
    	L[u]=(p==-1)?1:L[p]+1;
    	st[u]=++cnt;
    	for(i=0;i<g[u].size();i++)
    	{
    		dfs(g[u][i],u);
    	}
    	nd[u]=++cnt;
    }
    bool ispar(int u,int v)//u->v
    {
    	return (st[u]<=st[v] && nd[u]>=nd[v]);
    }
    void apply(int u,int p,long long a,long long b)
    {
    	int i;
    	A[u]=(((A[u]+a)%mod)+b)%mod;
    	long long temp_a=a,temp_b=b;
    	b=(a+b)%mod;a=temp_b;
    	for(i=0;i<updates[i].size();i++)
    	{
    		A[u]=(A[u]+F[updates[u][i]])%mod;
    		b=(b+F[updates[u][i]])%mod;
    		a=(a+F[updates[u][i]-1])%mod;
    	}
    	for(i=0;i<g[u].size();i++)
    	{
    		apply(g[u][i],u,a,b);
    	}
    }
    main()
    {
    	int i,t,x,k;
    	char type[5];
    	cin>>n>>q;
    	F[0]=0;F[1]=1;
    	for(i=2;i<200010;i++)
    	F[i]=(F[i-2]+F[i-1])%mod;
    	for(i=1;i<n;i++)
    	{
    		cin>>t;
    		g[t].push_back(i+1);
    	}
    	dfs(1,-1);
    	for(t=0;t<q;t++)
    	{
    		cin>>type;
    		if(type[0]=='U')
    		{
    			cin>>x>>k;
    			if(buf.size()>320)
    			{
    				apply(1,-1,0,0);
    				for(i=0;i<=n;i++)updates[i].clear();
    				buf.clear();
    			}
    			updates[x].push_back(k);
    			buf.push_back(make_pair(x,k));
    		}
    		else
    		{
    			cin>>x;
    			long long res=A[x];
    			for(i=0;i<buf.size();i++)
    			{
    				if(ispar(buf[i].first,x))
    				res=(res+F[buf[i].second+L[x]-L[buf[i].first]])%mod;
    			}
    			cout<<res<<endl;
    		}
    	}
    }

",C++
4150253,"
    #include <bits/stdc++.h>
    		
    using namespace std;
    #define ff first
    #define ss second
    #define pb push_back
    #define mp make_pair
    typedef unsigned long long ull;
    typedef long long int lli;
    typedef unsigned int ui;
    typedef pair<int, int> pii;
    typedef vector<int> vi;
    typedef long double ld;
    #define var(a,b)  __typeof(b) a = b
    #define rep(i,n)  for(int i = 0; (i) < (n); ++i)
    #define rept(i,a,b) for(var(i,a); i < (b); ++i)
    #define tr(v,it)  for(var(it,v.begin());it!=v.end();++it)
    #define fill(a,val) memset(a,val,sizeof(a))
    #define all(v) v.begin(),v.end()
    
    #define get getchar_unlocked
    
    //fast input
    template<class T>
    inline T scan_int() {int ip=get(),flag=1;T ret=0;for(;ip<'0'||ip>'9';ip=get())if(ip=='-'){flag=-1;ip=get();break;}for(;ip>='0'&&ip<='9';ip=get())ret=(ret<<3)+(ret<<1)+ip-'0';return flag*ret;}
    #define scan_d() scan_int<int>()
    #define scan_ld() scan_int<long int>()
    #define scan_lld() scan_int<long long int>()
    template <class T>
    inline T scan_decimal(){char c;c = get();T flag=1.0;long long int t = 0;for(;c<'0'||c>'9';c=get())if(c=='-'){flag=-1.0;c=get();break;}while(c<='9' && c>='0'){t=(t<<3)+(t<<1)+c-'0';c = get();}long long int d=0,i=1;if(c=='.'){c = get();while(c<='9' && c>='0'){i=(i<<3)+(i<<1);d=(d<<3)+(d<<1)+c-'0';c = get();}}return ((T)t + ((T)d)/i)*flag;}
    #define scan_f() scan_decimal<float>()
    #define scan_lf() scan_decimal<double>()
    inline void scan_str(char *str){register char c = 0;register int i = 0;while (c < 33)c = get();while (c != '\n' && c != EOF){str[i] = c;c = get();i = i + 1;}str[i] = '\0';}
    //end of fast input
    
    //fast output
    #define put putchar_unlocked
    char output_buffer[21];
    template <class T>
    inline void print_int(T n) {if(n<0){n=-n;put('-');}int i=21;do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{put(output_buffer[i]);}while(++i<21);}
    #define print_d print_int<int>
    #define print_ld print_int<long int>
    #define print_lld print_int<long long int>
    template <class T>
    inline void println_int(T n) {print_int(n);put('\n');}
    #define println_d println_int<int>
    #define println_ld println_int<long int>
    #define println_lld println_int<long long int>
    template <class T>
    inline void printsp_int(T n,char ch) {print_int(n);put(ch);}
    #define printsp_d printsp_int<int>
    #define printsp_ld printsp_int<long int>
    #define printsp_lld printsp_int<long long int>
    inline void print_str(char *str){char* temp=str;while((*temp)!='\0'){put(*temp);temp++;}}
    //end of fast output
    
    #define MAXM 100009
    
    bool exists[MAXM];
    int arr[MAXM];
    
    int main() {
    #ifdef LOCAL
        freopen(""/home/pramesh/Desktop/codes/in"", ""r"", stdin);
    #endif
    
        int m = scan_d();
        int flag;
        rep(i, m) arr[i] = scan_d();
    
        if(m == 1) {
        	println_d(1);
        	println_d(arr[0]);
        	return 0;
        }
    
        //sort(arr, arr + m);
    
        int count1 = 2;
        vi selected1;
    
        selected1.pb(arr[0]);
        selected1.pb(arr[1]);
        exists[arr[0]] = true;
        exists[arr[1]] = true;
    
        rept(i, 2, m) {
        	flag = 1;
        	for(int x = count1-1; x > 0; x--) {
        		if(((selected1[x]<<1) - arr[i]) >= 0 && ((selected1[x]<<1) - arr[i]) < MAXM && exists[(selected1[x]<<1) - arr[i]]) {
        			flag = 0;
        			break;
        		}
        	}
        	if(flag) {
        		count1++;
        		selected1.pb(arr[i]);
        		exists[arr[i]] = true;
        	}
        }
    
    
        //fdfkfjfjf
    
        fill(exists, 0);
    
        //sort(arr, arr + m, greater<int>());
    
        int count2 = 2;
        vi selected2;
    
        selected2.pb(arr[m-1]);
        selected2.pb(arr[m-2]);
        exists[arr[m-1]] = true;
        exists[arr[m-2]] = true;
    
        for(int i = m-3; i >= 0; i--) {
        	flag = 1;
        	for(int x = count2-1; x > 0; x--) {
        		if(((selected2[x]<<1) - arr[i]) >= 0 && ((selected2[x]<<1) - arr[i]) < MAXM && exists[(selected2[x]<<1) - arr[i]]) {
        			flag = 0;
        			break;
        		}
        	}
        	if(flag) {
        		count2++;
        		selected2.pb(arr[i]);
        		exists[arr[i]] = true;
        	}
        }
    
        if(count1 >= count2) {
        	println_d(count1);
        	tr(selected1, it)
        		printsp_d(*it, ' ');
        }
        else {
        	println_d(count2);
        	tr(selected2, it)
        		printsp_d(*it, ' ');
        }
    
    
    	return 0;
    }

",C++
10914780,"
    #include<iostream>
    #include<cstdio>
    using namespace std;
    
    int main(){
    	int v,res=0;
    	for(int i=1;!res&&i<=5;++i)
    		for(int j=i+1;!res&&j<=5;++j){
    			puts(""1"");
    			printf(""1 %d\n"",i);
    			printf(""1 %d\n"",j);
    			fflush(stdout);
    			scanf(""%d"",&v);
    			if(v<0)
    				res=j;
    			else if(v>0)
    				res=i;
    			}
    	printf(""2\n%d\n"",res);
    	fflush(stdout);
    	return 0;
    	}
    

",C++
10501955,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	setbuf(stdout, NULL);
    	/*int done=0,ans;
    	if(!done)
    	{
    		cout<<1<<endl;
    		cout<<1<<"" ""<<1<<endl;
    		cout<<1<<"" ""<<2<<endl;
    		fflush(stdout);
    		cin>>ans;
    		if(ans!=0)
    		{
    			cout<<2<<endl;
    			if(ans==1)
    			cout<<1;
    			else
    			cout<<2;
    			done=1;
    			return 0;
    		}
    		if(!done)
    		{
    			cout<<1<<endl;
    			cout<<1<<"" ""<<3<<endl;
    			cout<<1<<"" ""<<4<<endl;
    			fflush(stdout);
    			cin>>ans;
    			if(ans!=0)
    			{
    				cout<<2<<endl;
    				if(ans==1)
    				cout<<3;
    				else
    				cout<<4;
    				done=1;
    				return 0;
    			}
    		}
    		cout<<2<<endl;
    		cout<<5;
    		return 0;
    		
    		
    		
    		
    	}
    	*/
    	int ans;
    	cout<<1<<endl;
    	cout<<3<<"" ""<<4<<"" ""<<5<<"" ""<<5<<endl;
    	cout<<3<<"" ""<<1<<"" ""<<1<<"" ""<<2<<endl;
    	fflush(stdout);
    	cin>>ans;
    	cout<<ans+3;
    	
    	
    
    
    
    return 0;
    }
    

",C++
3621768,"
    #include <stdio.h>
    #include <string.h>
    //using namespace std;
    
    int main()
    {
        int n,num,k,j,rem = 0,temp,pos[3],a_i;
        short a[1003];
        scanf(""%d"",&n);
        int i = 0;
        for(;i<n;i++)
        {
    
            scanf(""%d %d"",&num,&k);
            memset(a,0,k+1);
            rem = 0;
            for(j=0;j<num && rem<=2;j++)
            {
                scanf(""%d"",&a_i);
                temp = a_i%(k+1);
                if(a[temp] == 0)
                {
                    pos[rem] = temp;
                    rem++;
                    a[temp]++;
                }
                else
                {
                    a[temp]++;
                }
    
            }
    
            if(rem == 1)
            {
                printf(""YES\n"");
            }
            else if(rem>2)
            {
                printf(""NO\n"");
            }
            else
            {
                if((a[pos[0]] == n-1) || (a[pos[1]] == n-1))
                {
                    printf(""YES\n"");
    
                }
                else
                {
                    printf(""NO\n"");
                }
            }
    
    
        }
    
    
    }
    

",C++
3129584,"
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    #include <iostream>
    
    using namespace std;
    
    int a[1000];
    
    inline void read(int *input)
    {
    	char ch = 0;
     
    	while(ch<33){
    		ch = getchar();
    	}
    	*input = 0;
     
    	while(ch > 33)	{
    		*input = *input * 10 + ch - '0';
    		ch = getchar();
    	}
    }
    
    int main()
    {
    	int case_num;
    	scanf(""%d"", &case_num);
    
    	char str[60000];
    	while(case_num){
    		case_num--;
    
    		int n, k;
    		scanf(""%d %d"", &n, &k);	
    		int rem[2], remcount = 0;
    		bool ans = true;
    		bool nonz = false;
    
            for(int j = 0; j < n; j++) {
                read(&(a[j]));
    			int tmp = a[j] % (k + 1);
    			if (a[j] != 0){
    				nonz = true;
    			}
    			if (remcount == 0){
    				rem[0] = a[j] % (k + 1);
    				remcount++;
    			}
    			else if (remcount == 1){
    				if (tmp != rem[0]){
    					rem[1] = tmp;
    					remcount++;
    				}
    			}
    			else if (remcount == 2){
    				if (tmp == rem[0]){
    					rem[1] = -1;
    				}
    				else if (tmp == rem[1]){
    					rem[0] = -1;
    				}
    				else{
    					ans = false;
    					break;
    				}
    			}
            }
    		if (ans && nonz){
    			printf(""YES\n"");
    		}
    		else{
    			printf(""NO\n"");
    		}
    	}
    	return 0;
    }

",C++
3097563,"
    #include<stdio.h>
    int main()
    {
    	int test;
    	scanf(""%d"",&test);
    	while(test--)
    	{
    		int n,k;
    		scanf(""%d %d"",&n,&k);
    		int a[n];
    		int i;
    		int b[11]={0};
    		int d=0;
    		for(i=0;i<n;i++)
    		{
    			scanf(""%d"",&a[i]);
    			if(b[a[i]%(k+1)]==0)
    			{
    				d++;
    			}				b[a[i]%(k+1)]++;
    			b[a[i]%(k+1)]++;
    		}
    		if(d>2)
    			printf(""NO\n"");
    		else if(d==1){
    			printf(""YES\n"");
    		}
    		else if(d==2)
    		{
    			int flag1=0;
    			int flag2=0;
    			for(i=0;i<11;i++)
    			{
    				if(b[i]==n-1)
    					flag1=1;
    				if(b[i]==1)
    					flag2=1;
    			}
    			if(flag1==1&&flag2==1)
    				printf(""YES\n"");
    			else
    				printf(""NO\n"");
    		}
    			
    	}
    	return 0;
    }
    

",C++
821375,"
    //package medium;
    
    /*
     * 
    3
    2 1
    10 10
    3 2
    1 2 2
    3 2
    1 2 3
    
    
    1
    4 3
    -3 1 1 6
    
    1
    4 6
    8 1 1 3
    
    
    1
    4 1
    0 0 0 0
    
    
     * 
     */
    
    import java.io.IOException;
    import java.util.Set;
    import java.util.TreeSet;
    
    /**
     * Solution: From the forum.
     * 
     * Observe that all elements in the array will undergo the same number of transformations.
     * Some of these transformations will be increment by K and
     * some of these will be decrement by 1
     * 
     * Consider a number a_i.
     * Let 'm' be the number of transformations applied before the array got converted to the
     * desired form.
     * Let x_i transformations be increment by K
     * and y_i transformations by decrement by 1.
     * x_i + y_i = m
     * 
     * a_i + x_i.K - y_i = 0
     * a_i + x_i.(K+1) - m = 0
     * 
     * m = a_i + x_i.(K+1)
     * 
     * m % (K+1) = a_i % (K+1)
     * 
     * This implies that each of the a_i's save one must give the same remainder with K+1. 
     * 
     * @author apurv
     *
     */
    
    
    public class Main {
    
      
      
      public int[] transform(int[] A, int K){
        int[] tA = new int[A.length];
        for(int i = 0; i < A.length; i++){
          while(A[i] < 0){
            A[i] += (K+1);
          }
          tA[i] = A[i]%(K+1);
        }
        return tA;
      }
      
      private boolean allZeros(int[] A){
        for(int a:A){
          if(a!=0)
            return false;
        }
        return true;
      }
       
    
      public void execute() throws IOException{
        int T = FastReader.nextInt();
        for(int i = 0; i < T; i++){
          int n = FastReader.nextInt();
          int K = FastReader.nextInt();
    
          int[] A = new int[n];
          for(int j = 0; j < n; j++){
            A[j] = FastReader.nextInt();
          }
          
          if(allZeros(A) && K > 0){
            System.out.println(""NO"");
            continue;
          }
          
          int[] tA = transform(A, K);
          
          Set<Integer> set = new TreeSet<Integer>();
          boolean flag = false;
          for(int x:tA){
            set.add(x);
            
            if(set.size() > 2){
              flag = true;
              break;
            }
          }
          System.out.println(set);
          System.out.println((flag)?""NO"":""YES"");
        }
      }
    
      /**
       * @param args
       * @throws IOException 
       */
      public static void main(String[] args) throws IOException {
        Main at = new Main();
        at.execute();		
      }
    
    }
    
    
    
    
    class FastReader {
      private static final int DEFAULT_SIZE = 1 << 15;
      private static byte[] buf = new byte[DEFAULT_SIZE];
      private static int ptr;
      private static int have;
    
      public static void setSize(int size) {
        buf = new byte[size];
      }
    
      private FastReader() throws Exception {
        throw new Exception();
      }
    
      private static void eat() throws IOException {
        have = System.in.read(buf, 0, buf.length);
        if (have < 0)
          have = 0;
        ptr = 0;
      }
    
      private static int read() throws IOException {
        if (ptr == have) {
          eat();
          if (have == 0)
            return -1;
        }
        return buf[ptr++] & 255;
      }
    
      public static int nextInt() throws IOException {
        int c = read();
        while ((c < '0' || c > '9') && c != '-')
          c = read();
        boolean negative = false;
        if (c == '-') {
          negative = true;
          c = read();
        }
        int m = 0;
        while (c >= '0' && c <= '9') {
          m = m * 10 + c - '0';
          c = read();
        }
        return negative ? -m : m;
      }
    
      public static long nextLong() throws IOException {
        int c = read();
        while ((c < '0' || c > '9') && c != '-')
          c = read();
        boolean negative = false;
        if (c == '-') {
          negative = true;
          c = read();
        }
        long m = 0;
        while (c >= '0' && c <= '9') {
          m = m * 10 + c - '0';
          c = read();
        }
        return negative ? -m : m;
      }
    
      private static char nextChar() throws IOException {
        int c = read();
        while (c <= ' ') {
          c = read();
        }
        return (char) c;
      }
    }
    

",JAVA
437693,"
    /* 
     * File:   main.cpp
     * Author: Vimal
     *
     * Created on January 29, 2011, 2:52 PM
     */
    
    #include <cstdlib>
    #include<iostream>
    
    using namespace std;
    
    /*
     * 
     */
    int main() {
        int t,n,k,a[100],i,j,r[2],count[2];
        cin>>t;
        while(t)
        {
            cin>>n;
            cin>>k;
            for(i=0;i<n;i++)
            {
                cin>>j;
                a[i]=j%(k+1);
            }
            count[1]=0;
            r[0]=a[0];
            count[0]=1;
            for(i=1;i<n;i++)
            {
                if(a[i]==r[0]) count[0]++;
                else if(count[1]==0)
                {
                    count[1]=1;
                    r[1]=a[i];
                }
                else if(count[1]!=0&&a[i]==r[1])
                    count[1]++;
                else if(count[1]!=0&&a[i]!=r[1])
                {
                    cout<<""NO\n"";
                    break;
                }
            }
            if(count[0]==n||count[1]==n||count[0]==(n-1)||count[1]==(n-1))
                cout<<""YES\n"";
            else
                cout<<""NO\n"";
            t--;
        }
        return 0;
    }
    
    

",C++
437344,"
    //Array Transform//
    
    #include<stdio.h>
    #include<stdlib.h>
    
    int main()
    {
        int t,n,k,ctr1,ctr2,*arr,i,flag,t1,t2;
        scanf(""%d"",&t);
        while(t--)
        {
            ctr2=ctr1=1;
            flag=i=0;
            scanf(""%d%d"",&n,&k);
            if(n==2)
            flag=1;
            arr=(int *)calloc(n,sizeof(int));
            for(i=0;i<n;i++)
            {
                scanf(""%d"",&arr[i]);
            }
            if(flag)
             printf(""YES\n"");
            else
            {
                t1=arr[0];
                for(i=1;i<n;i++)
                {
                    if(!((arr[i]-t1)%(k+1))||!((t1-arr[i])%(k+1)))
                     ctr1++;
                }
                if(ctr1>1&&ctr1<n-1)
                 printf(""NO\n"");
                else if(ctr1==n-1||ctr1==n)
                 printf(""YES\n"");
                else
                {
                    t1=arr[1];
                    for(i=2;i<n;i++)
                    {
                        if(!((arr[i]-t1)%(k+1))||!((t1-arr[i])%(k+1)))
                         ctr2++;
                    }
                    if(ctr2<n-1)
                    printf(""NO\n"");
                    else
                    printf(""YES\n"");
                }
            }
        }
        return 0;
        }
    
    

",C
435963,"
    #include<stdio.h>
    main(){
    int n,k,i,j,m,p;int count=0;int count1=0;
    printf(""Enter the Number of tests: "");
    scanf(""%d"",&p);
    for(n=0;n<=p;n++){
    printf(""Enter The values of N&K: "");
    scanf(""%d %d"",&n,&k);
    int array[n];int array1[n];
    for(i=0;i<n;i++){
        printf(""Enter The values of Array[i]: "");
        scanf(""%d"",array[i]);
              }
              for(j=0;j<n;j++){
              if(array[0]==array[j]){
                count=count+1;   }
              else{
              for(k=0;k<n;k++){
              array1[k]=array[j];}
                 }}
             for(m=0;j<m;m++){
              if(array1[0]==array1[j]){
                count1=count1+1;   }
                }
                if((count==k && count1==(n-1))||(count==(k-1)&&count1==(n)))
                printf(""yes"");
                else
                printf(""no"");
    }
    }
    

",C
425323,"
    #include<stdio.h>
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int test(int ar[],int m)
    {
        int i,max;
        int a[1001]={0};
        for( i=0;i<m;++i)
        a[ar[i]]++;
         max=0;
        for(i=1;i<1001;++i)
        if(a[i]>max)max=a[i];
        return max;
    }
        
    int main()
    {
        int t,n,k,i,m,flag,count,ar[100],j;
        cin>>t;
        while(t>0)
        {
                  cin>>n>>k;
                  i=0;m=n;flag=0;count=0;
                  if(n==1){cout<<""NO""<<endl;flag=1;}
                  while(n>0)
                  {
                            cin>>ar[i++];
                            --n;
                  }if(m==2&&(ar[0]!=ar[1])){cout<<""YES""<<endl;flag=1;}
                  else if(m==2){cout<<""YES""<<endl;flag=1;}
                  while(flag!=1)
                  {
                                for(j=0;j<i;++j)
                                ar[j]=ar[j]%(k+1);
                                 if(test(ar,m)==m-1||test(ar,m)==m)
                          {cout<<""YES""<<endl;break;}
                          else {cout<<""NO""<<endl;break;}
                  }
                  --t;
        }
        
                  return 0;
    }
    

",C++
4339601,"
    #include <iostream>
    #include <string>
    #include <algorithm>
    using namespace std;
    
    struct book
    {
    	string name;
    	long int page;
    	long int pos;
    };
    
    bool compare(const book &a, const book &b)
    {
    	if(a.page == b.page)return a.pos<b.pos;
    	return a.page<b.page;
    }
    
    
    int main() 
    {
    	long int n,i,no,c;
    	cin>>n;
    	book b[n];
    	c = 0;
    	for(i=0;i<n;i++)
    	{
    		cin>>no;
    		
    		if(no!=-1)
    		{
    			b[c].page = no;
    	        cin>>b[c].name;
    			b[c].pos = c;
    			c++;
    		}
    		else if(no==-1 && c!=0)
    		{
    			sort(b,b+c,compare);
    			cout<<b[0].pos<<"" ""<<b[0].name<<""\n"";
    			c = 0;
    		}
    		
    		
    	}
    	
    	return 0;
    }

",C++
3650657,"
    #include<iostream>
    #include<stack>
    #include<string>
    #include<stdio.h>
    using namespace std;
    string a[100001];
    int main(){
        long n,i,k,v;
        string st;
        stack<long> s,t;
        scanf(""%ld"",&n);
        k=0;
        i=0;
        s.push(100005);
        while(n--){
            scanf(""%ld"",&v);
            if(v==-1){
                cout<<k-t.top()-1<<"" ""<<a[i-1]<<endl;
                i--;
                k=t.top();
                s.pop();
                t.pop();
            }
            else{
                cin>>st;
                if(v<=s.top()){
                    s.push(v);
                    t.push(k);
                    a[i]=st;
                    i++;
                }
                k++;
            }
        }
        return 0;
    }
    

",C++
1655447,"
    import sys
    def main() :
      n = int(sys.stdin.readline())
      ll = []
      for i in range (n) :
        str = sys.stdin.readline().rstrip()
        if ""-1"" in str :
          minval = min(x[0] for x in ll)
          maxidx = max(x for x in range(len(ll)) if ll[x][0] == minval)
          numpops = len(ll) - maxidx;
          print ""%d %s"" % (numpops-1,ll[maxidx][1])
          del ll[maxidx:]
        else:
          (d,bookname) = str.split()
          ll.append([d,bookname])
    main()
    

",PYTH
1651273,"
    #include<iostream>
    #include<cstdio>
    #include<string>
    using namespace std;
    
    
    int main()
    {
       int n, cur, min = 100004, minindex;
    
       int bookcount =0, bookused =0;
        scanf(""%d"", &n);
        string books[n];
        int remex[n];
        int j = 0;
        for(int i=0; i<n; i++)
        {
            scanf(""%d"", &cur );
            if(cur>=0)
            {
            remex[j] = cur;
            cin>>books[j++];
            bookcount++;
            //cout<<""book count is ""<<bookcount<<endl;
            }
            else
            {
               for(int p=0; p<bookcount; p++)
               {
                   if(remex[p] < min)
                   {
                    min = remex[p];
                   }
               }
    
    
    
               for(int q =bookcount-1 ; q>=0; q--)
               {
                   if(remex[q] == min)
                   {
                   minindex = q;
    
                   break;
                   }
    
               }
    
               cout<<(bookcount - minindex -1- bookused )<<"" ""<<books[minindex]<<endl;
               remex[minindex]= 100005;
               min = 100004;
               bookused++;
            }
        }
    
    
    }
    

",C++
1632004,"
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintWriter;
    import java.math.BigInteger;
    import java.util.InputMismatchException;
    import java.util.PriorityQueue;
    import java.util.Stack;
    
    public class Main {
    	private InputReader in;
    	private PrintWriter out;
    
    	static class State implements Comparable<State>{
    		int exercise;
    		String subject;
    		
    		public State(int e, String s) {
    			exercise = e;
    			subject = s;
    		}
    
    		public int compareTo(State a) {
    			return exercise - a.exercise;
    		}
    
    		@Override
    		public String toString() {
    			return ""State [exercise="" + exercise + "", subject="" + subject + ""]"";
    		}
    		
    		
    		
    	}
    	private void solve() {
    		int n = in.readInt();
    		
    		Stack<State> st = new Stack<State>();
    		PriorityQueue<State> pq = new PriorityQueue<State>();
    		
    		while (n-- > 0) {
    			int e = in.readInt();
    			
    			if (e == -1) {
    				State min = pq.poll();
    				if (min == null) {
    					pl(0);
    					continue;
    				}
    				int res = 0;
    				while (!st.isEmpty()) {
    					State removed = st.pop();
    					if (min.exercise == removed.exercise && min.subject.equals(removed.subject)) {
    						pl(res, min.subject);
    						break;
    					}
    					++res;
    				}
    			} else {
    				String s = in.readString();
    				State cur = new State(e, s);
    				st.push(cur);
    				pq.add(cur);
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		new Main().run();
    	}
    
    	private Main() {
    
    		in = new InputReader(System.in);
    		out = new PrintWriter(System.out);
    	}
    
    	private void run() {
    
    		solve();
    		exit();
    	}
    
    	private void exit() {
    		out.close();
    		System.exit(0);
    	}
    
    	private static class InputReader {
    		private InputStream stream;
    		private byte[] buf = new byte[1024];
    		private int curChar, numChars;
    
    		public InputReader(InputStream stream) {
    			this.stream = stream;
    		}
    
    		public int read() {
    			if (numChars == -1)
    				throw new InputMismatchException();
    			if (curChar >= numChars) {
    				curChar = 0;
    				try {
    					numChars = stream.read(buf);
    				} catch (IOException e) {
    					throw new InputMismatchException();
    				}
    				if (numChars <= 0)
    					return -1;
    			}
    			return buf[curChar++];
    		}
    
    		public int readInt() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			int sgn = 1;
    			if (c == '-') {
    				sgn = -1;
    				c = read();
    			}
    			int res = 0;
    			do {
    				if (c < '0' || c > '9')
    					throw new InputMismatchException();
    				res *= 10;
    				res += c - '0';
    				c = read();
    			} while (!isSpaceChar(c));
    			return res * sgn;
    		}
    
    		public long readLong() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			int sgn = 1;
    			if (c == '-') {
    				sgn = -1;
    				c = read();
    			}
    			long res = 0;
    			do {
    				if (c < '0' || c > '9')
    					throw new InputMismatchException();
    				res *= 10;
    				res += c - '0';
    				c = read();
    			} while (!isSpaceChar(c));
    			return res * sgn;
    		}
    
    		public String readString() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			StringBuffer res = new StringBuffer();
    			do {
    				res.appendCodePoint(c);
    				c = read();
    			} while (!isSpaceChar(c));
    			return res.toString();
    		}
    
    		private boolean isSpaceChar(int c) {
    			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    		}
    
    		private String readLine0() {
    			StringBuffer buf = new StringBuffer();
    			int c = read();
    			while (c != '\n' && c != -1) {
    				if (c != '\r')
    					buf.appendCodePoint(c);
    				c = read();
    			}
    			return buf.toString();
    		}
    
    		public String readLine() {
    			String s = readLine0();
    			while (s.trim().length() == 0)
    				s = readLine0();
    			return s;
    		}
    
    		public String readLine(boolean ignoreEmptyLines) {
    			if (ignoreEmptyLines)
    				return readLine();
    			else
    				return readLine0();
    		}
    
    		public BigInteger readBigInteger() {
    			try {
    				return new BigInteger(readString());
    			} catch (NumberFormatException e) {
    				throw new InputMismatchException();
    			}
    		}
    
    		public char readCharacter() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			return (char) c;
    		}
    
    		public double readDouble() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			int sgn = 1;
    			if (c == '-') {
    				sgn = -1;
    				c = read();
    			}
    			double res = 0;
    			while (!isSpaceChar(c) && c != '.') {
    				if (c == 'e' || c == 'E')
    					return res * Math.pow(10, readInt());
    				if (c < '0' || c > '9')
    					throw new InputMismatchException();
    				res *= 10;
    				res += c - '0';
    				c = read();
    			}
    			if (c == '.') {
    				c = read();
    				double m = 1;
    				while (!isSpaceChar(c)) {
    					if (c == 'e' || c == 'E')
    						return res * Math.pow(10, readInt());
    					if (c < '0' || c > '9')
    						throw new InputMismatchException();
    					m /= 10;
    					res += (c - '0') * m;
    					c = read();
    				}
    			}
    			return res * sgn;
    		}
    
    		public int[] readIntArray(int size) {
    			int[] array = new int[size];
    			for (int i = 0; i < size; i++)
    				array[i] = readInt();
    			return array;
    		}
    
    		public long[] readLongArray(int size) {
    			long[] array = new long[size];
    			for (int i = 0; i < size; i++)
    				array[i] = readLong();
    			return array;
    		}
    
    		public double[] readDoubleArray(int size) {
    			double[] array = new double[size];
    			for (int i = 0; i < size; i++)
    				array[i] = readDouble();
    			return array;
    		}
    
    		public String[] readStringArray(int size) {
    			String[] array = new String[size];
    			for (int i = 0; i < size; i++)
    				array[i] = readString();
    			return array;
    		}
    
    		public char[][] readTable(int rowCount, int columnCount) {
    			char[][] table = new char[rowCount][columnCount];
    			for (int i = 0; i < rowCount; i++) {
    				for (int j = 0; j < columnCount; j++)
    					table[i][j] = readCharacter();
    			}
    			return table;
    		}
    
    		public void readIntArrays(int[]... arrays) {
    			for (int i = 0; i < arrays[0].length; i++) {
    				for (int j = 0; j < arrays.length; j++)
    					arrays[j][i] = readInt();
    			}
    		}
    	}
    
    	void p(Object... objects) {
    		for (int i = 0; i < objects.length; i++) {
    			if (i != 0)
    				out.print(' ');
    			out.flush();
    			out.print(objects[i]);
    			out.flush();
    		}
    	}
    
    	void pl(Object... objects) {
    		p(objects);
    		out.flush();
    		out.println();
    		out.flush();
    	}
    
    }

",JAVA
1628768,"
    // try BEX - using stack a data structure problem
    // a linear complexity one!
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <stack>
    using namespace std;
    
    struct node
    {
           char name[15];
           long long int no_ex;
           int no_books;
    };
    
    int main()
    {
        
        stack<node> s;
        node ss, t;
        long long int n, num;
        scanf(""%lld"", &n);
        
        while(n--) {
                   scanf(""%lld"", &num);
                   if (num != -1) {
                      scanf(""%s"", ss.name);
                      if (s.empty() == false) {
                         t = s.top();
                         if (num != 0) {
                         if (num > t.no_ex) {
                            t.no_books++;
                            s.pop();
                            s.push(t);
                         } else if(num != 0) {
                            ss.no_ex = num;
                            ss.no_books = 0;
                            s.push(ss);
                         }
                         }
                      } else {
                            if (num != 0) {
                               ss.no_ex = num;
                               ss.no_books = 0;
                               s.push(ss);
                            }
                      } 
                   } else if(num == -1 && num != 0) {
                     t = s.top();
                     s.pop();
                     printf(""%d %s"", t.no_books, t.name);
                   }
        }    
        
        //system(""pause"");
        return 0;
    }
    

",C++
12092111,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int t;
    	cin >> t;
    	while(t--)
    	{
    	    long long r,g,b,k;
    	    cin >> r >> g >> b;
    	    cin >> k;
    	    cout << min(r,k-1)+min(g,k-1)+min(b,k-1)+1 << ""\n"";
            }
    	return 0;
    }

",C++
8094030,"
    #include <stdio.h>
    #include <string.h>
    #define MAXN 1005
    using namespace std;
    
    int nrt, n;
    bool s[MAXN][MAXN], f[MAXN][MAXN], row[MAXN], col[MAXN];
    
    int main()
    {
        //freopen(""in"", ""r"", stdin);
    
        scanf(""%d"", &nrt);
        while(nrt--) {
            scanf(""%d"", &n);
            for(int i = 1; i <= n; i++)
                for(int j = 1; j <= n; j++)
                    scanf(""%d "", &s[i][j]);
            for(int i = 1; i <= n; i++)
                for(int j = 1; j <= n; j++)
                    scanf(""%d "", &f[i][j]);
    
            memset(row, 0, sizeof(row));
            memset(col, 0, sizeof(col));
    
            int sol = 0;
            for(int j = 1; j <= n; j++)
                if(s[1][j] != f[1][j]) {
                    col[j] = 1;
                    ++sol;
                }
    
            bool noSol = 0;
            for(int i = 2; i <= n; i++)
                for(int j = 1; j <= n; j++)
                    if(s[i][j] ^ row[i] ^ col[j] != f[i][j]) {
                        if(row[i]) {
                            noSol = 1;
                            break;
                        }
                        else ++sol, row[i] = 1;
                    }
    
            if(noSol) {
                printf(""-1\n"");
                continue;
            }
    
            int cntRow = 0, cntCol = 0;
            for(int i = 1; i <= n; i++) {
                cntRow += (row[i] == 1);
                cntCol += (col[i] == 1);
            }
    
            if(sol < 2 * n - sol || (sol == 2 * n - sol && col[1] == 1)) {
                if(!sol) {
                    printf(""0\n"");
                    continue;
                }
    
                printf(""%d\n"", cntRow);
                for(int i = 1; i <= n; i++)
                    if(row[i])
                        printf(""%d\n"", i - 1);
                printf(""%d\n"", cntCol);
                for(int i = 1; i <= n; i++)
                    if(col[i])
                        printf(""%d\n"", i - 1);
            }
            else {
                sol = 2 * n - sol;
                cntRow = n - cntRow;
                cntCol = n - cntCol;
    
                printf(""%d\n"", cntRow);
                for(int i = 1; i <= n; i++)
                    if(!row[i])
                        printf(""%d\n"", i - 1);
                printf(""%d\n"", cntCol);
                for(int i = 1; i <= n; i++)
                    if(!col[i])
                        printf(""%d\n"", i - 1);
            }
        }
    
        return 0;
    }
    

",C++
351551,"
    #include<iostream>
    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<vector>
    #include<algorithm>
    #include<stack>
    #include<queue>
    #include<list>
    //#include<conio.h>
    
    
    #define min(a,b) (a>b?b:a)
    #define max(a,b) (a>b?a:b)
    
    
    using namespace std;
    
    char inp[10000000];
    char *ptr;
    
    inline int SCAN_INT(void)
    {
        while(!(*ptr<='9' && *ptr>='0'))
            ptr++;
        int  ret=0;
        while(*ptr<='9' && *ptr>='0')
            ret=ret*10+(*(ptr++))-'0';
        return ret;
    }
    
    inline char SCAN_CHAR(void)
    {
        while(!(*ptr<='Z' && *ptr>='A') && !(*ptr<='9' && *ptr>='0'))
            ptr++;
        return *ptr++;
    }
    
    char s[1000][1000];
    char t[1000][1000];
    char f[1000][1000];
    int pr[2000];
    vector<int> ansr;
    vector<int> ansc;
    int n;
    
    int chk()
    {
        for(int i=0;i<n;i++){
            int tmp = strcmp(f[i],t[i]);
            if(tmp!=0)
                return 0;
        }
        return 1;
    }
    
    void toggle(int a)
    {
        if(a<=n){
            for(int i=0;i<n;i++){
                t[a-1][i]=(t[a-1][i]=='0')?'1':'0';
            }
        }
        if(a>n){
            a=a-n;
            for(int i=0;i<n;i++){
                t[i][a-1]=(t[i][a-1]=='0')?'1':'0';
            }
        }
    }
    
    int press(int count,int start)
    {
        if(count==0){
            int r=chk();
            return r;
        }
        for(int i=start;i<=2*n;i++){
            if(pr[i]==1)
                continue;
            toggle(i);
            pr[i]=1;
            int t=press(count-1,i+1);
            pr[i]=0;
            toggle(i);
            if(t==1){
                if(i<=n)
                    ansr.push_back(i-1);
                else
                    ansc.push_back(i-n-1);
                return 1;
            }
        }
        return 0;
    }
    
    void reset()
    {
       for(int i=0;i<n;i++){
            strcpy(t[i],s[i]);
        }
    }
    
    int main()
    {
        //freopen(""input.txt"",""r"", stdin);
    	fread(inp, sizeof(char), 10000000, stdin);
    	ptr = inp;
    	int t;
    	t=SCAN_INT();
    	while(t--){
            n=SCAN_INT();
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    s[i][j]=SCAN_CHAR();
                }
                s[i][n]='\0';
            }
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    f[i][j]=SCAN_CHAR();
                }
                f[i][n]='\0';
            }
            reset();
            if(chk()){
                printf(""0\n"");
                continue;
            }
            int i;
            for(i=1;i<=2*n;i++){
                reset();
                int tmp=press(i,1);
                if(tmp==1)
                    break;
            }
            if(i>2*n){
                printf(""-1\n"");
                continue;
            }
            printf(""%d\n"",ansr.size());
            for(int i=ansr.size()-1;i>=0;i--)
                printf(""%d\n"",ansr[i]);
            printf(""%d\n"",ansc.size());
            for(int i=ansc.size()-1;i>=0;i--)
                printf(""%d\n"",ansc[i]);
            ansr.clear();
            ansc.clear();
    	}
    }
    

",C++
100051,"
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.IOException;
    import java.util.*;
    
    public class Main {
    
        public static void main(String[] args){
                Main main = new Main();
            try {
                main.execute();
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
    
        public class TestCase {
            int size;
            int[][] origSquare;
            int[][] destSquare;
            int[][] dArray;
    
        }
    
        public class NotPossibleException extends Exception {
            public NotPossibleException(){
                super();
            }
        }
    
        private void execute() throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
            int numOfTestCases=Integer.parseInt(br.readLine());
            List<TestCase> tCases=new ArrayList<TestCase>();
            for (int i=0;i<numOfTestCases;i++){
                int n=Integer.parseInt(br.readLine());
                int[][] oriSquare=new int[n][n];
                int[][] destSquare=new int[n][n];
                for (int j=0;j<n;j++){
                      String row=br.readLine();
                      StringTokenizer token=new StringTokenizer(row,"" "");
                      for(int count=0;count<n;count++){
                          oriSquare[j][count]=Integer.parseInt(token.nextToken());
                      }
                }
                for (int j1=0;j1<n;j1++){
                      String row=br.readLine();
                      StringTokenizer token=new StringTokenizer(row,"" "");
                      for(int count=0;token.hasMoreTokens();count++){
                          destSquare[j1][count]=Integer.parseInt(token.nextToken());
                      }
                }
                TestCase tCase=new TestCase();
                tCase.size=n;
                tCase.origSquare=oriSquare;
                tCase.destSquare=destSquare;
                tCases.add(tCase);
            }
    
            for(TestCase tCase:tCases){
                boolean possTransform=true;
                Set rowButtons=new HashSet();
                Set colButtons=new HashSet();
                int n=tCase.size;
                int[][] dArray=new int[n][n];
                for (int u=0;u<n;u++){
                   for (int u1=0;u1<n;u1++){
                       if (tCase.origSquare[u][u1]==tCase.destSquare[u][u1])
                       dArray[u][u1]=0;
                       else dArray[u][u1]=1;
                   }
                }
                tCase.dArray=dArray;
    
                boolean evenSize=false;
                if (n%2==0)
                    evenSize=true;
                int midLenght=n/2;
    
                try{
                    if (!evenSize){
                        int mid=midLenght;
                        if (tCase.origSquare[mid][mid]==tCase.destSquare[mid][mid]){
                            if (tCase.origSquare[0][mid]!=tCase.destSquare[0][mid]
                                        && tCase.origSquare[mid][0]!=tCase.destSquare[mid][0]
                                    && tCase.origSquare[n-1][mid]!=tCase.destSquare[n-1][mid]
                                    && tCase.origSquare[mid][n-1]!=tCase.destSquare[mid][n-1]){
                                            rowButtons.add(midLenght);
                                            toggleRow(tCase,midLenght);
                                            colButtons.add(midLenght);
                                            toggleCol(tCase,midLenght);
                            }
                        }else{
                            int sumCol=0;
                            int sumRow=0;
                            for (int p=0;p<n-1;p++){
                                if (tCase.origSquare[mid][p]!=tCase.destSquare[mid][p]){
                                    sumRow++;
                                }
                                if (tCase.origSquare[p][mid]!=tCase.destSquare[p][mid]){
                                    sumCol++;
                                }
                            }
                            if (sumRow>=sumCol){
                                //row mid pressed
                                rowButtons.add(mid);
                                toggleRow(tCase,mid);
                            }else if(sumRow<sumCol){
                                //col mid pressed
                                colButtons.add(mid);
                                toggleCol(tCase,mid);
                            }
                        }
                    }
                    for (int i=midLenght-1;i>=0;i--){
                        //on corners
                        int s00=tCase.origSquare[i][i];
                        int s01=tCase.origSquare[i][n-1-i];
                        int s10=tCase.origSquare[n-1-i][i];
                        int s11=tCase.origSquare[n-1-i][n-1-i];
    
                        int d00=tCase.destSquare[i][i];
                        int d01=tCase.destSquare[i][n-1-i];
                        int d10=tCase.destSquare[n-1-i][i];
                        int d11=tCase.destSquare[n-1-i][n-1-i];
    
                        int[][] matrix=new int[2][2];
    
    
                        if (s00==d00)
                            matrix[0][0]=0;
                        else
                            matrix[0][0]=1;
                        if (s01==d01)
                            matrix[0][1]=0;
                        else
                            matrix[0][1]=1;
                        if (s10==d10)
                            matrix[1][0]=0;
                        else
                            matrix[1][0]=1;
                        if (s11==d11)
                            matrix[1][1]=0;
                        else
                            matrix[1][1]=1;
    
                        int sumofChanges=matrix[0][0]+matrix[0][1]+matrix[1][0]+matrix[1][1];
                        if (sumofChanges==1 || sumofChanges==3)
                            throw new NotPossibleException();
                        if (sumofChanges==0){
                             //all corners are 0
                            int sumOfmidsRow0=0;
                            int sumOfmidsRow1=0;
                            int sumOfMidsCol0=0;
                            int sumOfMidsCol1=0;
                            for (int h=i+1;h<n-1-i;h++){
    
                                 if (tCase.origSquare[i][h]!=tCase.destSquare[i][h])
                                    sumOfmidsRow0++;
                                 if (tCase.origSquare[n-1-i][h]!=tCase.destSquare[n-1-i][h])
                                    sumOfmidsRow1++;
                                if (tCase.origSquare[h][i]!=tCase.destSquare[h][i])
                                    sumOfMidsCol0++;
                                 if (tCase.origSquare[h][n-1-i]!=tCase.destSquare[h][n-1-i])
                                    sumOfMidsCol1++;
                            }
                            int noOfmidsChanged=0;
                            if (sumOfmidsRow0>0)
                                noOfmidsChanged++;
                            if (sumOfmidsRow1>0)
                                noOfmidsChanged++;
                            if (sumOfMidsCol0>0)
                                noOfmidsChanged++;
                            if (sumOfMidsCol1>0)
                                noOfmidsChanged++;
    
                            if (noOfmidsChanged==0){
                                continue;
                            }else{
                                if (noOfmidsChanged==1||noOfmidsChanged==2||noOfmidsChanged==3)
                                      throw new NotPossibleException();
                                    if (evenSize){
                                            rowButtons.add(i);
                                            toggleRow(tCase,i);
                                            colButtons.add(i);
                                            toggleCol(tCase,i);
                                            rowButtons.add(n-i-1);
                                            toggleRow(tCase,n-i-1);
                                            colButtons.add(n-i-1);
                                            toggleCol(tCase,n-i-1);
                                    }else{
                                        if (i==midLenght-1){
                                           rowButtons.add(midLenght);
                                            toggleRow(tCase,midLenght);
                                            colButtons.add(midLenght);
                                            toggleCol(tCase,midLenght);
                                        }else{
                                            rowButtons.add(i);
                                            toggleRow(tCase,i);
                                            colButtons.add(i);
                                            toggleCol(tCase,i);
                                            rowButtons.add(n-i-1);
                                            toggleRow(tCase,n-i-1);
                                            colButtons.add(n-i-1);
                                            toggleCol(tCase,n-i-1);
                                        }
                                    }
                            }
                        }
    
                        if (sumofChanges==2){
                                int mid01=1;
                                int mid10=1;
                                int mid12=1;
                                int mid21=1;
                                if(!evenSize){
                                    mid01=tCase.dArray[i][midLenght];
                                    mid10=tCase.dArray[midLenght][i];
                                    mid12=tCase.dArray[midLenght][n-i-1];
                                    mid21=tCase.dArray[n-1-1][midLenght];
                                }
    
    
                                if (matrix[0][0]==1&& matrix[0][1]==1){
                                    //row i pressed
                                    if (mid01==1){
                                         rowButtons.add(i);
                                        toggleRow(tCase,i);
                                    }else{
                                          rowButtons.add(n-1-i);
                                        toggleRow(tCase,n-1-i);
                                        colButtons.add(i);
                                        toggleCol(tCase,i);
                                        colButtons.add(n-1-i);
                                        toggleCol(tCase,n-1-i);
                                    }
    
                                }else if (matrix[0][0]==1&& matrix[1][0]==1){
                                    //column i pressed
                                    if(mid10==1){
                                       colButtons.add(i);
                                        toggleCol(tCase,i);
                                    }else{
                                          colButtons.add(n-1-i);
                                        toggleCol(tCase,n-1-i);
                                        rowButtons.add(i);
                                        toggleRow(tCase,i);
                                        rowButtons.add(n-1-i);
                                        toggleRow(tCase,n-1-i);
                                    }
    
                                }else if (matrix[1][0]==1&& matrix[1][1]==1){
                                    //row n-1-i pressed
                                    if (mid21==1){
                                       rowButtons.add(n-1-i);
                                        toggleRow(tCase,n-1-i);
                                    }else{
                                        rowButtons.add(i);
                                        toggleRow(tCase,i);
                                        colButtons.add(i);
                                        toggleCol(tCase,i);
                                         colButtons.add(n-1-i);
                                        toggleCol(tCase,n-1-i);
                                    }
    
                                }else if (matrix[1][1]==1&& matrix[0][1]==1){
                                    //column n-1-i pressed
                                    if(mid12==1){
                                       colButtons.add(n-1-i);
                                        toggleCol(tCase,n-1-i);
                                    }else{
                                        colButtons.add(i);
                                        toggleCol(tCase,i);
                                        rowButtons.add(i);
                                        toggleRow(tCase,i);
                                        rowButtons.add(n-1-i);
                                        toggleRow(tCase,n-1-i);
                                    }
    
                                }else{
    
                                    int sumRow0=0;
                                    int sumRow1=0;
                                    int sumColmn0=0;
                                    int sumColmn1=0;
    
                                    for (int g=i+1;g<=n-i-2;g++){
                                        if (tCase.origSquare[i][g]!=tCase.destSquare[i][g])
                                            sumRow0++;
                                        if (tCase.origSquare[n-1-i][g]!=tCase.destSquare[n-1-i][g])
                                            sumRow1++;
                                        if (tCase.origSquare[g][i]!=tCase.destSquare[g][i])
                                            sumColmn0++;
                                        if (tCase.origSquare[g][n-1-i]!=tCase.destSquare[g][n-1-i])
                                            sumColmn1++;
                                    }
                                        if (sumRow0>sumRow1){
                                               rowButtons.add(i);
                                               toggleRow(tCase,i);
                                         }else if (sumRow0<sumRow1){
                                            rowButtons.add((n-1-i));
                                            toggleRow(tCase,n-1-i);
                                        }
                                    if (sumColmn0>sumColmn1){
                                               colButtons.add(i);
                                               toggleCol(tCase,i);
                                         }else if (sumColmn0<sumColmn1){
                                               colButtons.add(n-1-i);
                                               toggleCol(tCase,n-1-i);
                                    }
                                    if(sumRow0==sumRow1&&sumColmn0==sumColmn1){
                                        if (matrix[0][0]==0 && matrix[0][1]==1 && matrix[1][0]==1 && matrix[1][1]==0){
                                               int sum= checkSumRowColumnToggle(tCase,i,i);
                                               int sum2= checkSumRowColumnToggle(tCase,n-1-i,n-1-i);
                                               if (sum<=sum2){
                                                   rowButtons.add(i);
                                                   toggleRow(tCase,i);
                                                    colButtons.add(i);
                                                   toggleCol(tCase,i);
                                               }else{
                                                   rowButtons.add(n-1-i);
                                                   toggleRow(tCase,n-1-i);
                                                   colButtons.add(n-1-i);
                                                   toggleCol(tCase,n-1-i);
                                               }
    
                                        }else{
                                              int sum= checkSumRowColumnToggle(tCase,n-1-i,i);
                                              int sum2= checkSumRowColumnToggle(tCase,i,n-1-i);
                                              if (sum<sum2){
                                                   rowButtons.add(n-1-i);
                                                  toggleRow(tCase,n-1-i);
                                                  colButtons.add(i);
                                                  toggleCol(tCase,i);
                                              }else{
                                                   rowButtons.add(i);
                                                  toggleRow(tCase,i);
                                                  colButtons.add(n-1-i);
                                                  toggleCol(tCase,n-1-i);
                                              }
    
                                        }
                                    }
                                }
                        }else if (sumofChanges==4){
                                    int sumRows=0;
                                    int sumColmns=0;
                                    int sumRows0=0;
                                    int sumColmns0=0;
                                    int sumRows1=0;
                                    int sumColmns1=0;
    
                                    for (int g=i;g<n-i;g++){
                                        if (tCase.origSquare[i][g]!=tCase.destSquare[i][g])
                                            sumRows0++;
                                        if (tCase.origSquare[n-1-i][g]!=tCase.destSquare[n-1-i][g])
                                            sumRows1++;
                                        if (tCase.origSquare[g][i]!=tCase.destSquare[g][i])
                                            sumColmns0++;
                                        if (tCase.origSquare[g][n-1-i]!=tCase.destSquare[g][n-1-i])
                                            sumColmns1++;
                                    }
                                    sumRows=sumRows0+sumRows1;
                                    sumColmns=sumColmns0+sumColmns1;
                                    if (sumRows>sumColmns){
                                        // row i and n-1-i pressed.
                                        rowButtons.add(i);
                                        rowButtons.add(n-1-i);
                                        toggleRow(tCase,i);
                                        toggleRow(tCase,n-1-i);
                                    }else if (sumRows<sumColmns){
                                        //column i and n-1-i pressed.
                                         colButtons.add(i);
                                        colButtons.add(n-1-i);
                                        toggleCol(tCase,i);
                                        toggleCol(tCase,n-1-i);
                                    }else {
                                        throw new NotPossibleException();
                                    }
    
                        }
                    }
    
                }catch(NotPossibleException npe){
                       possTransform=false;
                }
                if(possTransform){
                    try {
                        checkSame(tCase,rowButtons,colButtons);
                    } catch (NotPossibleException e) {
                        System.out.println(-1);
                        continue;
                    }
                    if(rowButtons.size()==0&&colButtons.size()==0){
                        System.out.println(0);
                        continue;
                    }
                    System.out.println(rowButtons.size());
                    for(Object rownum:rowButtons){
                           System.out.println(((Integer)rownum).toString());
                    }
                    System.out.println(colButtons.size());
                    for(Object colnum:colButtons){
                           System.out.println(((Integer)colnum).toString());
                    }
                }else{
                    System.out.println(-1);
                }
            }
        }
    
        private int checkSumRowColumnToggle(TestCase tCase, int rowIndex, int colIndex) {
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.dArray[rowIndex][i]= (tCase.dArray[rowIndex][i]+1)%2;
            }
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.dArray[i][colIndex]= (tCase.dArray[i][colIndex]+1)%2;
            }
            int sum=0;
            for (int i=0;i<tCase.size;i++){
                for (int j=0;j<tCase.size;j++){
                    sum=sum+tCase.dArray[i][j];
                }
            }
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.dArray[rowIndex][i]= (tCase.dArray[rowIndex][i]+1)%2;
            }
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.dArray[i][colIndex]= (tCase.dArray[i][colIndex]+1)%2;
            }
            return sum;
        }
    
        private void checkSame(TestCase tCase, Set rowButtons, Set colButtons) throws NotPossibleException {
            for (int i=0;i<tCase.size;i++){
                for (int j=0;j<tCase.size;j++){
                    if (tCase.origSquare[i][j]!=tCase.destSquare[i][j])
                        throw new NotPossibleException();
                }
            }
        }
    
        private void toggleRow(TestCase tCase, int rIndex) {
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.origSquare[rIndex][i]= (tCase.origSquare[rIndex][i]+1)%2;
                tCase.dArray[rIndex][i]= (tCase.dArray[rIndex][i]+1)%2;
            }
        }
    
        private void toggleCol(TestCase tCase, int cIndex) {
            for (int i=0;i<tCase.origSquare.length;i++){
                tCase.origSquare[i][cIndex]= (tCase.origSquare[i][cIndex]+1)%2;
                tCase.dArray[i][cIndex]= (tCase.dArray[i][cIndex]+1)%2;
            }
        }
    }
    

",JAVA
99733,"
    #include <stdio.h>
    #include <stdlib.h>
    
    
    void print (FILE *fp, int *arr, int n);
    void read (FILE *infile, int ** m, int n);
    bool checkSolutionExist(int **initial, int **final, int n, int &sumXY);
    int * buttonMainPart(int ** initial, int **final, int n);
    int value (int init, int final, int xOry);
    int findSolution(int *x, int *y, int **initial, int **final, int n, int sumXY);
    void generateTestcase(int n);
    int main (int argc, char *argv [])
    {
        FILE *infile;// = fopen (argv[1], ""r"");
        int n;
        int **initial, **final;
        
        //fscanf(infile, ""%d"", &n);
      // if ( 0 == argv[1])
      // {
      //     for (int i = 900; i < 1000; i += 5)
      //     {
      //         for (int j = 0; j < 100; j++)
      //         generateTestcase(i);
      //     }
      //     return 0;
      // }
        infile = stdin;//fopen (argv[1], ""r"");
        int nofTest;
        fscanf(infile, ""%d"", &nofTest);
        for (int i = 0; i < nofTest; i++)
        {
            fscanf(infile, ""%d"", &n);
            initial = (int **) malloc (n * sizeof (int *) );
            final = (int **) malloc (n * sizeof (int *) );
            read (infile,initial, n);
            read (infile,final, n);
            int *sArray = buttonMainPart(initial, final, n);
            if (sArray != 0)
            {
                print (stdout,sArray, n);
            }
            else
            {
                printf(""-1\n"");
            }
        }
        return 0;
        
    
    }
    void print (FILE *outfile, int *arr, int n)
    {
        int i;
        int numr = 0;
        int numc = 0;
        for ( i = 0; i < n; i++)
        {
            if (arr[i] == 1) numr++;
        }
        fprintf (outfile,""%d\n"", numr);
        for ( i = 0; i < n; i++)
        {
            if (arr[i] == 1)
            fprintf (outfile,""%d\n"", i);
        }
        printf (""\n"");
        for (  i = n; i < 2*n ; i++)
        {
            if (arr[i] == 1) numc++;
        }
        fprintf (outfile,""%d\n"", numc);
        for (  i = n; i < 2*n ; i++)
        {
            if (arr[i] == 1) fprintf (outfile,""%d\n"", i - n);
        }
        printf (""\n"");
    }
    
    void read (FILE *infile, int ** m, int n)
    {
        for (int i = 0; i < n; i++)
        {
            int *temp = (int *) malloc (n * sizeof (int));
            int k;
            for (int j = 0; j < n; j++)
            {
                fscanf(infile, ""%d"", &k);
                temp [j] = k;
            }
            m [i] = temp;
        }
    }
    
    bool checkSolutionExist(int **initial, int **final, int n, int &sumXY)
    {
        // n is number of row/cloumn
    
        sumXY = 0;
           for (int i = 0; i < n; i++)
           {
               sumXY += (initial[i][i] - final[i][i]) != 0;
           }
         //  return true;
        for (int i = 1; i < n; i++)
        {
            int x0Ply0 = (initial[0][0] - final[0][0]) != 0;
            int xiPly0 = (initial[i][0] - final[i][0]) != 0;
            int xiMnx0 = (x0Ply0 - xiPly0)  != 0;
            for (int j = 1; j < n; j++)
            {
                int x0Plyj = (initial[0][j] - final[0][j]) != 0;
                int xiPlyj = (initial[i][j] - final[i][j]) != 0;
                int temp = (x0Plyj - xiPlyj) != 0;
                if (temp != xiMnx0)
                {
                    return false;
                }
            }
        }
       //int temp = 0;
       //int first = 1;
       //int second = n - 1;
       //while (first != n)
       //{
       //    int k,j;
       //    temp = 0;
       //    for (k = 0,j = first; j < n; j++, k++)
       //    {
       //        temp += (initial[k][j] - final[k][j]) != 0;
       //    }
       //    for (k = 0, j = second; j < n; j++, k++)
       //    {
       //        temp += (initial[j][k] - final[j][k]) != 0;
       //    }
       //    if (temp != sumXY)
       //    {
       //        return false;
       //    }
       //    first++;
       //    second--;
       //}
        return true;
    }
    
    int * buttonMainPart(int ** initial, int **final, int n)
    {
        int sumXY ;
        if (checkSolutionExist(initial, final, n, sumXY) == false)
        {
            return 0;
        }
    
        int *x = (int *) malloc (n * sizeof(int));
        int *y = (int *) malloc (n * sizeof(int));
        int *soultionArray = (int *) malloc (2*n * sizeof(int));
        for (int i = 0; i < n ; i++)
        {
            x[i] = 0;
            y[i] = 0;
        }
        int numOfButtonPressed = findSolution(x,y, initial, final, n, sumXY);
        for (int i = 0; i < n; i++)
        {
            soultionArray[i] = x[i];
            soultionArray[i+n] = y[i];
            x[i] = y[i] = 0;
        }
        x[0] = 1;
        int temp = findSolution(x,y,initial, final, n, sumXY);
        if (temp < numOfButtonPressed)
        {
            numOfButtonPressed = temp;
            for (int i = 0; i < n; i++)
            {
                soultionArray[i] = x[i];
                soultionArray[i+n] = y[i];
            }
        }
        return soultionArray;
    }
    
    int value (int init, int final, int xOry)
    {
        return abs((init != final) - xOry);
    }
    int findSolution(int *x, int *y, int **initial, int **final, int n, int sumXY)
    {
        int c = x[0];
        for (int i = 0; i < n; i++)
        {
            y[i] = value (initial[0][i], final[0][i], x[0]);
            c += y[i];
        }
        for (int i = 1; i < n - 1; i++)
        {
            x[i] = value (initial[i][0] , final[i][0], y[0]);
            c += x[i];
        }
        x[n - 1] = abs (sumXY - c) % 2;
        return c + x[n - 1];
    }
    
    
    

",C++
95322,"
    #include <iostream>
    #include <stdlib.h>
    #include <vector>
    #include <cstdio>
    #include <stdio.h>
    using namespace std;
    
    
    
    class Grid
    {
      private:
        
        short int **m_finalG;
        int m_n;
        int m_nrow;
        int m_ncol;
        bool m_match;
        
        vector<int> m_row;
        vector<int> m_col;
        
      public:
        short int **m_g;
        Grid(int &n)
        {
    	m_nrow=0; m_ncol=0;
    	m_match=false;
    	m_n = n;
    	m_g = (short int ** )malloc(sizeof(short int * ) * n );
    	for ( int i=0;i<n;i++)
    	    m_g[i] = (short int * )malloc(sizeof(short int *)* n );
    	
    	for ( int i=0;i<n;i++)
    	    for ( int j=0;j<n;j++)
    		scanf(""%d"", m_g[i]+j );
    
    	m_finalG = (short int ** )malloc(sizeof(short int * ) * n );
    	for ( int i=0;i<n;i++)
    	    m_finalG[i] = (short int * )malloc(sizeof(short int *)* n );
    
    	for ( int i=0;i<n;i++)
    	    for ( int j=0;j<n;j++)
    		scanf(""%d"", m_finalG[i]+j );
    	
        }
        
        ~Grid()
        {
    	for ( int i=0;i<m_n;i++)
    	{
    	    free(m_finalG[i]);
    	    free(m_g[i]);
    	}
        }
        
        bool evaluate2(short int ** initial,int t=-1,bool boolrow=false,bool boolcol=false )
        {
    	short int ** array;
    	array = (short int ** )malloc(sizeof(short int * ) * m_n );
    	for ( int i=0;i<m_n;i++)
    	    array[i] = (short int * )malloc(sizeof(short int *)* m_n );
    	
    	for ( int i=0;i<m_n;i++)
    	    for ( int j=0;j<m_n;j++)
    		*(array[i]+j) = *(initial[i]+j);
    	    
    	if ( boolrow == true )
    	    toggler(t,array);
    	else if ( boolcol == true )
    	    togglec(t,array);
          
    //	show(array);
    	int mc=0,mr=0;
    	int finalMisMatch=0;
    	int maxmismatch=0;
    	for(int i=0;i<m_n;i++)
    	{
    	    int mismatchc=0,mismatchr=0;
    	    for (int j=0;j<m_n;j++)
    	    {
    		if (*(m_finalG[i]+j) != *(array[i]+j) )
    		    mismatchr++;
    		if (*(m_finalG[j]+i) != *(array[j]+i) )
    		    mismatchc++;
    	    }
    	    finalMisMatch = mismatchc+mismatchr + finalMisMatch;
    	    if ( mismatchc > mc && mismatchc >= m_n/2 )
    		mc=mismatchc;
    	    if(mismatchr >mr && mismatchr >= m_n/2 )
    		mr=mismatchr;
    	}
    	if ( mc <= mr )
    	    maxmismatch = mr;
    	else 
    	    maxmismatch = mc;
    //	cout << ""mc=""<<mc<<"" mr=""<<mr<<""\t""<<finalMisMatch<<endl;
    	if ( finalMisMatch == 0)
    	{
    	    m_match = true;
    //	    cout<< ""as mismatc =0, returning true""<<endl;
    	    return true;
    	}
    	if ( mc ==0 && mr ==0 )
    	    return false;
    	
    	vector<int> vRow,vCol;
    	
    	for(int i=0;i<m_n;i++)
    	{
    	    int mismatchc=0,mismatchr=0;
    	    for (int j=0;j<m_n;j++)
    	    {
    		if (*(m_finalG[i]+j) != *(array[i]+j) )
    		    mismatchr++;
    		if (*(m_finalG[j]+i) != *(array[j]+i) )
    		    mismatchc++;
    	    }
    	    if(mismatchc == maxmismatch )
    		vCol.push_back(i);
    	    if(mismatchr == maxmismatch )
    		vRow.push_back(i);
    	}
    	
    	if ( vRow.size() ==0 && vCol.size() == 0 )
    	{
    //	    cout << ""as row size=0,colsize=-0,returnng false""<<endl;
    	    return false;
    	}
    //	cout <<""roz,col""<< vRow.size() << ""\t""<< vCol.size()<<endl;
    	bool status = false;
    //	cout << "" before row for loop"" <<endl;
    	for( int i=0;i<vRow.size();i++)
    	{
    	    m_row.push_back(vRow.at(i));
    	    m_nrow++;
    //	    cout << ""for row=""<<i<<""\t""<<vRow.size()<<endl;
    	    status=evaluate2(array,vRow.at(i),true,false);
    //	    cout <<""status returned in row"" << status<<""\t""<<i<< endl;
    	    if ( status == false )
    	    {	
    		m_row.pop_back();
    		m_nrow--;
    	    }
    	    else
    		break;
    	}
    	if (status == true )
    	{
    //	    cout<< ""as status true, returning before col for loop""<<endl;
    	    return status;
    	}
    	
    //	cout << ""before col for loop""<<endl;
    	for(int i=0;i<vCol.size();i++)
    	{
    	    m_col.push_back(vCol.at(i));
    	    m_ncol++;
    //	    cout << ""for col=""<<i<<""\t"" <<vCol.size() <<endl;
    	    status = evaluate2(array,vCol.at(i),false,true);
    //	    cout <<""status returned in col"" << status<< ""\t""<<i<<endl;
    	    
    	    if ( status == false )
    	    {
    		m_col.pop_back();
    		m_ncol--;
    	    }
    	    else
    		break;	    
    	}
    	return status;
        }
    
        void toggler(int r, short int ** array)
        {
    //      cout << ""\n toggling row=""<<r<<endl;
          if (r<0 )
    	  return;
          
          
    	for ( int j=0;j<m_n;j++)
    	    if ( *(array[r]+j) == 0 )
    		*(array[r]+j) = 1;
    	    else 
    		*(array[r]+j) = 0;
        }
        
        void togglec(int c, short int ** array)
        {
    //      cout<<""\ntoggling col=""<<c<<endl;
          if ( c<0 ) 
    	  return;
          
    	for ( int j=0;j<m_n;j++)
    	    if ( *(array[j]+c) == 0 )
    		*(array[j]+c) =1;
    	    else
    		*(array[j]+c) =0;
        }
        
        void show(short int ** array=NULL)
        {
    	cout << endl<<""initial matrix"" <<endl;
    	    for( int i=0;i<m_n;i++) {
    	      for( int j=0;j<m_n;j++)
    		cout << *(array[i]+j)<<""\t"";
    	      cout << endl;
    	    }
    	    cout << "" final matrix""<<endl;;
    	    for( int i=0;i<m_n;i++) {
    	      for( int j=0;j<m_n;j++)
    		cout << *(m_finalG[i]+j)<<""\t"";
    	      cout << endl;
    	    }
        }
          
        void output()
        {
    	if ( m_match == false )
    	{
    	    cout << ""-1"" <<endl;	
    //	    show();
    	    return;
    	}
    	
    	if ( m_nrow == 0 && m_ncol == 0 )
    	{
    	    cout << m_ncol << endl;
    	    return;
    	}
    	cout <<  m_nrow << endl;
    	for ( int i=0; i< m_row.size() ; i++)
    	  cout << m_row.at(i) << endl;
    	
    	cout << m_ncol << endl;
    	for (int i=0;i<m_col.size(); i++)
    	    cout << m_col.at(i) << endl;
        }
        
        
    };
    
    int main() 
    {
    //    freopen(""out.out"", ""wt"", stdout);
        int testCases=0;
        scanf(""%d"" , &testCases);
        
        vector<Grid*> vG;
        for (int i=0;i<testCases;i++)
        {
    	int n;
    	scanf(""%d"" , &n);
    	Grid *g = new Grid(n);
    	vG.push_back(g);
    	g->evaluate2(g->m_g);	
        }
        
        for ( int i=0;i<vG.size();i++)
        {
    	Grid *gr = vG.at(i);
    //	cout << ""test case"" << i+1 << endl;
    	gr->output();
        }
        return 0;
    }
    

",C++
11109132,"
    #include<iostream>
    using namespace std;
    
    class test
    {
    	int n;
    	public:
    		void getdata()
    		{
    			cin>>n;
    		}
    		void clac()
    		{
    			int i,temp,flag=1;
    			for(i=0;i<n;i++)
    			{
    				cin>>temp;
    				if(temp%2!=0)
    				    flag=0;
    			}
    			if(flag==1)
    			    cout<<""2\n"";
    			else
    			    cout<<""1\n"";    
    			
    		}
    };
    
    int main()
    {
    	test t1;
    	int z;
    	cin>>z;
    	while(z>0)
    	{
    		t1.getdata();
    		t1.clac();
    		z--;
    	}
    	return 0;
    }

",C++
8846402,"
    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    long gcd(long a,long b){
        if(b==0)
            return a;
        else
            return gcd(b,a%b);
    }
    
    int main(){
        int t;
        cin>>t;
        while(t--){
            int n;
            cin>>n;
            vector<long> a(n);
            for(int i=0;i<n;i++)
                cin>>a[i];
            long g=gcd(a[0],a[1]);
            for(int i=2;i<n;i++)
                g=gcd(g,a[i]);
            cout<<g<<endl;
        }
        return 0;
    }
    

",C++
4418352,"
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
        int *a, n, m, i, j, *b, sum, k;
        
        scanf(""%d"", &m);
        b = malloc(sizeof(int)*m);
    
        for(i=0;i<m;++i)
        {
        	sum=0;
            scanf(""%d"", &n);
            
            a= malloc(sizeof(int)*n);
    
            for(j=0;j<n;++j)
            {
                            scanf(""%d"", &a[j]);
            }
            if (n==1)
            {
            	b[i]=a[0];
            	break;
            }
            for(k=0; k<n; ++k)
            {
                    if(a[k]%2!=0)
                    sum= sum+1;
            }
            if (sum==0)
            b[i]=2;
            else
            b[i]=1;
        }
    
    
        for(i=0;i<m;++i)
        {
                           printf(""%d \n"", b[i]);
         }
    
        return 0;
    }

",C
3463012,"
    #include<iostream>
    using namespace std;
    int main(){
    long int n;
    int t,i,a[1000];
    cin>>t;
    while(t--)
    {cin>>n;
    cout<<endl;
    for(i=0;i<n;i++)
    cin>>a[i];
    for(i=0;i<n;i++)
    {
    if(a[i]%2==0){
    cout<<2<<endl;break;}
    else{
    cout<<1<<endl;break;}
    }
    }
    return 0;
    }
    

",C++
2897331,"
    #include<stdio.h>
    int scan()
    {
    	int n=0;
    	int ch = getchar_unlocked();
    	while(ch<'0'||ch>'9')
    		ch=getchar_unlocked();
    	while(ch>='0'&&ch<='9')
    	{
    		n=(n*10)+ch-'0';
    		ch=getchar_unlocked();
    	}
    	return n;
    }
    int gcd(int a,int b)
    {
    	if(b==0)
    		return a;
    	else
    		 return gcd(b,a%b);
    }
    int main()
    {
    	int t,n,i;
    	t=scan();
    	//printf("" %d"",t);
    	while(t--)
    	{
    		n=scan();
    		int a = scan();
    		int b = scan();
    		int ans = gcd(a,b);
    		//printf(""%d "",ans);
    		for(i=0;i<n-2;i++)
    			ans = gcd(ans,scan());
    		printf(""%d\n"",ans);
    	}
    }
    

",C
6559446,"
    #include <iostream>
    #include<cstdio>
    using namespace std;
    
    
    int main() {
    	// your code goes here
        int t;
        cin >> t;
        while(t--)
        {
            long int n;
            cin >> n;
            long int res = (n*(n+1))/2;
            res = res+n;
            cout << res << endl;
                
        }
    	return 0;
    }
    

",C++
5205892,"
    #include<stdio.h>
    #include<iostream>
    #include<stdlib.h>
    #include<math.h>
    #include<string>
    #include<cstring>
    #include<vector>
    #include<algorithm>
    #include<stack>
    #include<map>
    #define scan_i(a) scanf(""%d"",&a)
    #define scan_c(c) scanf(""%c"",&c)
    #define scan_l(l) scanf(""%ld"",&l)
    #define scan_ll(ll) scanf(""%lls"",&ll)
    #define scan_s(s) scanf(""%s"",s)
    #define ll long long int
    #define print_i(a) printf(""%d"",a)
    #define print_c(c) printf(""%c"",c)
    #define print_l(l) printf(""%ld"",l)
    #define print_ll(ll) printf(""%lld"",ll)
    #define MOD_LP 1000000007		//LP is largest prime for int
    #define pair<int,int> ip
    #define FOR(l,h) for(int i=l;i<h;i++)
    using namespace std;
    int main()
    {
    int t,n;
    long result;
    scanf(""%d"",&t);
    while(t--)
    {
    cin>>n;
    result=2*n+(n*n)/2-((n/2)*(n/2+1))/2;
    cout<<result<<endl;
    }
    
    
    return 0;
    }

",C++
5197017,"
    #include<stdio.h>
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		long long int n;
    		long long int ans;
    		scanf(""%d"",&n);
    		ans=(n*n+3*n)/2;
    		printf(""%lld\n"",ans);
    	}
    	return 0; 
    }

",C
11191236,"
    #include<bits/stdc++.h>
    
    using namespace std;
    
    
    int main()
    {
        int t;
        cin>>t;
    
        while(t--)
        {
            int m,n,k1,k2,i,j;
            cin>>n>>m>>k1>>k2;
            int l=m*n;
            int pre[l]={0};
            int a[n][m];
            for(i=0;i<n;i++)
            {
                for(j=0;j<m;j++)
                {
                    cin>>a[i][j];
                    if(a[i][j]==1)
                    {
                        int lol=m*i+j;
                        pre[lol]=1;
                    }
                }
            }
            if(m==1)
                cout<<""-1\n"";
    
            int visitedq1[l]={0};
            int visitedq2[l]={0};
            queue < pair<int,int> > q1,q2;
            pair<int,int> c;
            q1.push(make_pair(0,0));
            q2.push(make_pair(m-1,0));
            visitedq1[0]=1;
            visitedq2[m-1]=1;
            int m1=0;
            int loop1=0;
            int loop2=0;
            int loop3=0;
            int flag=0;
            int z;
            while(1)
            {
                //loop1=0;
                while(1)
                {
                    if(q2.empty())
                    {
                        loop3=1;
                        break;
                    }
                    //cout<<""adarsh\n"";
                    c=q2.front();
                    if(c.second==m1+1)
                        break;
                    else
                    {
                        int p=c.first;
                        //cout<<p<<endl;
                        for(i=0;i<=k2;i++)
                        {
                            for(j=0;j<=k2;j++)
                            {
                                if(i+j<=k2 && i+j>0)
                                {
                                    for(z=0;z<4;z++)
                                    {
                                        int x1=p/m;
                                        int y1=p%m;
                                        int point,fuck1,fuck2;
                                        if(z==0)
                                            {
                                                point =(x1+i)*m+(y1+j);
                                                fuck1=x1+i;
                                                fuck2=y1+j;
                                            }
                                        else if(z==1)
                                            {
                                                point =(x1-i)*m+(y1+j);
                                                fuck1=x1-i;
                                                fuck2=y1+j;
                                            }
                                        else if(z==2)
                                            {
                                                point =(x1+i)*m+(y1-j);
                                                fuck1=x1+i;
                                                fuck2=y1-j;
                                            }
                                        else if(z==3)
                                            {
                                                point =(x1-i)*m+(y1-j);
                                                fuck1=x1-i;
                                                fuck2=y1-j;
                                            }
                                        //cout<<""a""<<point<<endl;
                                        if(fuck1>=n || fuck1<0)
                                            continue;
                                        if(fuck2>=m || fuck2<0)
                                            continue;
                                        //cout<<""b""<<point<<endl;
                                        if(pre[point]==1)
                                            continue;
                                        if(visitedq1[point]==1)
                                        {
                                            loop1=1;
                                            //m1++;
                                            //cout<<""b""<<point<<"" "";
                                            break;
                                        }
    
                                       if(visitedq2[point]==0)
                                       {
                                           q2.push(make_pair(point,m1+1));
                                           //cout<<""b""<<point<<"" "";
                                            visitedq2[point]=1;
                                       }
                                    }
                                }
                            }
                            if(loop1==1)
                                break;
                        }
                        q2.pop();
                    }
                    if(loop1==1)
                        break;
                }
                if(loop1==1)
                        break;
                //q1 traversal
                while(1)
                {
                    if(q1.empty())
                    {
                        loop2=1;
                        break;
                    }
                    c=q1.front();
                    if(c.second==m1+1)
                        break;
                    else
                    {
                        int p=c.first;
                        for(i=0;i<=k1;i++)
                        {
                            for(j=0;j<=k1;j++)
                            {
                                if(i+j<=k1 && i+j>0)
                                {
                                    for(z=0;z<4;z++)
                                    {
                                        int x1=p/m;
                                        int y1=p%m;
                                        int point,fuck1,fuck2;
                                        if(z==0)
                                            {
                                                point =(x1+i)*m+(y1+j);
                                                fuck1=x1+i;
                                                fuck2=y1+j;
                                            }
                                        else if(z==1)
                                            {
                                                point =(x1-i)*m+(y1+j);
                                                fuck1=x1-i;
                                                fuck2=y1+j;
                                            }
                                        else if(z==2)
                                            {
                                                point =(x1+i)*m+(y1-j);
                                                fuck1=x1+i;
                                                fuck2=y1-j;
                                            }
                                        else if(z==3)
                                            {
                                                point =(x1-i)*m+(y1-j);
                                                fuck1=x1-i;
                                                fuck2=y1-j;
                                            }
                                        //cout<<""a""<<point<<endl;
                                        if(fuck1>=n || fuck1<0)
                                            continue;
                                        if(fuck2>=m || fuck2<0)
                                            continue;
                                        if(pre[point]==1)
                                            continue;
                                        if(visitedq2[point]==1)
                                        {
                                            loop1=1;
                                            //m1++;
                                            //cout<<""a""<<point<<"" "";
                                            break;
                                        }
                                        if(visitedq1[point]==0)
                                       {
                                           q1.push(make_pair(point,m1+1));
                                           //cout<<""a""<<point<<"" "";
                                            visitedq1[point]=1;
                                       }
                                    }
                                }
                            }
                            if(loop1==1)
                                break;
                        }
                        q1.pop();
                    }
                    if(loop1==1)
                        break;
                }
                // q2 traversal
                //loop1=0;
                //cout<<endl;
    
                if(loop1==1)
                        break;
                //cout<<""loop1 ""<<loop1<<""loop2 ""<<loop2<<""loop3 ""<<loop3<<""\n"";
                if(loop2==1 && loop3==1)
                {
                    flag=1;
                    break;
                }
                m1++;
                //cout<<endl;
            }
            //cout<<""flag ""<<flag<<""\n"";
            m1++;
        if(flag==1)
            cout<<""-1\n"";
        else
            cout<<m1<<""\n"";
        }
        return 0;
    }
    

",C++
11693522,"
    #include <bits/stdc++.h>
    #define mod 1000000007
    #define gtx getchar_unlocked
    #define ptx putchar_unlocked
    using namespace std;
    
    inline long long int getint(){
        char cod;
        long long int xod=0;
        cod=gtx();
        while (cod<=' '){cod=gtx();}
        while (cod>='0'){ xod=10*xod+(cod-'0'); cod=gtx();}
        return xod;
    }
    
    inline void outint(long long int xod){
        char sdfga[16];
        long long int iod=0;
        if (xod==0){ ptx('0');}
        else{
        while (xod>0){ sdfga[iod++]=(xod%10)+'0'; xod=xod/10; }
        while (iod) ptx(sdfga[--iod]); }
        ptx('\n');
    }
    int main()
    {
        ios_base::sync_with_stdio ( false );
        long long int t,n,i;t=getint();
        while(t--)
        {
              n=getint();long long int a,b;a=getint();long long int ans=a;
              for(i=1;i<n;i++)
              {
                  b=getint();if(b>a){ans+=b-a;}
                  a=b;
              }
              outint(ans);
        }
    
        return 0;
    }
    
    

",C++
8239603,"
    #include <bits/stdc++.h>
    using namespace std;
    #define ll long long int 
    int main() 
    {
    	long int t;
    	scanf(""%ld"",&t);
    	while(t--)
    	{
    	    ll n,x,m,ans=0;
    	    scanf(""%lld"",&n);
    	    n--;
    	    scanf(""%lld"",&x);
    	    m=x;
    	    ans = x;
    	    while(n--)
    	    {
    	     scanf(""%lld"",&x);
    	     if(x>m)
    	     {
    	         ans = ans + (x-m);
    	         m = x;
    	     }  
    	    }
    	    printf(""%lld\n"",ans);
    	}
    	return 0;
    }
    

",C++
7255798,"
    #include <cstdio>
    using namespace std;
    
    bool A[100001];
    
    int main()
    {
    	int T, N, x, cnt;
    	scanf(""%d"", &T);
    	while( T-- )
    	{
    		for(int i=0; i<100001; i++) A[i]=false;
    		scanf(""%d"", &N);
    		cnt=0;
    		while( N-- )
    		{
    			scanf(""%d"", &x);
    			if(!A[x])cnt++;
    			A[x]=true;
    		}
    		printf(""%d\n"", cnt);
    	}
    	return 0;
    }

",C++
7253891,"
    #include <stdio.h>
    #include <math.h>
    
    int main(void) {
    	long int T,a,b,i,j,h;
    	scanf(""%ld"",&T);
    	for(i=0;i<T;i++)
    	{
    	    scanf(""%ld %ld"",&a,&b);
    	    if(a<b) { j=a; a=b;b=j;}
    	   h= (long int)(log(a)/log(2))-(long int)((log(b)/log(2)));
    	   a=a/(long int)(pow(2.0,h));
    	   j=0;
    	   while(1)
    	   {
    	       if(a/(long int)pow(2.0,j)==b/(long int)pow(2.0,j)) break;
    	       j++;
    	   }
    	   printf(""%ld\n"",h+2*j);
    	   
    	    
    	}
    	return 0;
    }
    

",C
10782006,"
    typedef long long ll;
    #include <iostream>
    #include <stdio.h>
    #include <cmath>
    #include <algorithm>
    #include <vector>
    #include <string>
    #include <string.h>
    #include <map>
    #include <queue>
    #include <stack>
    #include <sstream>
    #include <fstream>
    #include <stdlib.h>
    #include <utility>
    #define pb push_back
    #define mp make_pair
    #define pll pair<ll,ll> 
    #define plll pair<ll,pair<ll,ll> >
    
    using namespace std;
    ll mod=1000000007,fact[100007];
    void EE(ll a,ll b,ll& x,ll& y)
    {
        if(a%b==0)
        {
            x=0;
            y=1;
            return;
        }
        EE(b,a%b,x,y);
        ll temp=x;
        x=y;
        y=temp-y*(a/b);
    }
    ll inverse(ll a,ll m)
    {
        ll x,y;
        EE(a,m,x,y);
        if(x<0) 
        x += m;
        return x;
    }
    int main()
    {
        ll i,res,sum,c,n,k,x,t;
        fact[0]=1;
        for(i=1;i<=100000;i++)
        fact[i]=(fact[i-1]*i)%mod;
        scanf(""%lld"",&t);
        while(t--)
        {
            scanf(""%lld %lld"",&n,&k);
            c=0;
            for(i=1;i<=n;i++)
            {
                scanf(""%lld"",&x);
                if(x==0)
                c++;
            }
            res=0;
            for(i=0;i<=min(n,k);i++)
            {
                if(c || (k-i)%2==0)
                {
                    sum=fact[n];
                    sum*=inverse(fact[i],mod);
                    sum%=mod;
                    sum*=inverse(fact[n-i],mod);
                    sum%=mod;
                    res+=sum;
                    res%=mod;
                }
            }
            printf(""%lld\n"",res);
        }
    	return 0;
    }

",C++
10521127,"
    #include <bits/stdc++.h>
    using namespace std;
    
    typedef pair<long long,long long> ii;
    typedef pair<ii,long long> pii;
    typedef vector<long long> vi;
    typedef vector<ii> vii;
    typedef vector<pii> vpii;
    typedef long long ll;
    typedef unsigned long long ull;
    
    #define mi 1000000007
    #define rep(i,a,b) for(i=a;i<b;i++)
    #define repv(i,a,b) for(i=a;i>b;i--)
    #define inf INT_MAX
    #define pb push_back
    #define mp make_pair
    #define fi first
    #define se second
    #define let(x,a) __typeof(a) x(a)
    #define all(a) (a).begin(),(a).end() 
    #define endl '\n'
    #define present(c,x) ((c).find(x) != (c).end()) 
    #define tr(v,it) for(let(it,v.begin()); it != v.end(); it++)
    #define rtr(v,it) for(let(it,v.rbegin()); it != v.rend(); it++)
    #define SET(a,b) memset(a,b,sizeof(a))
    #define si(n) scanf(""%d"",&n)
    #define dout(n) printf(""%d\n"",n)
    #define sll(n) scanf(""%lld"",&n)
    #define lldout(n) printf(""%lld\n"",n)
    
    #define trace1(x)                cerr << #x << "": "" << x << endl;
    #define trace2(x, y)             cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << endl;
    #define trace3(x, y, z)          cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << "" | "" << #z << "": "" << z << endl;
    #define trace4(a, b, c, d)       cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << endl;
    #define trace5(a, b, c, d, e)    cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << "" | "" << #e << "": "" << e << endl;
    #define trace6(a, b, c, d, e, f) cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << "" | "" << #e << "": "" << e << "" | "" << #f << "": "" << f << endl;
    
    long long mult(long long x,long long y)
    {
    	ll ans,x1=(ll)x,y1=(ll)y;
    	ans=((x1%mi )*(y1%mi))%mi;
    	return (long long)ans;
    }
    long long gcd(long long a,long long b) { return b==0 ? a : gcd (b,a%b);}
    long long lcm(long long a,long long b) { return a*(b/gcd(a,b));}
    
    long long pow1(long long a,long long b)
    {
    	long long ans=1;
    	while(b>0)
    	{
    		if(b&1) ans=mult(ans,a);  
    		a=mult(a,a); b>>=1;
    	} 
    	return ans;
    }
    long long mina(long long arr[],long long n)
    {
    	long long x=arr[0],i,pos=0;
    	rep(i,1,n){ if(arr[i]<x) { x=arr[i]; pos=i; } }
    	return x;
    }
    long long maxa(long long arr[],long long n)
    {
    	long long x=arr[0],i,pos=0;
    	rep(i,1,n){ if(arr[i]>x) { x=arr[i]; pos=i; } }
    	return x;
    }
    
    long long arr[100005], fact[100005];
    int main()
    {
    	long long t;
    	cin>>t;
    	fact[0]=1;
    	for(long long i=1; i<100005; i++)
    	{
    		fact[i]=((fact[i-1]%mi) * (i%mi))%mi;
    	}
    	while(t--)
    	{
    		long long zero=0;
    		long long n, k;
    		cin>>n>>k;
    		for(long long i=0; i<n ; i++)
    		{
    			cin>>arr[i];
    			if(arr[i]==0)
    				zero++;
    		}
    		n-=zero;
    		long long ans=0;
    		if(zero==0)
    		for(long long i=k; i>=0; i-=2)
    		{
    			if(i<=n)
    			{
    				
    				long long num=fact[n];
    				long long deno=((fact[n-i])%mi *(fact[i])%mi)%mi;	
    				long long temp=((num%mi)*(pow1(deno, mi-2)%mi))%mi;
    				ans=(ans%mi + temp%mi)%mi;
    			}
    		}
    		else
    		for(long long i=k; i>=0; i-=1)
    		{
    			if(i<=n)
    			{
    				
    				long long num=fact[n];
    				long long deno=((fact[n-i])%mi *(fact[i])%mi)%mi;	
    				long long temp=((num%mi)*(pow1(deno, mi-2)%mi))%mi;
    				ans=(ans%mi + temp%mi)%mi;
    			}
    		}
    
    		cout<<ans<<endl;
    	}
    	return 0;
    }

",C++
10516415,"
    #include<iostream>
    using namespace std;
    #define PRIME 1000000009
     
    long long int modinv(int x)
    {
    	long long int a=PRIME,b=x;
    	long long int a1=1,a2=0,b1=0,b2=1;
    	while(b!=0)
    	{
    		long long int t1=b1,t2=b2,t=b;
    		b1 = a1-(a/b)*b1;
    		b2 = a2-(a/b)*b2;
    		a1=t1;
    		a2=t2;
    		b=a%b;
    		a=t;
    	}
    	return ((a2)%PRIME+PRIME)%PRIME;
    }
     
    int main()
    {
    	long long int N,K,arr[100000],num_zero,sum,T,nCk;
    	cin>>T;
    	while(T--)
    	{
    		num_zero = 0;
    		cin>>N>>K;
    		for(int i=0;i<N;i++)
    		{
    			cin>>arr[i];
    			if(arr[i]==0)
    				num_zero++;
    		}
    		if(num_zero>0)
    		{
    			if(K>N-num_zero)
    				K=N-num_zero;
    			
    			nCk=1;sum=1;
    			for(long long int i=1;i<=K;i++)
    			{
    				nCk = (nCk*(((N-num_zero-i+1)*modinv(i))%PRIME))%PRIME;
    				sum = (sum+nCk)%PRIME;
    			}
    		}
    		if(num_zero==0)
    		{
    			long long int start;
    			if(K>N)
    				K = N-(K-N)%2;
    			if(K%2==0)
    			{
    				nCk=sum=1;
    				start = 0;
    			}
    			else
    			{
    				nCk=sum=N;
    				start = 1;
    			}
    			for(long long int i=start+2;i<=K;i+=2)
    			{
    				nCk = ((((((nCk)*(((N-i+1)*modinv(i))%PRIME))%PRIME)*(N-i+2))%PRIME)*(modinv(i-1)))%PRIME;
    				sum = (sum+nCk)%PRIME;
    			}		
    		}
    		cout<<sum<<endl;
    	}	
    	return 0;
    }  

",C++
7937472,"
    #include <bits/stdc++.h>
     
    using namespace std;
     
    int main()
    {
        char  sides[6][400];
        bool check = false;
     
        int T;
        scanf(""%d"",&T);
     
        while(T--)
        {
            for(int i = 0; i < 6; i++)
            scanf(""%s"",sides[i]);
     
            for(int i = 0; i < 6; i++)
            {
                if(strcmp(sides[0],sides[2]) == 0 && strcmp(sides[0],sides[4]) == 0){check = true; break;}   
                if(strcmp(sides[0],sides[2]) == 0 && strcmp(sides[0],sides[5]) == 0){check = true; break;}
                if(strcmp(sides[0],sides[3]) == 0 && strcmp(sides[0],sides[4]) == 0){check = true; break;}
                if(strcmp(sides[0],sides[3]) == 0 && strcmp(sides[0],sides[5]) == 0){check = true; break;}
                if(strcmp(sides[1],sides[2]) == 0 && strcmp(sides[1],sides[4]) == 0){check = true; break;}
                if(strcmp(sides[1],sides[3]) == 0 && strcmp(sides[1],sides[4]) == 0){check = true; break;}
                if(strcmp(sides[1],sides[2]) == 0 && strcmp(sides[1],sides[5]) == 0){check = true; break;}
                if(strcmp(sides[1],sides[3]) == 0 && strcmp(sides[1],sides[5]) == 0){check = true; break;}
            }
     
            (check == true) ? printf(""YES\n"") : printf(""NO\n"");
        }
     
        return 0;
    }
    

",C++
5640653,"
    #include<bits/stdc++.h>
    using namespace std;
    const int nmax=105;
    int a[nmax];
    int dp[nmax][nmax];
    typedef long long ll;
    const int md=1e9+7;
    int main() {
        int n;
        scanf(""%d"",&n);
        for(int i=1;i<=n;i++) {
            scanf(""%d"",&a[i]);
        }
        for(int i=1;i<=n;i++) {
            dp[i+1][i]=1;
        }
        for(int len=1;len<=n;len++) {
            for(int i=1;i<=n-len+1;i++) {
                int j=i+len-1;
                dp[i][j]+=dp[i+1][j];
                if(a[i]<0) {
                    for(int k=i+1;k<=j;k++) {
                        if(a[k]==-a[i]) {
                            int x=ll(dp[i+1][k-1])*dp[k+1][j]%md;
                            dp[i][j]+=x;
                            if(dp[i][j]>=md) dp[i][j]-=md;
                        }
                    }
                }
            }
        }
        printf(""%d\012"",dp[1][n]);
        return 0;
    }
    

",C++
5614206,"
    #include<iostream>
    #include<cstdio>
    using namespace std;
    #define MOD 1000000007
    int dp[105][105]={0};
    int main()
    {
        int n,i,j,c,k;
        int a[105];
        scanf(""%d"",&n);
        for(i=0; i<n; i++)
            scanf(""%d"",&a[i]);
        for(c=2; c<=n ; c++)
        {
            for(i=0; i<(n-c+1); i++)
            {
                j=i+c-1;
                dp[i][j]=(dp[i][j-1])%MOD;
                for(k=i; k<=j-1; k++)
                {
                    if(a[k]<0 && a[j]+a[k]==0 && a[j]>0)
                        dp[i][j]=((dp[i][j]%MOD)+((dp[i][k-1]+1)%MOD)*1LL*((dp[k+1][j-1]+1)%MOD))%MOD;
                }
            }
        }
        printf(""%d\n"",(dp[0][n-1]+1)%MOD);
        return 0;
    }
    

",C++
5611485,"
    #include<iostream>
    using namespace std;
    #define mod 1000000007
    int main()
    {
        int n;
        cin>>n;
        int arr[n];
        int dp[102][102];
        for(int i=0;i<n;i++)
            cin>>arr[i];
    
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
             dp[i][j]=0;
        }
        int j;
        for(int l=2;l<=n;l++){
            for(int i=0;i+l-1<n;i++){
                  j=i+l-1;
                  dp[i][j]=dp[i][j-1];
                for(int k=i;k<j;k++){
                  // cout<<l<<"" ""<<k;
                    if(arr[j]>0&&(-1*arr[j])==arr[k]){
    
                        long long n=dp[i][k-1]+1;
                        long long m=dp[k+1][j-1]+1;
                        dp[i][j]=(dp[i][j]+(n*m)%mod)%mod;
                    }
    
                }
    
            }
            }
    /*for(int i=0;i<n;i++){
        for(int j=0;j+i<n;j++)
            cout<<(dp[j][j+i]+1)%mod<<"" "";
            cout<<""\n"";
            }*/
    
    cout<<(dp[0][n-1]+1)%mod;
    }
    //33 2424 2
    

",C++
11901803,"
    #include<stdio.h>
    int main()
    {
      int n,i,t,count;
      arr[101]={0};
      scanf(""%d"",&t);
      while(t--)
      {
        scanf(""%d"",&n);
        int ar[n];
        count=0;
        for(i=0;i<n;i++)
           { 
             scanf(""%d"",&ar[i]);
             arr[ar[i]]=1;
           }
        for(i=0;i<101;i++)
          {
            if(arr[i]==1)
             {
               count++;
             }
          }
        printf(""%d\n"",count);
      }       
     return 0;
    }

",C
11786902,"
    #include ""string.h""
    int main(int argc, char *argv[])
    {
    	int T, i, j, n, party_day[101], day, sum;
    	scanf(""%d"", &T);
    	for (i = 0; i < T; i++)
    	{
    		scanf(""%d"", &n);
    		memset(party_day,0, sizeof(party_day));
    		for (j = 0; j < n; j++)
    		{
    			scanf(""%d"", &day);
    			party_day[day] = 1;
    		}
    		sum = 0;
    		for (j = 1; j < 101; j++)
    		{
    			sum += party_day[j];
    		}
    		printf(""%d\n"", sum);
    	}
    	return 0;
    }

",C
11705649,"
    #include<stdio.h>
    #include<string.h>
    
    int main()
    {
      int t,n,i,j,count;
      int a[55];
    
      scanf(""%d"",&t);
    
      while(t--)
      {
        
         scanf(""%d"",&n);
    
         for(i=0;i<n;i++)
         {
           scanf(""%d"",&a[i]);
         }
    
         count=n;
    
         for(i=0;i<n;i++)
         {
              for(j=i+1;j<n;j++)
              {
                if(a[i]==a[j])
                {
                   count--;
                   break;
                }
              }
         }
    
         printf(""%d\n"",count);
       }
       return 0;
    }
    

",C
11641807,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    
    main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int n;
            cin>>n;
            int a[n];
            for(int i=0; i<n; i++)
            {
                cin>>a[i];
            }
            sort(a,a+n);
        int count=1;
            for(int i=1; i<n; i++)
            {
            if(a[i]!=a[i-1]) ++count;
            }
            cout<<count<<endl;
        }
        return 0;
    }
    

",C++
7020525,"
    import java.util.Scanner;
    class Cfrtest {
    	
    	public static void main(String args[])
    	{
             Scanner br = new Scanner(System.in);
    	  int t=br.nextInt();
    	
    	while((t--)>0)
    		
    	{
    		int count=0;
    		int n=br.nextInt();
    		
    		int[] a= new int[100];
    		
    		for(int i=0;i<n;i++)
    		{
    			a[br.nextInt()]++;
    			
    		}
    			
    		for(int i=0;i<100;i++)
    		{
    			if(a[i]!=0)
    			{
    				count++;
    			}
    			}
    		System.out.println(count);
    		
    	}		
    			
    
    	
    }
     
    }

",JAVA
7020439,"
    import java.util.Scanner;
    class Cfrtest {
    	
    	public static void main(String args[])
    	{
        Scanner br = new Scanner(System.in);
    	int count=0;
    	
    	int t=br.nextInt();
    	
    	while((t--)>0)
    		
    	{
    		
    		int n=br.nextInt();
    		
    		int[] a= new int[n];
    		int[] b= new int[100];
    		for(int i=0;i<n;i++)
    		{
    			a[i]=br.nextInt();
    			int temp=a[i];
    			
    			for(int j=0;j<n;j++)
    			{
    				if(temp==a[j])
    				{
    					b[temp]=b[temp]+1;
    				}
    			}
    		}
    			
    		for(int i=0;i<100;i++)
    		{
    			if(b[i]!=0)
    			{
    				count++;
    			}
    			}
    		System.out.println(count);
    		count=0;
    	}		
    			
    
    	
    }
     
    }
    

",JAVA
3014360,"
    #include<iostream>
    #include<vector>
    #include<set>
    #include<map>
    #include<queue>
    #include<deque>
    #include<stack>
    #include<list>
    #include<complex>
    #include<string>
    #include<utility>
    #include<numeric>
    #include<iterator>
    #include<algorithm>
    #include<cstdio>
    #include<cstdlib>
    #include<cmath>
    #include<cctype>
    #include<climits>
    #include<ctime>
    #include<cstring>
    
    #define ALL(c)  c.begin(), c.end()
    #define TR(c, it)   for(typeof(c.begin()) it = c.begin(); it != c.end(); it++)
    #define FOR(i, j, n)  for(int (i) = (j); i < n; i++)
    #define MAX(a, b)   ((a) > (b) ? (a) : (b))
    #define gc  getchar_unlocked
    #define ll long long int
    #define ull unsigned long long int
    #define inf INT_MAX
    #define mininf INT_MIN
    #define pb push_back
    #define mp  make_pair
    #define time   QueryPerformanceCounter
    #define qp  QuadPart
    #define LI LARGE_INTEGER
    #define PI  3.14159265358979323846264338327950288
    
    using namespace std;
    
    inline void ifast(int &x)
    {
        register int c = gc();
        x = 0;
        int neg = 0;
        for(; ((c<48 || c>57) && c != '-'); c = gc());
        if(c=='-')
        {
            neg = 1;
            c = gc();
        }
        for(; c>47 && c<58 ; c = gc())
        {
            x = (x<<1) + (x<<3) + c - 48;
        }
        if(neg)
            x = -x;
    }
    
    int main()
    {
        int t;
        scanf(""%d"", &t);
        while(t--)
        {
            int k;
    //        scanf(""%d"", &k);
            ifast(k);
            ll ans = 0;
            FOR(i, 0, k)
            {
                int n;
    //            scanf(""%d"", &n);
                ifast(n);
                vector<int> arr(n);
                FOR(i, 0, n)
                    ifast(arr[i]);
    //                scanf(""%d"", &arr[i]);
                sort(ALL(arr));
                arr.erase(unique(ALL(arr)), arr.end());
                ll value = (1LL << 50);
                ll res = ((arr[0] & 1) == 0) ? value : -value;
                int sz = arr.size();
                bool change = false;
                FOR(i, 1, sz)
                {
                    if((arr[i] & 1) != (arr[i-1] & 1))
                        change = true;
                    if(change)
                        value >>= 1;
                    res += ((arr[i] & 1) == 0) ? value : -value;
                }
                ans += res;
            }
            if(ans > 0)
                printf(""EVEN\n"");
            else if(ans < 0)
                printf(""ODD\n"");
            else
                printf(""DON'T PLAY\n"");
        }
        return 0;
    }
    

",C++
9194195,"
    #include <stdio.h>
    
    int main(void) {
        int n,i,m,l,r,j,c,g;
        long int a[100005],d,p;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    	scanf(""%ld"",&a[i]);
    	scanf(""%d"",&m);
    	for(i=0;i<m;i++){
    	scanf(""%d "",&c);
    	if(c==1){
    	    scanf(""%d %d %ld"",&l,&r,&p);
    	   // printf(""%d %d %ld\n"",l,r,p);
    	    for(j=l-1;j<=r-1;j++){
    	        g=a[j]%p;
    	        if(g==0)
    	        a[j]=a[j]/p;
    	    }
    	    
    	}
    	else{
    	    scanf(""%d %ld"",&l,&d);
    	   // printf(""%d %ld\n"",l,d);
    	    a[l-1]=d;
    	    
    	}}
    	for(i=0;i<n;i++)
    	printf(""%ld "",a[i]);
    	
    	return 0;
    }
    

",C
10815761,"
    #include<cstdio>
    #include<cstring>
    #include<iostream>
    #include<vector>
    #include<stack>
    #include<climits>
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        int t;
        scanf(""%d"",&t);
        while(t--)
        {
            int n;
            scanf(""%d"",&n);
            string  a;long long b[n];
            cin.ignore();
            cin>>a;
            for(int i=0;i<n;i++)
            scanf(""%lld"",&b[i]);
            long long  d=0,dist=0;
            for(int i=0;i<n;i++)
            {
                if(a[i]=='0')
                {
                    dist+=b[i]-d;d=b[i];
                }
                if(a[i]=='1')
                {
                    d=b[i];
                }
            }
            printf(""%lld\n"",dist);
        }
        return 0;
    }
    

",C++
10915620,"
    n = int(raw_input())
    t=0
    if n<28:
        for i in range(n):
            k = str(i)
            k = list(k)
            k = map(int,k)
            sumi = sum(k)
            p = str(sumi)
            p = list(p)
            p = map(int,p)
            sumi+=sum(p)+i
            if sumi==n:
                t+=1
    elif n<98:
        for i in range(n-27,n):
            k = str(i)
            k = list(k)
            k = map(int,k)
            sumi = sum(k)
            p = str(sumi)
            p = list(p)
            p = map(int,p)
            sumi+=sum(p)+i
            if sumi==n:
                t+=1
    else:
        for i in range(n-97,n):
            k = str(i)
            k = list(k)
            k = map(int,k)
            sumi = sum(k)
            p = str(sumi)
            p = list(p)
            p = map(int,p)
            sumi+=sum(p)+i
            if sumi==n:
                t+=1
    print t

",PYTH
8990182,"
    #include<iostream>
    #include<algorithm>
    #include<bitset>
    #include<cctype>
    #include<cmath>
    #include<complex>
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<ctime>
    #include<climits>
    #include<functional>
    #include<fstream>
    #include<istream>
    #include<iterator>
    #include<iomanip>
    #include<list>
    #include<map>
    #include<numeric>
    #include<queue>
    #include<set>
    #include<sstream>
    #include<stack>
    #include<string>
    #include<utility>
    #include<vector>
    
    
    using namespace std;
    
    #define FOR(i,a,b) for(LLI i=(a);i<(b);i++)
    #define RFOR(i,a,b) for(LLI i=(b-1);i>=(a);i--)
    #define FOREACH(i, c) for( __typeof( (c).begin() ) i = (c).begin(); i != (c).end(); ++i )
    #define REP(i,n) for(LLI i=0;i<(n);i++)
    #define RREP(i,n) for(LLI i=(n)-1;i>=0;i--)
    
    #define INF LLI_MAX/3
    #define PB push_back
    #define MP make_pair
    #define ALL(a) (a).begin(),(a).end()
    #define SET(a,c) memset(a,c,sizeof a)
    #define CLR(a) memset(a,0,sizeof a)
    #define PII pair<LLI,LLI>
    #define PCC pair<char,char>
    #define PIC pair<LLI,char>
    #define PCI pair<char,LLI>
    #define FST first
    #define SEC second
    #define VS vector<string>
    #define VI vector<LLI>
    #define DEBUG(x) cout<<#x<<"": ""<<x<<endl
    #define MIN(a,b) (a>b?b:a)
    #define MAX(a,b) (a>b?a:b)
    #define PI acos(-1.0)
    #define RADIANS(x) (((1.0 * x * PI) / 180.0))
    #define DEGREES(x) (((x * 180.0) / (1.0 * pi)))
    #define SINE(x) (sin(RADIANS(x)))
    #define COSINE(x) (cos(RADIANS(x)))
    #define SETBIT(x, i) (x |= (1 << i))
    #define TANGENT(x) (tan(RADIANS(x)))
    #define ARCSINE(x) (DEGREES((asin(x))))
    #define RESETBIT(x, i) (x &= (~(1 << i)))
    #define ARCCOSINE(x) (DEGREES((acos(x))))
    #define ARCTANGENT(x) (DEGREES((atan(x))))
    #define INFILE() freopen(""in0.txt"",""r"",stdin)
    #define OUTFILE()freopen(""out0.txt"",""w"",stdout)
    #define FASTIO ios_base::sync_with_stdio(0);cin.tie();
    #define IN scanf
    #define OUT prLLIf
    #define SI(a) scanf(""%d"",&a)
    #define SL(a) scanf(""%lld"",&a)
    #define SD(a) scanf(""%lf"",&a)
    #define OI(a) prLLIf(""%d"",a)
    #define OL(a) prLLIf(""%lld"",a)
    #define OD(a) prLLIf(""%lf"",a)
    #define LL long long
    #define ULL unsigned long long
    #define EPS 1e-9
    #define MOD 1000000007
    #define LIM 4
    
    //TYPE CONVERSION
    template<typename T>inline string toString(T a)
    {
        ostringstream os("""");
        os<<a;
        return os.str();
    }
    template<typename T>inline LL toLong(T a)
    {
        LL res;
        istringstream os(a);
        os>>res;
        return res;
    }
    //template<typename T>inline LLI toLLI(T a)
    //{
    //    LLI res;
    //    istringstream os(a);
    //    os>>res;
    //    return res;
    //}
    template<typename T>inline double toDouble(T a)
    {
        double res;
        istringstream os(a);
        os>>res;
        return res;
    }
    //MATHEMATICS
    template<typename T>inline T  SQ(T a)
    {
        return a*a;
    }
    template<typename T>inline T GCD(T a, T b)
    {
        if (b == 0)return a;
        else return GCD(b, a % b);
    }
    template<typename T>inline T LCM(T a, T b)
    {
        LL res=a*b;
        res/=GCD(a,b);
        return res;
    }
    template<typename T>inline ULL BIGMOD(T a, T b, T m)
    {
        if (b == 0)return 1;
        else if (b % 2 == 0)return SQ(BIGMOD(a, b / 2, m)) % m;
        else return (a % m*BIGMOD(a, b - 1, m)) % m;
    }
    template<typename T>inline VS PARSE(T str)
    {
        VS res;
        string s;
        istringstream os(str);
        while(os>>s)res.PB(s);
        return res;
    }
    template<typename T>inline ULL  DIST(T A,T B)
    {
        ULL res=(A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y);
        return res;
    }
    template<typename T>inline LL  CROSS(T A,T B,T C)
    {
        return (B.x-A.x)*(C.y-A.y)-(C.x-A.x)*(B.y-A.y);
    }
    template<typename T>inline double cosAngle(T a,T b,T c)
    {
        double res=a*a+b*b-c*c;
        res=res/(2*a*b);
        res=acos(res);
        return res;
    }
    //template<typename T>inline T POWER(T base,LLI po)
    //{
    //    T res=1;
    //    if(base==0)return 0;
    //    FOR(i,0,po)res*=base;
    //    return res;
    //}
    //BIT
    template<typename T>inline bool IS_ON(T mask,T pos)
    {
        return mask&(1<<pos);
    }
    //template<typename T>inline LLI OFF(T mask,T pos)
    //{
    //    return mask^(1<<pos);
    //}
    //template<typename T>inline LLI ON(T mask,T pos)
    //{
    //    return mask|(1<<pos);
    //}
    //MOVEMENT INSIDE GRID
    //template<typename T>inline bool INSIDE_GRID(LLI R,LLI C,LLI ro,LLI clm)
    //{
    //    if(R>=0&&C>=0&&R<ro&&C<clm)return 1;
    //    return 0;
    //}
    //template<typename T>inline void PRLLI_GRID(T GRID,LLI ro,LLI clm)
    //{
    //    DEBUG(GRID);
    //    FOR(i,0,ro)
    //    {
    //        FOR(j,0,clm)cout<<GRID[i][j]<<"" "";
    //        puts("""");
    //    }
    //}
    
    #define LLI long long
    string a,b;
    LLI A[1005][26];
    LLI B[1005][26];
    LLI KTH,LEN;
    LLI dp[1005][1005];
    LLI way[1005][1005];
    LLI high=1000000009;
    LLI f(LLI x, LLI y)
    {
    
        if(x>=LEN || y>=LEN)return 0;
    
        LLI &ret = dp[x][y];
        if(ret!=-1)return ret;
        ret = 0;
        if(a[x]==b[y])ret =  1+ f(x+1,y+1);
        else
        {
    
            ret = f(x+1,y);
            ret = max(ret, f(x,y+1));
    
        }
        return ret;
    }
    
    
    LLI solve(LLI x, LLI y , LLI baki)
    {
    
        if( baki==0 )
        {
            return 1;
        }
    
        LLI &ret = way[x][y];
        if(ret!=-1)return ret ;
    
        ret=0;
        for(LLI i=0; i<26; i++ )
        {
            LLI X = A[x][i ];
            LLI Y = B[y][i ];
            if(X<LEN && Y<LEN && baki == 1+f(X+1,Y+1)   )
            {
                ret += solve(X+1,Y+1,baki-1);
            }
    ret=min(ret,high);
    
        }
        return ret;
    }
    
    
    void path(LLI x, LLI y , LLI need , LLI baki)
    {
    
    
        if(baki==0)return ;
    
        for(LLI i=0; i<26; i++ )
        {
            LLI X = A[x][i ];
            LLI Y = B[y][i ];
            LL have=0 ;
            if(X<LEN && Y<LEN && baki == 1+f(X+1,Y+1)   ) have=solve(X+1,Y+1 , baki-1);
    
            if(have>=need)
            {
    
                cout<<char('a'+i);
                path(X+1,Y+1,need , baki-1);
                return ;
    
            }
            else
            {
                need-=have;
            }
    
        }
    
    }
    
    
    
    int main()
    {
        cin>>LEN>>KTH;
        cin>>a>>b;
    //    a="" ""+a;
    //    b="" ""+b;
        SET(dp,-1);
        LLI lcs=f(0,0);
    
        SET(way,-1);
    
    
    
        for(LLI j=0; j<26; j++)A[LEN+1][j]=LEN+1;
        for(LLI j=0; j<26; j++)B[LEN+1][j]=LEN+1;
    
    
        for(LLI i = LEN-1; i>=0; i-- )
        {
            for(LLI j=0; j<26; j++)A[i][j]=A[i+1][j];
            for(LLI j=0; j<26; j++)B[i][j]=B[i+1][j];
    
            A[i][a[i]-'a' ]=i;
            B[i][b[i]-'a' ]=i;
        }
    
    
        LL w = solve(0,0,lcs);
    
        if(KTH>w)cout<<-1<<endl;
        else
        {
    
            path(0,0,KTH,lcs);
            cout<<endl;
        }
    }
    
    //Comments
    

",C++
11068572,"
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    bool prime[100001];
    
    void preCompute() {
    	for(int i = 0; i < 100001; i++)
    		prime[i] = true;
    	prime[0] = prime[1] = false;
    	for(int i = 2; i < 317; i++) {
    		if(prime[i]) {
    			for(int j = i * i; j < 100001; j += i)
    				prime[j] = false;
    		}
    	}
    }
    
    int main(int argc, char const *argv[]) {
    	ios::sync_with_stdio(false);
    	preCompute();
    	int T;
    	cin >> T;
    	for(int i = 0; i < T; i++) {
    		int N, A[100000], ans = 0, count, max_count;
    		cin >> N;
    		for(int j = 0; j < N; j++)
    			cin >> A[j];
    		int max = *max_element(A, A + N);
    		for(int j = 2; j <= max; j++) {
    			if(prime[j]) {
    				max_count = 0;
    				for(int k = 0; k < N; k++) {
    					count = 0;
    					if(A[k] % j == 0) {
    						while(A[k] % j == 0) {
    							count++;
    							A[k] /= j;
    						}
    					}
    					if(count > max_count)
    						max_count = count;
    				}
    				ans += max_count;
    			}
    		}
    		cout << ans << endl;
    	}
    	return 0;
    }

",C++
8281709,"
    #include <iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
        std::ios::sync_with_stdio(false);
        int t; cin>>t;
       while(t--){
       int prime[]={2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997};
       int prime_cnt[170]={0};
       int n,j; cin>>n; int a[n];
       for(int i=0;i<n;i++){
        cin>>a[i];
        j=0;
        while(a[i]!=1){
                int cnt=0;
            while(a[i]%prime[j]==0 && j<=167){
                a[i]=a[i]/prime[j]; cnt++;}
                if(cnt >= prime_cnt[j])
                   prime_cnt[j]=cnt;
            j++;
        }
    
    
        }
       long long int sum=0;
       for(int i=0;i<170;i++)
        sum+=prime_cnt[i];
       cout<<sum<<endl;
    
    
    
     }
        return 0;
    }
    

",C++
10904693,"
    #include<bits/stdc++.h>
    using namespace std;
    bool visited[50][50];
    string ans[55][55];
    vector<pair<int,int> > nturn;
    vector<pair<int,int> > ntemp;
    struct node
    {
    	int x;
    	int y;
    };
    struct node capital;
    
    char A[55][55];
    int main()
    {
    	ios_base::sync_with_stdio(0);
    	int N,M;
    	char c;
    	cin >> N >> M;
    	for(int i = 1;i <= N;i++)
    	{
    		for(int j = 1;j <= M;j++)
    		{
    			cin >> c;
    			if(c == '*')
    				visited[i][j] = 1;
    			if(c == 'C')
    			{
    				capital.x = i;
    				capital.y = j;
    			}
    
    			A[i][j] = c;
    		}
    	}
    //	cout << capital.x << "" "" << capital.y << endl;
    	if(A[capital.x][capital.y - 1] == '.')
    	{
    		ans[capital.x][capital.y - 1] = ""R"";
    		visited[capital.x][capital.y - 1] = 1;
    		nturn.push_back(make_pair(capital.x,capital.y - 1) );
    	}
    	
    	if(A[capital.x][capital.y + 1] == '.')
    	{
    		ans[capital.x][capital.y + 1] = ""L"";
    		visited[capital.x][capital.y + 1] = 1;
    		nturn.push_back(make_pair(capital.x,capital.y + 1) );
    	}
    	
    	if(A[capital.x - 1][capital.y] == '.')
    	{
    		ans[capital.x - 1][capital.y] = ""D"";
    		visited[capital.x - 1][capital.y] = 1;
    		nturn.push_back(make_pair(capital.x - 1,capital.y) );
    	}
    
    	if(A[capital.x + 1][capital.y] == '.')
    	{
    		ans[capital.x + 1][capital.y] = ""U"";
    		visited[capital.x + 1][capital.y] = 1;
    		nturn.push_back(make_pair(capital.x + 1,capital.y) );
    	}
    //	cout << ans[2][4] << endl;
    //	cout << visited[2][4] << endl;
    //	cout << nturn .size(); 
    	while(1)
    	{
    		bool flag = 0;
    		int cache = nturn.size();
    		
    		for(int i = 0;i < cache;i++)
    		{
    				
    				int curr_x = nturn[i].first;
    				int curr_y = nturn[i].second;
    				
    				if(visited[curr_x][curr_y - 1] == 0 && A[curr_x][curr_y - 1] == '.')
    				{
    					visited[curr_x][curr_y - 1] = 1;
    					flag = 1;
    					ans[curr_x][curr_y - 1] = ""R"";
    					ans[curr_x][curr_y - 1].append(ans[curr_x][curr_y]);
    					ntemp.push_back(make_pair(curr_x,curr_y - 1) );
    				}
    							
    				if(visited[curr_x][curr_y + 1] == 0 && A[curr_x][curr_y + 1] == '.')
    				{
    					visited[curr_x][curr_y + 1] = 1;
    					flag = 1;
    					ans[curr_x][curr_y + 1] = ""L"";
    					ans[curr_x][curr_y + 1].append(ans[curr_x][curr_y]);
    					ntemp.push_back(make_pair(curr_x,curr_y + 1) );
    				}
    				
    				if(visited[curr_x - 1][curr_y] == 0 && A[curr_x - 1][curr_y] == '.')
    				{
    					visited[curr_x - 1][curr_y] = 1;
    					flag = 1;
    					ans[curr_x - 1][curr_y] = ""D"";
    					ans[curr_x - 1][curr_y].append(ans[curr_x][curr_y]);
    					ntemp.push_back(make_pair(curr_x - 1,curr_y) );
    				}
    
    				if(visited[curr_x + 1][curr_y] == 0 && A[curr_x + 1][curr_y] == '.')
    				{
    					visited[curr_x + 1][curr_y] = 1;
    					flag = 1;
    					ans[curr_x + 1][curr_y] = ""U"";
    					ans[curr_x + 1][curr_y].append(ans[curr_x][curr_y]);
    					ntemp.push_back(make_pair(curr_x + 1,curr_y) );
    				}
    		}
    			nturn.clear();
    			nturn = ntemp;
    			ntemp.clear();
    			if(flag == 0)
    				break;
    	}
    	int cnt = 0;
    //	cout << ans[2][4] << endl;
    	for(int i = 1;i <= N;i++)
    	{
    		for(int j = 1;j <= M;j++)
    		{
    			if(ans[i][j] != """")
    			{
    				int l = ans[i][j].length();
    				for(int k = 0;k < l;k++)
    				{
    					cout << ans[i][j][k];
    					cnt++;
    				}
    
    				for(int k = l - 1;k >= 0;k--)
    				{
    					if(ans[i][j][k] == 'L')
    						cout << ""R"",cnt++;
    					else if(ans[i][j][k] == 'R')
    						cout << ""L"",cnt++;
    					else if(ans[i][j][k] == 'D')
    						cout << ""U"",cnt++;
    					else if(ans[i][j][k] == 'U')
    						cout << ""D"",cnt++;
    				}
    			}
    
    			
    		}
    	}
    //	cout << cnt << "" "";
    	assert(cnt <= 100000);
    	cout << endl;
    
    	
    
    	return 0;
    	
    }
    

",C++
1055363,"
    import java.io.*;
    import java.util.Arrays;
    import java.util.Scanner;
    
    
    //A Home for Chef
    //Problem code: CHEFHOME
    //http://www.codechef.com/MAY12/problems/CHEFHOME
    //http://www.codechef.com/problems/CHEFHOME
    public class Main {
    	public static void main(String[] args)throws Exception{
    			solve();
    	}
    
    	public static void solve() throws IOException{
    		Scanner fscan =  new Scanner(System.in);
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    		int T = fscan.nextInt();
    		
    		for(; T > 0; T--){
    			long dx,dy;
    			dx = dy = 1;
    
    			int N = fscan.nextInt();
    			long x[] = new long[N];
    			long y[] = new long[N];
    			for (int i = 0; i < N; i++) {
    				x[i] = fscan.nextInt();;
    				y[i] = fscan.nextInt();
    			}
    			
    			if(N%2 == 0){
    				Arrays.sort(x);
    				Arrays.sort(y);
    				dx = x[N/2] - x[N/2 -1] + 1;
    				dy = y[N/2] - y[N/2 -1] + 1;
    			}
    
    			bw.append(String.valueOf(dx * dy) + ""\n"");
    		}
    		fscan.close();	
    		bw.close();
    	}
    }

",JAVA
3651229,"
    #include <cstdio>
    
    using namespace std;
    
    const int N = 6670, MOD = 747474747;
    int n, d, a [N][6];
    long long dist [N], ans = 1;
    
    void read () {
        int i, j;
    
        scanf (""%d%d"", &n, &d);
        for (i = 1; i <= n; i ++)
            for (j = 1; j <= d; j ++)
                scanf (""%d"", &a [i][j]);
    }
    
    long long distance (const int &u, const int &v) {
        int i;
        long long D = 0;
        for (i = 1; i <= d; i ++)
            D = (long long)D + (a [u][i] - a [v][i])*(a [u][i] - a [v][i]);
        return D;
    }
    
    void apm (int node) {
        int i, newnode = 0;
        long long newdist, mindist = (1ll << 31) - 1;
    
        dist [node] = -1;
        for (i = 1; i <= n; i ++)
            if (dist [i] != -1) {
                newdist = distance (node, i);
                if (newdist > dist [i])
                    dist [i] = newdist;
                if (newdist < mindist) {
                    mindist = newdist;
                    newnode = i;
                }
            }
        if (newnode) {
            ans = ((long long)ans * mindist) % MOD;
            apm (newnode);
        }
    }
    
    void solve () {
        if (n == 1)
            printf (""0\n"");
        else {
            apm (1);
            printf (""%lld\n"", ans);
        }
    }
    
    int main () {
        int T, t;
    
       /* freopen (""chef.in"", ""r"", stdin);
        freopen (""chef.out"", ""w"", stdout);*/
    
        scanf (""%d"", &T);
        for (t = 0; t < T; t ++) {
            read ();
            solve ();
        }
        return 0;
    }
    

",C++
2054528,"
    #include<stdio.h>
    #define m 7474747
    typedef struct
    {
    	int x1,x2,x3,x4,x5;
    }vertices;
     typedef struct
    {
    	int row,col;
    	long value;
    }max;
    	vertices v[10000];
        long arr[10000][10000];
        max maxi[10000];
    	int disjoint[10000];
        void makeset(int disjoint[],int size)
    	{
    	    int i;
    	   for(i=0;i<size;i++)
    	  {
    	    disjoint[i]=-1;
    	  }
    	}
        int find(int disjoint[],int x)
    	 {
    	 if(disjoint[x]<0)
    	 return x;
    	 else
    	 return find(disjoint,disjoint[x]);
    	 }
        int unionbysize(int root1,int root2)
    	 {
    		 int a,b;
    		 a=find(disjoint,root1);
    		 b=find(disjoint,root2);
    		 if(a==b)
    			 return 0;
    		 if(disjoint[a]<disjoint[b])
    		 {
    			 disjoint[a]+=disjoint[b];
    			 disjoint[b]=a;
    			 return 1;
    		 }
    		 else
    		 {
    			 disjoint[b]+=disjoint[a];
    			 disjoint[a]=b;
    			 return 1;
    		 }
    	 }
        main()
    	{
    		int testcases,su,nlines,dimensions,i,a,b,c,d,e,j,pointer=0,pointer2=0;
    		long long maximum=0,distance,ans;
    		scanf(""%d"",&testcases);
    		while(testcases>0)
    		{
    			testcases--;
    			ans=1;
    			scanf(""%d %d"",&nlines,&dimensions);
    			for(i=0;i<nlines;i++)
    			{
    
    				if(dimensions==1)
    				{
    				    scanf(""%d"",&a);
    				    v[i].x1=a;v[i].x2=0;v[i].x3=0;v[i].x4=0;v[i].x5=0;
    				}
    				else if(dimensions==2)
    				{
    					scanf(""%d %d"",&a,&b);
    					v[i].x1=a;v[i].x2=b;v[i].x3=0;v[i].x4=0;v[i].x5=0;
    
    				}
    				else if(dimensions==3)
    				{
    					scanf(""%d %d %d"",&a,&b,&c);
    					v[i].x1=a;v[i].x2=b;v[i].x3=c;v[i].x4=0;v[i].x5=0;
    				}
    				else if(dimensions==4)
    				{
    					scanf(""%d %d %d %d"",&a,&b,&c,&d);
    					v[i].x1=a;v[i].x2=b;v[i].x3=c;v[i].x4=d;v[i].x5=0;
    				}
    				else if(dimensions==5)
    				{
    					scanf(""%d %d %d %d %d"",&a,&b,&c,&d,&e);
    					v[i].x1=a;v[i].x2=b;v[i].x3=c;v[i].x4=d;v[i].x5=e;
    				}
    			}
    				for(i=0;i<nlines;i++)
    				{
    					maximum=0;
    					for(j=i;j<nlines;j++)
    					{
    						distance=(((((v[i].x1-v[j].x1)*(v[i].x1-v[j].x1))%m+((v[i].x2-v[j].x2)*(v[i].x2-v[j].x2))%m)%m
    						+((v[i].x3-v[j].x3)*(v[i].x4-v[j].x4))%m)%m+
    						((v[i].x5-v[j].x5)*(v[i].x5-v[j].x5))%m)%m;
    						arr[i][j]=distance;
    						if(maximum<distance)
    						{
    							maximum=distance;
                                pointer=j;
    						}
    					}
    						maxi[i].row=i;maxi[i].col=pointer;maxi[i].value=maximum;
    
    				}
    				makeset(disjoint,nlines);
    				//for(i=0;i<nlines;i++)
    				//printf(""%d  "",disjoint[i]);
    				//printf(""\n"");
    				for(su=0;su<nlines;su++)
    				{
    					long mmax=0;
    					pointer=0;
    					pointer2=0;
    					for(i=0;i<nlines;i++)
    					{
    						if(maxi[i].value>mmax)
    				    	{
    						 pointer=i;
    				    	 mmax=maxi[i].value;
    				    	}
    					}
    					if(unionbysize(pointer,maxi[pointer].col)==1)
    					{
    					    //printf(""varun %d %d %d\n"",pointer,maxi[pointer].col,maxi[pointer].value);
    						ans=((ans%m)*(mmax%m))%m;
    					}
    					//for(i=0;i<nlines;i++)
    					//printf(""%d  "",disjoint[i]);
    					//printf(""\n"");
    					long smax=0l;
    					for(j=0;j<nlines;j++)
    					{
    						if(arr[pointer][j]<=mmax&&arr[pointer][j]>=smax&&j!=maxi[pointer].col)
    						{
    							smax=arr[pointer][j];
    							pointer2=j;
    						}
    					}
    					maxi[pointer].value=smax;
    					maxi[pointer].col=pointer2;
    				}
    				printf(""%lld\n"",ans);
    				for(i=0;i<nlines;i++)
    				 v[i].x1=0;v[i].x2=0;v[i].x3=0;v[i].x4=0;v[i].x5=0;
    			}
                 return 0;
    		}
    
    

",C++
4083708,"
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <stack>
    #include <math.h>
    
    using namespace std;
    
    int arr[350][350];
    bool visited[350][350];
    bool isPrime[10000001]={false}; 
    int cost[10000001];
    int N;	
    
    typedef struct _node{
    
    int i;
    int j;
    
    }node;
    
    void DFS(int i, int j);
    void DFS2(int i, int j);
    
    int main()
    {
    	
    	int T,i,j;
    	int a=10000001;
    	long long int totalcost;
    	scanf(""%d"",&T);
    	//printf(""%d\n"",T);
    	isPrime[0]=true;
    	isPrime[1]=true;
    
    	
    	for(i=2;i<sqrt(a);i++)
    	{
    		if(!isPrime[i])
    		{
    			for(j=i*i;j<a;j+=i)
    				isPrime[j]=true;
    		}
    	}
    
    	int primeid=0;
    	
    	for(i=0;i<a;i++)
    	{
    		if(!isPrime[i])
    		{
    			cost[i]=primeid;
    			primeid++;
    		}
    		else
    		{
    			if(i%2==0)
    				cost[i]=i/2;
    			else
    				cost[i]=(i+3)/2;
    		}
    	}
    
    
    
    	while(T--)
    	{
    		totalcost=0;
    		scanf(""%d"",&N);
    		for(i=0;i<N;i++)
    		{
    			for(j=0;j<N;j++)
    			{
    				scanf(""%d"",&arr[i][j]);
    				visited[i][j]=false;
    			}
    		}
    		for(i=0;i<N;i++)
    		{
    			for(j=0;j<N;j++)
    			{
    				if(!visited[i][j])
    				{
    					//printf(""cost of %d = %d\n"",arr[i][j] , cost[arr[i][j]]);
    					totalcost+=cost[arr[i][j]];
    					DFS(i,j);
    					visited[i][j]=true;
    				}
    				
    			}
    			
    		}
    
    		printf(""%lld\n"",totalcost);
    
    	}
    	return 0;
    }
    
    void DFS2(int i,int j)
    {
    
    }
    void DFS(int i, int j)
    {
    	stack <node> mystack;
    	node a;node b;
    	a.i=i;a.j=j;
    	int all_neighburs_visited;
    	if(isPrime[arr[i][j]])
    	mystack.push(a);
    	while(!mystack.empty())
    	{
    		a=mystack.top();
    		visited[a.i][a.j]=true;
    		all_neighburs_visited=1;
    		if(a.i<N-1)
    		{
    			if(!visited[a.i+1][a.j] && isPrime[arr[a.i+1][a.j]] && arr[a.i+1][a.j]%2==arr[a.i][a.j]%2)
    			{
    				b.i=a.i+1;
    				b.j=a.j;
    				mystack.push(b);
    				all_neighburs_visited=0;
    			}
    		}
    			if(a.j<N-1)
    		{
    			if(!visited[a.i][a.j+1] && isPrime[arr[a.i][a.j+1]] && arr[a.i][a.j+1]%2==arr[a.i][a.j]%2)
    			{
    				b.i=a.i;
    				b.j=a.j+1;
    				mystack.push(b);
    				all_neighburs_visited=0;
    			}
    		}
    		if(a.i!=0)
    		{
    			if(!visited[a.i-1][a.j] && isPrime[arr[a.i-1][a.j]] && arr[a.i-1][a.j]%2==arr[a.i][a.j]%2)
    			{
    				b.i=a.i-1;
    				b.j=a.j;
    				mystack.push(b);
    				all_neighburs_visited=0;
    			}
    		}
    		if(a.j!=0)
    		{
    			if(!visited[a.i][a.j-1] && isPrime[arr[a.i][a.j-1]] && arr[a.i][a.j-1]%2==arr[a.i][a.j]%2)
    			{
    				b.i=a.i;
    				b.j=a.j-1;
    				mystack.push(b);
    				all_neighburs_visited=0;
    			}
    		}
    		if(all_neighburs_visited)
    		{
    			//printf(""(%d,%d)\n"",a.i,a.j );
    			mystack.pop();
    		}
    	}
    
    		
    }

",C++
1724608,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Stack;
    class StackElement
    {
    	private int iCtr, jCtr;
    	StackElement(int iCtr, int jCtr)
    	{
    		this.iCtr = iCtr;
    		this.jCtr = jCtr;
    	}
    	public int getiCtr() {
    		return iCtr;
    	}
    	public int getjCtr() {
    		return jCtr;
    	}
    }
    class Data
    {
    	private int value;
    	private boolean prime = false, even = false, odd = false, visited = false;
    	int count = 0;
    	Data(int value)
    	{
    		this.setValue(value);
    		if(Main.composites[value])
    		{
    			if(value % 2 == 0)
    				even = true;
    			else
    				odd = true;
    		}
    		else
    			prime = true;
    	}
    	public boolean isPrime()
    	{
    		return this.prime;
    	}
    	public boolean isEven()
    	{
    		return this.even;
    	}
    	public boolean isOdd()
    	{
    		return this.odd;
    	}
    	public boolean isVisited()
    	{
    		return this. visited;
    	}
    	public void setVisited(boolean visited) {
    		this.visited = visited;
    	}
    	public int getValue() {
    		return value;
    	}
    	public void setValue(int value) {
    		this.value = value;
    	}
    	public String toString()
    	{
    		return value + "" "" + count + "" "" + even + "" "" + odd + "" "" + prime + ""\t""; 
    	}
    }
    public class Main
    {
    	public static final int SIZE = 10000000;
    	public static boolean[] composites;
    	public static int[] nth;
    	public static void generate_sieve_of_eratosthenes()
    	{
    		composites = new boolean[SIZE+2];
    		nth = new int[SIZE+2];
    		composites[0] = composites[1] = true;
    		int bound = (int)Math.sqrt(SIZE);
    		for (int i = 2; i <= bound; ++i) {
    			if (!composites[i]) {
    				for (int j = i*i; j <= SIZE; j += i) {
    					composites[j] = true;	
    				}
    			}
    		}	
    		int cnt = 0;
    		for (int i = 2; i <= SIZE; ++i) {
    			if (!composites[i]) {
    				nth[i] = cnt;
    				cnt++;
    			}
    		}
    	}
    	public static void main(String [] arg) throws NumberFormatException, IOException
    	{
    		generate_sieve_of_eratosthenes();
    		BufferedReader c = new BufferedReader(new InputStreamReader(System.in));
    		int testCase = Integer.parseInt(c.readLine());
    		StringBuilder sb = new StringBuilder();
    		if(testCase > 8 || testCase < 1)
    			return;
    		while(testCase-- > 0)
    		{
    			int n = Integer.parseInt(c.readLine());
    			if(n > 350 || n < 1)
    				return;
    			int count = 0;
    			Data[][] passwordData = new Data[n][n];
    			for(int iCtr = 0 ; iCtr < n ; ++iCtr)
    			{
    				String[] data = c.readLine().split("" "");
    				for(int jCtr = 0 ; jCtr < n; jCtr++)
    					passwordData[iCtr][jCtr] = new Data(Integer.parseInt(data[jCtr]));
    			}
    			for(int iCtr = 0 ; iCtr < n ; ++iCtr)
    			{
    				for(int jCtr = 0 ; jCtr < n; jCtr++)
    				{
    					if(passwordData[iCtr][jCtr].isPrime())
    					{
    						passwordData[iCtr][jCtr].count = getSequenceCount(passwordData[iCtr][jCtr].getValue());
    						count += passwordData[iCtr][jCtr].count;
    						passwordData[iCtr][jCtr].setVisited(true);
    					}
    					else if(passwordData[iCtr][jCtr].isVisited())
    						passwordData[iCtr][jCtr].count = 0;
    					else if(passwordData[iCtr][jCtr].isEven())
    					{
    						passwordData[iCtr][jCtr].count = passwordData[iCtr][jCtr].getValue() / 2;
    						count += passwordData[iCtr][jCtr].count;
    						passwordData[iCtr][jCtr].setVisited(true);
    						spread(passwordData, iCtr, jCtr, passwordData[iCtr][jCtr].isEven());
    					}
    					else
    					{
    						passwordData[iCtr][jCtr].count = (passwordData[iCtr][jCtr].getValue() + 3) / 2;
    						count += passwordData[iCtr][jCtr].count;
    						passwordData[iCtr][jCtr].setVisited(true);
    						spread(passwordData, iCtr, jCtr, passwordData[iCtr][jCtr].isEven());
    					}
    				}
    			}
    //				System.out.println();
    //				for(int iCtr = 0 ; iCtr < n ; ++iCtr)
    //				{
    //					for(int jCtr = 0 ; jCtr < n; jCtr++)
    //					{
    //						System.out.print(passwordData[iCtr][jCtr] + "" "");
    //					}
    //					System.out.println();
    //				}
    //				System.out.println();
    			sb.append(count);
    			sb.append(""\r\n"");
    		}
    		System.out.print(sb.toString());
    	}
    	static final int dx[] = {+0, +1, +0, -1};
    	static final int dy[] = {+1, +0, -1, +0};
    	private static void spread(Data[][] passwordData, int iCtr, int jCtr, boolean even) 
    	{
    		Stack<StackElement> stack = new Stack<StackElement>();
    		stack.push(new StackElement(iCtr, jCtr));
    		while(!stack.empty())
    		{
    			StackElement se = stack.pop();
    			iCtr = se.getiCtr();
    			jCtr = se.getjCtr();
    			for(int kCtr = 0 ; kCtr < 4 ; kCtr++)
    			{
    				int nextiCtr = iCtr + dx[kCtr];
    				int nextjCtr = jCtr + dy[kCtr];
    				if(nextiCtr >= 0 && nextiCtr < passwordData.length && nextjCtr >= 0 && nextjCtr < passwordData.length)
    				{
    					if(passwordData[nextiCtr][nextjCtr].isVisited())
    						continue;
    					if(passwordData[nextiCtr][nextjCtr].isPrime())
    						continue;
    					if(passwordData[nextiCtr][nextjCtr].isEven() != even)
    						continue;
    					passwordData[nextiCtr][nextjCtr].setVisited(true);
    					stack.push(new StackElement(nextiCtr, nextjCtr));
    					//spread(passwordData, nextiCtr, nextjCtr, even);
    				}
    			}
    		}
    	}
    
    	private static int getSequenceCount(int value) {
    		return Main.nth[value];
    	}
    }   

",JAVA
1724478,"
    /* Author: Karlheinz Jung */
    /* Compiler: Borland Turbo C 2.01 */
    /* Computer: Rabbit 286 */
    /* Contest: January 2013 Long Contest (JAN13) */
    /* Problem: End Of The World (CHEFHACK) */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    #include <limits.h>
    
    #define LL long long
    #define ULL unsigned long long
    #ifndef ONLINE_JUDGE
    	#define buffer_size 1000
    	#define siz1 10
    	#define siz2 100
    	#define siz3 1000
    #else
    	#define buffer_size 200000000
    	#define siz1 351
    	#define siz2 626000
    	#define siz3 10000000
    #endif
    #define _T for(;!((*ez1>='0'&&*ez1<='9')||*ez1=='-');ez1++);if(*ez1=='-'){wq1=-1;ez1++;}while(1){char c=*ez1;if(c<=32)return wq2*wq1;wq2=(wq2<<1)+(wq2<<3)+c-'0';ez1++;}
    
    char pq1[buffer_size];
    char *ez1;
    
    int sint(){int wq1=1,wq2=0;_T}
    long slong(){long wq1=1,wq2=0;_T}
    LL sLL(){LL wq1=1,wq2=0;_T}
    ULL sULL(){ULL wq1=1,wq2=0;_T}
    int sstring(char ziel[]){char *ez2=ziel;for(;ez1<pq1+buffer_size&&*ez1<33;ez1++);for(;ez1<pq1+buffer_size&&*ez1>32;*ez2++=*ez1++);*ez2='\0';return ez1<pq1+buffer_size;}
    
    #define _A for(i=0;i<n;i++)for(j=0;j<n;j++)
    
    int n;
    int e[siz3];
    int a[siz1][siz1];
    int z1[]={-1,1,0,0}, z2[]={0,0,1,-1};
    int o[siz1][siz1];
    char f[siz2];
    
    void F(int x, int x1, int y1)
    {
    int i, x2, y2;
    for(i=0; i<4; i++)
    	{
    	x2=x1+z1[i];
    	y2=y1+z2[i];
    	if(x2<0||y2<0||x2==n||y2==n) continue;
    	if(o[x2][y2]==1) continue;
    	if((a[x2][y2]&1)==x)
    		{
    		o[x2][y2]=1;
    		F(x,x2,y2);
    		}
    	}
    }
    
    void losen()
    {
    int i, j;
    LL r=0;
    n=sint();
    memset(o,0,sizeof(o));
    _A
    	{
    	a[i][j]=sint();
    	if(e[a[i][j]])
    		{
    		r+=e[a[i][j]]-1;
    		o[i][j]=1;
    		}
    	}
    _A
    	if(o[i][j]!=1)
    		{
    		o[i][j]=1;
    		if(a[i][j]%2==0)
    			{
    			r+=(a[i][j]+1)/2;
    			F(0,i,j);
    			}
    		else
    			{
    			r+=1+(a[i][j]+1)/2;
    			F(1,i,j);
    			}
    		}
    printf(""%lld\n"",r);
    }
    
    int main()
    {
    int fall, i, j, q=0;
    memset(f,255,sizeof(f));
    memset(e,0,sizeof(e));
    if(fread(pq1,1,sizeof(pq1),stdin));
    ez1=pq1;
    f[0]=0xFE;
    for(i=1; i<3165; i++)
    	if(f[i>>3]&(1<<(i&7)))
    		for(j=3*i+1; j<siz3/2; j+=2*i+1)
    			f[j>>3]&=~(1<<(j&7));
    e[2]=++q;
    for(i=3; i<siz3; i+=2)
    	if((f[(i)>>4]&(1<<(((i)>>1)&7)))) e[i]=++q;
    for(fall=sint(); fall--; losen());
    return 0;
    }
    

",C
12109009,"
    ///IN THE NAME OF MY CREATOR.......................
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
         int t;
         cin>>t;
         while(t--)
         {
              string s;
              cin>>s;
              int count=0;
              for(int i=1;i<s.length();i++)
              {
                     if(s[i]==s[i-1])
                     {
                          count++;
                          if(s[i]=='-')
                          {
                               s[i]='+';
                          }
                          else
                          {
                               s[i]='-';
                          }
                     }
              }
    
              cout<<count<<endl;
         }
    }
    

",C++
10827496,"
    #include<bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    	std::ios_base::sync_with_stdio(false);
    
    	int T;
    	cin >> T;
    	for (int j=0;j<T;j++)
        {
           char s[10005];
           cin >> s;
           int l = strlen(s);
           char pos[l];
           char neg[l];
    
           for (int i=0;i<l;i++)
           {
               if (i%2==0)
               {
                   pos[i]='+';
                   neg[i]='-';
               }
               else
                {
                   pos[i]='-';
                   neg[i]='+';
                }
           }
    
           int counter = 0;
    
           if (s[0]=='+')
           {
               for (int i=0;i<l;i++)
               {
                   if (s[i] != pos[i])
                   {
                       counter = counter + 1;
                   }
               }
           }
    
           else
           if (s[0]=='-')
           {
               for (int i=0;i<l;i++)
               {
                   if (s[i]!=neg[i])
                   {
                       counter = counter + 1;
                   }
               }
           }
    
           cout << counter << ""\n"";
    
        }
        
           return (0);
        }
    
    
    

",C++
8957266,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		long int count,n,i;
    		char a[100006];
    		count=0;
    		scanf(""%s"",a);
    		n=strlen(a);
    			for(i=2;i<n;i+=2)
    			{
    				if(a[i]!=a[0])
    				count++;
    			}
    			for(i=1;i<n;i+=2)
    			{
    				if(a[i]==a[0])
    				count++;
    			}
    		printf(""%ld\n"",count);
    	}
    	return 0;
    }

",C
6385328,"
    //Either convert string to +-+-+-.....
    //or to -+-+-+
    #include <iostream>
    using namespace std;
    int main(){
        ios_base::sync_with_stdio(false);
        int t,i,num_flips_1,num_flips_2;
        string s;
        cin>>t;
        while(t){
            cin>>s;
            num_flips_1=0;//String starting with +
            num_flips_2=0;//string starting with -
    
            for(int i=0;i<s.size();i++){
                if(i&1){
                    if(s[i]!='-')
                        num_flips_1++;
                }else{
                    if(s[i]!='+')
                        num_flips_1++;
                }
            }
    
            for(int i=0;i<s.size();i++){
                if(i&1){
                    if(s[i]!='+')
                        num_flips_2++;
                }else{
                    if(s[i]!='-')
                        num_flips_2++;
                }
            }
    
    
            if(num_flips_1>=num_flips_2)
                cout<<num_flips_2<<endl;
            else
                cout<<num_flips_1<<endl;
    
            t--;
        }
        return 0;
    }
    

",C++
6814395,"
    import java.util.Scanner;
    
    public class Main {
      public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int i = 0; i < t; i++) {
          int n = in.nextInt();
          int[] val = new int[(int)1e5 + 1];
          int maxFreq = Integer.MIN_VALUE;
          for (int j = 0; j < n; j++) {
            int a = in.nextInt();
            val[a] ++;
            if (val[a] > maxFreq) {
              maxFreq = a;
            }
          }
          System.out.println(n - maxFreq);
        }
      }
    }
    
          

",JAVA
10138870,"
    #include <iostream>
    using namespace std;
    
    long long arr[45];
    
    long long calc(int x, int k, int n)
    {
    	if(x<0)
    	return 0;
    	
    	else if(x==0)
    	{
    		if(k==0)
    		return 1;
    		else
    		return 0;
    	}
    	else if(k==0)
    	return 0;
    	
    	else if(x>k*arr[n])
    	return 0;
    	
    	int sum=0;
    	
    	if(n-1>=0)
    	sum=calc(x,k,n-1);
    	
    	sum%=1000000007;
    	
    	if(x-arr[n]>=0)
    	sum+=calc(x-arr[n],k-1,n);
    	
    	return sum%1000000007;
    }
    int main() {
    	arr[0]=1;
    	arr[1]=2;
    	for(int i=2;i<44;i++)
    	arr[i]=arr[i-1]+arr[i-2];
    	//cout<<arr[42]<<endl;
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		int x,k;
    		scanf(""%d %d"",&x,&k);
    		printf(""%d\n"",calc(x,k,42));
    	}
    	return 0;
    }

",C++
10104480,"
    #include<bits/stdc++.h>
    using namespace std;
    #define MOD 1000000007
    long long fib[43];
    void caluculatefib()
    {
       fib[0]=1;
       fib[1]=2;
        for(int i=2;i<43;i++)
        fib[i]=fib[i-1]+fib[i-2];
    }
    
    long long results(long long sum,int k,int n)
    {
        if(k==0)
        return (sum==0)?1:0;
        if((n==0)||(sum<=0))
        return 0;
        long long ans=0;
        for(int i=n;i>=0;i--)
        {
            if((fib[i]*k)<sum)
            break;
            ans=((ans%MOD)+(results(sum-fib[i],k-1,n-1)%MOD))%MOD;
        }
        return ans;
    }
    int main()
    {
        caluculatefib();
        int t;
        int k;
        long long x;
        scanf(""%d"",&t);
        while(t--)
        {
            scanf(""%lld %d"",&x,&k);
          printf(""%lld\n"",results(x,k,42));
            
        }
        return 0;
    }  

",C++
9926495,"
    #include<bits/stdc++.h>
    using namespace std;
    #define ll long long
    int main()
    {
        long long t;
        cin>>t;
        while(t--)
        {
            ll n,m;
            cin>>n>>m;
            if((n==1&&m==2)||(n==2&&m==1))
                cout<<""Yes\n"";
            else if(n==1||m==1||(n&1&&m&1))
                cout<<""No\n"";
            else
                cout<<""Yes\n"";
        }
    }
    

",C++
11887849,"
    #include<stdio.h>
    
    int main(void)
    {
      int t, n, m;
      scanf(""%d"", &t);
      
      while(t--)
      {
        scanf(""%d %d"", &n, &m);
        
        if(n*m % 2 == 0)
          printf(""Yes\n"");
        else
          printf(""No\n"");
      }
      
      return 0;
      
    }

",C
11207107,"
    #include<iostream>
    #include<cmath>
    #include<set>
    #include<vector>
    #include<list>
    #include<map>
    #include<algorithm>
    #include<stdio.h>
    #include<string.h>
    #include<stack>
    #include<queue>
    #include<climits>
    #include<string>
    #include<sstream>
    #include <bitset>
    
    using namespace std;
    
    typedef unsigned long long int ULL;
    typedef long long int LL;
    typedef unsigned int UI;
    
    typedef pair<int, int> PI;
    typedef vector<int> VI;
    
    
    #define MP make_pair
    //bool operator <(const X& A, const X& B){return A.n < B.n;}
    
    #define FOR(i, a, b) for(int i=a;i<b;++i)
    
    #ifndef ONLINE_JUDGE
    
    #include <time.h>
    
    #endif
    
    int A[100000 + 10];
    
    int main() {
    #ifndef ONLINE_JUDGE
        freopen(""input.txt"", ""r"", stdin);
        //freopen(""output.txt"",""w"",stdout);
        clock_t start = clock();
    #endif
    
    
        int T;
        scanf(""%d\n"", &T);
        FOR(tT, 0, T) {
            int N;
            scanf(""%d"", &N);
            FOR(i, 0, N) {
                scanf(""%d"", &A[i]);
            }
    
    
            map<int, int> C;
            map<int, int> L;
            FOR(j, 0, N) {
                if (L[j] == 1)continue;
                int k = j;
                map<int, int> V;
                int f = 0;
                do {
                    if (L[k] == 1) {
                        f = 1;
                    }
                    V[k] = 1;
                    L[k] = 1;
                    k = (A[k] + k + 1) % N;
                } while (V[k] == 0);
    
                if (f == 1)break;
    
                int s = k;
                C[s] = 1;
                do {
                    k = (A[k] + k + 1) % N;
                    C[k] = 1;
                } while (k != s);
                Z:;
            }
    
            printf(""%d\n"", C.size());
        }
    
    
    #ifndef ONLINE_JUDGE
        printf(""Time elapsed: %f\n"", ((double) clock() - start) / CLOCKS_PER_SEC);
    #endif
        return 0;
    }
    

",C++
11184910,"
    #include<iostream>
    #include<cstdio>
    using namespace std;
    int main()
    {
        int t;
        scanf(""%d"",&t);
        for(int i=0;i<t;i++)
        {
            int n;
            scanf(""%d"",&n);
            int arr[n];
            for(int j=0;j<n;j++)
            {
                int a;
                scanf(""%d"",&a);
                arr[j]=(a+j+1)%n;
            }
            int count=0;
            for(int j=0;j<n;j++)
            {
                int k=j,l=0;
                bool temp[n];
                temp[k]=true;
                while(1)
                {
                    k=arr[k];
                    if(!temp[k])
                        temp[k]=true;
                    else if(k==j)
                    {
                        l=1;
                        break;
                    }
                    else
                        break;
                }
                if(l==1)
                    count++;
            }
            printf(""%d\n"",count);
        }
        return 0;
    }
    

",C++
8998182,"
    #include<iostream>
    #include<vector>
    using namespace std;
    int main()
    {
    	ios::sync_with_stdio(false);
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		int n,temp;
    		long long ans;
    		cin>>n;
    		ans=n;
    		vector<int> a,v,m;
    		for(int i=0;i<n;i++)
    		{
    			cin>>temp;
    			a.push_back(temp);
    			v.push_back(temp);
    			m.push_back(temp);
    		}
    		for(int j=2;j<=n;j++)
    		{
    			for(int i=0;i<v.size()-1;i++)
    			{
    				v[i]+=a[i+j-1];
    				m[i]*=m[i+j-1];
    				if(v[i]==m[i])
    					ans++;
    			}
    		}
    		cout<<ans<<endl;
    	}
    	return 0;
    }

",C++
7312460,"
    #include <cstdio>
    #include <cstring>
    #define Maxn 1000000
    int zs[Maxn],cnt = 0,n,T;
    bool f[Maxn];
    void Pre_work() //筛法
    {
        memset(f,false,sizeof(f));
        for(int i=2;i<Maxn;i++)
    		if(!f[i])
    		{
    			zs[++cnt] = i;
    			for(int j=2*i;j<Maxn;j+=i)
                    f[j] = true;
    		}
    }
    void Work()
    {
    	long long ans,t1,t2;
        ans = 1;
        for(int i=1;(i<=cnt)&&(n>1);i++)
        {
            if(zs[i] * zs[i] > n)
                break;
            t1 = t2 = 1;
            while(n % zs[i]==0)
            {
                t2 *= zs[i];//printf(""%d\n"",t2);
                t1 += t2;
                n /= zs[i];
            }
            ans *= t1;//printf(""%d\n"",ans);
        }
        if(n > 1)
            ans *= (1 + n);
        printf(""%lld\n"",ans);
    }
    int main()
    {
        Pre_work();
    	for (scanf(""%d"",&T);T--;)
    	{
    		scanf(""%d"",&n);
            Work();
    	}
    	return 0;
    }
    

",C++
11708913,"
    #include<stdio.h>
    #include<stdbool.h>
    int main()
    {
        bool arr[100001]={false};
        long int a,i,n;
        scanf(""%ld"",&n);
        for(i=0;i<n;i++)
        {
           scanf(""%ld"",&a);
           arr[a]=true;
           }
        for(i=0;i<=n;i++)
        {
          if(arr[i]==false)
          printf(""%ld "",i);
          }
          
          return 0;
          }
     

",C
11546211,"
    #include<stdio.h>
    int main()
    {
    	int n,a[100000],x,i;
    	printf(""enter the no of members:\n"");
    	scanf(""%d"",&n);
    	printf(""enter the members:\n"");
    	for(i=0;i<=n;i++)
    	{
    		a[i]=-1;
    	}
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&x);
    		a[x]=1;
    	}
    	for(i=0;i<=n;i++)
    	{
    		if(a[i]==-1)
    		{
    			printf(""%d "",i);
    		}
    	}
    	return 0;
    }
    

",C
11545503,"
    n = input()
    suspects = range(1, n+1)
    bosses = map(int, str(raw_input()).split()) 
    for tmp in bosses:
    	try:
    		suspects.remove(tmp)
    	except:
    		pass
    print ' '.join(map(str, suspects))

",PYTH
10156808,"
    #include<bits/stdc++.h>
    using namespace std;
    int is_doubleString(char s[])
    {
    	int f=1;
    	long long int len=strlen(s);
    	for(int i=0;i<len/2;i++)
    	{
    		if(s[i]!=s[i+len/2])
    		{
    			f=0;
    			break;
    		}
    	}
    	return f;
    }
    int is_sub(char str1[],long long int a,long long int b,char str2[],long long int x,long long int y)
    {
    	long long int j=a;
    	for(long long int i=x;i<=y&&j<=b;i++)
    	{
    		if(str1[j]==str2[i])
    		j++;
    	}
    	return (j==b+1);
    }
    int main()
    {
    	ios::sync_with_stdio(false);
    	long long int d;
    	cin>>d;
    	while(d--)
    	{
    		char s[1000001];
    		int f;
    		cin>>s;
    		long long int l=strlen(s);
    		if(l%2==0)
    		f=is_doubleString(s);
    		else
    		{
    			if(l==1)
    			f=0;
    			else
    			{
    				long long int h;
    				h=l/2;
    				f=is_sub(s,0,h-1,s,h,l-1)||is_sub(s,h+1,l-1,s,0,h);
    			}
    		}
    		if(f==1)
    		cout<<""YES""<<endl;
    		else
    		cout<<""NO""<<endl;
    	}
    	return 0;
    }

",C++
9039239,"
    #include <stdio.h>
    
    int main()
    {
        int t=0,i=0;
        scanf(""\n%d"",&t);
        for(i=0;i<t;i++)
        {
            int n=0;
            scanf(""\n%d"",&n);
            int a[n],j=0,k=0,temp=0,sum=0;
            for(j=0;j<n;j++)
            {
                scanf(""\n%d"",&a[j]);
            }
            for(j=0;j<n-1;j++)
            {
                for(k=j+1;k<n;k++)
                {
                    if(a[j]<=a[k])
                    {
                        temp=a[k];
                        a[k]=a[j];
                        a[j]=temp;
                    }
                }
            }
            for(j=0;j<(n+1)/2;j++)
            {
                sum=sum+a[j];
            }
            printf(""\n%d"",sum);
        }
    	return 0;
    }
    

",C
8230968,"
    #include<iostream>
    using namespace std;
    int main()
    {
     int t;
     cin>>t;
     while(t--)
     {
      int N;
      long long count=0;
      cin>>N;
      long long a[N];
      for(int i=0;i<N;i++)
      cin>>a[i];
      for(int i=0;i<N;i++)
      {
        for(int j=i+1;j<N;j++)
        {
          if(a[i]>a[j])
          {
          int temp;
          temp=a[i];
          a[i]=a[j];
          a[j]=temp;
        }
       }
    }
    for(int i=N-1;i>=0;i-=2)
    {
      count=count+a[i];
    }
    cout<<count<<endl;
     }
    return 0;
    }
    

",C++
7578483,"
    #include<stdio.h>
    int cmpfunc (const void * a, const void * b)
    {
       return ( *(long long int*)a - *(long long int*)b );
    }
    int main(){
    	int t;
    	scanf(""%d"",&t);
    	while(t--){
    		long long int sum=0,n,i,j;
    		scanf(""%lld"",&n);
    		long long int a[n];
    		for(i=0;i<n;i++)
    			scanf(""%lld"",&a[i]);
    		qsort(a,n,sizeof(long long int),cmpfunc);
    		for(i=n-1;i>=0;i=i-2)
    			sum=sum+a[i];
    		printf(""%lld\n"",sum);
    	}
    return 0;
    }
    

",C
7494780,"
    #include<iostream>
    #include<cstdio>
    #include<algorithm>
    #include<cmath>
    #define gc getchar
    typedef long long int ll;
    using namespace std;
    ll read_int() {
    char c = gc();
    while(c<'0' || c>'9') c = gc();
    ll ret = 0;
    while(c>='0' && c<='9') {
    ret = 10 * ret + c - 48;
    c = gc();
    }
    return ret;
    }
    int main()
    {
        ll t,n,i,maxi=0;
        t=read_int();
        while(t--)
        {
            n=read_int();
            ll a[n];
            for(i=0;i<n;i++)
            {
                a[i]=read_int();
            }
            sort(a,a+n);
            for(i=n-1;i>=0;i-=2)
                maxi+=a[i];
            printf(""%lld\n"",maxi);
            maxi=0;
        }
        return 0;
    }
    

",C++
5623298,"
    #include <iostream>
    using namespace std;
    long long ans(long long arr[],int x)
    {
        int sum=0;
        for(int i=x-1;i>=0;i-=2)
        {
            sum+=arr[i];
        }
        return sum;
    }
    int main()
    {
        int n,i;
        cin>>n;
        long long b[n];
        for(i=0;i<n;i++)
        {
            int m;
            cin>>m;
            long long a[m];
            for(int j=0;j<m;j++)
            {
                cin>>a[j];
            }
            for(int k=0;k<m-1;k++)
            {
                for(int l=0;l<m-k;l++)
                {
                    if(a[l]>a[l+1])
                    {
                        long long temp=a[l];
                        a[l]=a[l+1];
                        a[l+1]=temp;
                    }
                }
            }
            b[i]=ans(a,m);
        }
        for(i=0;i<n;i++)
        {
            cout<<b[i]<<endl;
        }
        return 0;
    }
    

",C++
4923590,"
    #include<cstdio>
    #include<cstdlib>
    #include<iostream>
    #include<utility>
    #include<algorithm>
    #include<map>
    #include<queue>
    #include<stack>
    #include<vector>
    #include<string>
    #include<cmath>
    #include<map>
    
    #define gi(x) scanf(""%d"",&x)
    #define pi(x) printf(""%d "",x)
    #define pin(x) printf(""%d\n"",x);
    #define mp make_pair
    #define fi first
    #define se second
    
    using namespace std;
    
    const int lim = 100005;
    typedef long long LL;
    typedef pair<int,int> pii;
    
    int t;
    int n;
    int a[lim];
    
    int main()
    {
        gi(t);
    	while(t--)
    	{
    		gi(n);
    		for(int i=0;i<n;i++)
    			gi(a[i]);
    		sort(a,a+n,greater<int>());
    		LL res=(LL)0;
    		for(int i=0;i<n;i+=2)
    			res += (LL) a[i];
    		cout << res <<""\n"";
    	}
        return 0;    
    }
    

",C++
12036774,"
    #include<stdio.h>
    
    int main()
    {
    	int T,count,i=1,j=1,temp;
    	long int n,m,c;
    
    	do
    	{
    		scanf(""%d"",&T);
    	}
    	while(T<1 || T>100);
    
    	while(T)
    	{
    		count=0;
    		do
    		{
    			scanf(""%ld %ld %ld"",&n,&m,&c);
    		}
    		while((n<1 || n>1000000) && (m<1 || m>1000000) && (c<1 || c>1000000));
    
    		while(i<=n)
    		{
    			if(c%i==0)
    			{
    				temp=c/i;
    				if(temp<=m)
    					count++;
    			}
    			i++;
    		}
    
    		printf(""%d\n"",count);
    
    		T--;
    	}
    	return 0;
    }

",C
11917976,"
    /* package codechef; // don't place package name! */
    
    import java.util.*;
    import java.lang.*;
    import java.io.*;
    
    /* Name of the class has to be ""Main"" only if the class is public. */
    class Codechef
    {
    public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		int T = scanner.nextInt();
    		int _arr[] = new int[T * 3];
    		for (int k = 0; k < _arr.length; k += 3) {
    			_arr[k] = scanner.nextInt();
    			_arr[k + 1] = scanner.nextInt();
    			_arr[k + 2] = scanner.nextInt();
    		}
    
    		for (int i = 0; i < _arr.length; i+=3) {
    			int count = 0;
    			int h = _arr[i], w = _arr[i+1];
    			int c = _arr[i+2];
    			for (int j = 1; j <= h; j++) {
    				if (c % j == 0 && c / j <= w)
    					count++;
    			}
    			System.out.println(count);
    		}
    		scanner.close();
    	}
    }
    

",JAVA
11883306,"
        /*
    				-----   Kiamottullah   -----
    				       (20/ 10/ 2016)
    				All code is written by me .
    				You can allways use this code for
    				Learning context . keep learning
    */
    
    #include <iostream>
    #include <vector>
    using namespace std;
    
    class Pair{
        private :
            long long int X;
            long long int Y;
        
        public :
            Pair(int x, int y){
                X = x;
                Y = y;       // constructor
            }
            		// prototypes of this class
            int getX (){
                return X;
            }
            int getY (){
                return Y;
            }
            void show (){
                cout << getX() << "" "" << getY() << endl;
            }
    };
    
    class Testcase{
        private :
            int N;  // height
            int M;  // width
            long long int C;  // number of colours
    
            vector <Pair> Pairs;    // it's pairs
            
        public :
            Testcase (int n, int m, int c){
                N = n;
                M = m;      // constructor
                C = c;
                calculatePairs();
            }
            
            		// prototypes of this class
            int getN (){
                return N;
            }
            int getM (){
                return M;
            }
            int getC (){
                return C;
            }
            
            void calculatePairs (){
            // is all color (C) fit in (n*m) display
                if((N * M) >= C){
                
                	// firstly push two pairs (1, C) and (C, 1)
                    int x = 1, y = C;
                    if(isFit(x, y)){
                        Pairs.push_back(Pair(x, y));
                    }
                    x = C, y = 1;
                    if(isFit(x, y)){
                        Pairs.push_back(Pair(x, y));
                    }
                    // checking all the pairs from 2 to C/2
                    int hulf = C/2;
                    for(int i = 2; i <= hulf; i++){		
                        for(int j = 2; j <= C/i; j++){
                            if(isPair(i, j)){
                                if(isFit(i, j)){
                                    Pairs.push_back(Pair(i, j));
                                }
                            }
                        }
                    }
                }else {
    				        // so if all color can't drawble
    				        // Pair size will be 0
                }
            }
            void showPairs (){
                int s = Pairs.size();	// this function show all the Pairs
                for(int i = 0;i < s; i++){	// of C ... one by one
                    Pairs[i].show();
                }
            }
            bool isFit (int x, int y){
                if(((x <= N) && (y <= M))){
                    return true;		// this function check whether 
                }else {			// A pair (rect) fit into display (n*m)
                    return false;		  
                }
            }
            int getPairsLength (){
                return Pairs.size();	// this function return the number of 
            }				            // Pairs in Pairs vector .
            
            bool isPair (int x, int y){
                if ((x * y) == C){		// this function return true if (x*y) == C
                    return true;		// else return false that's it ((x*y) != C)
                }else {
                    return false;
                }
            }
    };
    
    int main() {
        // number of test case;
        int T; 
        
        // get input of number of test case
        cin >> T;
        
        // make an vector of size T;
        vector <Testcase> cases;
        
        for(int i = 0; i < T; i++){			// while (i < T) take input of
            int n, m, c;				// (n, m, c) for each testcase
            cin >> n >> m >> c;			// then push them in `cases`
            cases.push_back(Testcase(n, m, c));	// vector
    
            Testcase tc = cases[i];			// cout the length of Pairs
            cout << tc.getPairsLength() << endl;
        }
        return 0;
    }

",C++
11882748,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int T;
    	cin>>T;
    	while(T!=0)
    	{int i,j,p=0;
    		int c,n,m;
    		cin>>n>>m>>c;
    		for(i=1;i<=c;i++)
    		{
    			if(c%i==0)
    			{
    				x=c%i;
    				y=i;
    			
    			if(n>=x&&m>=y)
    			p++;
    		    }
    		}
    		cout<<p<<endl;T--;
    	}
    	return 0;
    }

",C++
5675837,"
    /* HellGeek */
    /* Shiva Bhalla */
    /* iit2012077 */
     
    #include<stdio.h>
    #include<vector>
    #include<map>
    #include<utility>
    #include<algorithm>
    #include<set>
    #include<string>
    #include<string.h>
    #include<time.h>
    #include<iostream>
    #include<queue>
    #include<stack>
    #include<math.h>
    
    #define LL long long
    #define FIT(i,t) for(i=0;i<t;i++)
    #define FIN(i,n) for(i=0;i<n;i++)
    #define FJT(j,t) for(j=0;j<t;j++)
    #define FJN(j,n) for(j=0;j<n;j++)
    #define MAX2(a,b) a>b?a:b
    #define MIN2(a,b) a>b?b:a
    #define REP(i,a,b) for(i=a;i<=b;i++)
    
    using namespace std;
    
    double prob[27][27];
    int k;
    char str[5];
    char mat[100005][5];
    string ar[100005];
    
    void mat_mult(double M1[27][27], double M2[27][27]) {
         
         double M3[27][27];
         
         int i,j,l,m,n;
         
         for(i=0;i<26;i++) {
                           for(j=0;j<26;j++) {
                                             M3[i][j] = 0;
                                             for(l=0;l<26;l++) {
                                                               M3[i][j] = M3[i][j] + M1[i][l]*M2[l][j];
                                             }
                           }
         }
         
         for(i=0;i<26;i++)
         for(j=0;j<26;j++)
         M1[i][j] = M3[i][j];
    }
    
    void mat_exp ( double F[27][27] , int n) {
         if(n==0 || n==1)
         return ;
         mat_exp(F,n/2);
         mat_mult(F,F);
         if(n%2==1)
         mat_mult(F,prob);
    }
         
         
    
    int main()
    {
        int i,j,l,n,m,t;
        scanf(""%d"",&t);
        double F[27][27];
        while(t--) {
                   scanf(""%d%d%s"",&n,&k,str);
                   for(i=0;i<26;i++) {
                                     for(j=0;j<26;j++) {
                                                       scanf(""%lf"",&prob[i][j]);
                                                       F[i][j] = prob[i][j];
                                     }
                                     
                   }
                   for(i=0;i<n;i++)
                   scanf(""%s"",mat[i]);
                   
                   mat_exp(F,k);
                   
                   double p = 0;
                   
                   for(i=0;i<n;i++) {
                                    if(strlen(str) != strlen(mat[i]))
                                    continue;
                                   // p += F[str[0]-97][mat[i][0]-97]*F[str[1]-97][mat[i][1]-97]*F[str[2]-97][mat[i][2]-97];
                                   double x = 1;
                                   for(j=0;j<strlen(str);j++)
                                   x = x*F[str[j]-97][mat[i][j]-97];
                                   p += x;
                   }
                   
                   printf(""%.9lf\n"",p);
        }
        
        return 0;
    }
    

",C++
8662265,"
    #include <bits/stdc++.h>
    using namespace std;
    
    const int N = 1e3 + 5;
    
    int n, a[N];
    
    int main(){
        #ifndef ONLINE_JUDGE
            freopen(""input.txt"", ""r"", stdin);
            freopen(""output.txt"", ""w"", stdout);
        #endif
    
        int T;
        scanf(""%d"", &T);
        while (T--){
            scanf(""%d"", &n);
            for (int i = 0; i < n; ++i)
                scanf(""%d"", &a[i]);
            sort(a, a+n);
            if (a[0] == 1){
                puts(""-1"");
                continue;
            }
            long long ans = 0;
            for (int i = 1; i < n; ++i)
                ans += a[i];
    
            ans += 2;
            printf(""%lld\n"", ans);
        }
    }
    

",C++
2494514,"
    #include<iostream>
    using namespace std;
    #include<algorithm>
    int main()
    {
    	long int i,j,c,n,w,ans;
    	
    	scanf(""%d"",&n);
    	scanf(""%d"",&w);
    	int a[n],b[n-1];
    	for(i=0;i<n;i++)
    	scanf(""%ld"",&a[i]);
    	
    	sort(a,a+n);
    	for(i=0;i<n-1;i++)
    	b[i]=a[i+1]-a[i];
    	sort(b,b+n-1);
    	ans=0;
    	for(i=0;i<n-1;)
    	{
    		c=0;
    		for(j=i;j<n-1&&b[j]==1;j++)
    		c++;
    		if(c/w>0)
    		ans=ans+(c/w)+(c%w);
    		i=j+1;
    	}
    	
    	printf(""%ld\n"",ans+1);
    }

",C++
1353163,"
    #include<stdio.h>
    long int a[400005],b[400005]={0};
    int main()
    {
    long int t,n,w,i,j,count,c;
    count=0;c=0;
    scanf(""%ld %ld"",&n,&w);
    for(i=1;i<=n;i++)
    {scanf(""%ld"",&a[i]);}
    if(w==1)
    {
        printf(""%ld\n"",n);return 0;
    }
    for(i=1;i<=w;i++)
    {b[a[i]]=1;
    c=c+b[a[i]-1]+b[a[i]+1];}//printf(""a%ld\n"",c);
    if(c==w-1)count++;
    for(i=w+1;i<=n;i++)
    {
    
    c=c-b[a[i-w]-1]-b[a[i-w]+1];b[a[i-w]]=0;//printf(""b%ld\n"",c);
    b[a[i]]=1;
    c=c+b[a[i]-1]+b[a[i]+1];//printf(""c%ld\n"",c);
    if(c==w-1)count++;
    }
    printf(""%ld\n"",count);
    
    return 0;
    }
    

",C
10049833,"
    import java.io.*;
    import java.util.*;
    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 m=sc.nextInt();
    			for(int i=0;i<n;i++){
    				m+=sc.nextInt();
    			
    		    }
                System.out.println(m%n==0?""Yes"":""No"");
    	    }
        }
    }

",JAVA
9634232,"
    #include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
       long int j,q;cin>>q;long int ans[q];
       for(j=0;j<q;j++){
       long int i,n,m,maxi=0,r=0;cin>>n>>m;long int a[n];
       for(i=0;i<n;i++){
       cin>>a[i];
       if(a[i]>maxi)maxi=a[i];
       }
        for(i=0;i<n;i++)r+=maxi-a[i];
        if(m>=r&&(m-r)%n==0)ans[j]=1;
        else ans[j]=0;
       }
    
       for(j=0;j<q;j++){if(ans[j]==1)cout<<""Yes\n"";
       else cout<<""No\n"";}
       return 0;
    }
    

",C++
5175164,"
    #include <iostream>
    
    using namespace std;
    
    int main()
    { int k;
    
    cin>>k;
    int l;
    for(l=0;l<k;l++)
    {
    
    
        int n;
        int m;
        int A[10];
    
        cin>>n;
    
        cin>>m;
    
        int i;
        for(i=0;i<n;i++)
        {
            cin>>A[i];
    
    
        }int max1=A[0];
        for(i=1;i<n;i++)
        {
            if(A[i]>max1)
            {
                max1=A[i];
            }
        }int q,j;
        for(i=0;i<n;i++)
        {q=max1-A[i];
            if((A[i]<max1)&&(m>0))
            {
                for(j=0;j<q;j++)
                {
                    A[i]++;
                    m--;
                }
            }
        }int t=1;
        if(m==0)
        {
            for(i=0;i<n;i++)
            {
                if(A[i]!=max1)
                {
                    t=0;
                }
            }if(t==1)
            {
                cout<<""Yes"";
            }
            else cout<<""No"";
        }
        else cout<<""No"";}
        return 0;
    }
    

",C++
5149545,"
    #include<stdio.h>
    int main()
    {
    	int t,n,m,sum;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		sum=0;
    		scanf(""%d%d"",&n,&m);
    		int a[n+1],i;
    		for(i=0;i<n;i++)
    		{
    			scanf(""%d"",&a[i]);
    		}
    			for(i=0;i<n;i++)
    		{
    			
    			sum=sum+a[i];
    		}
    		if((sum+m)%n==0)
    				printf(""Yes"");
    		else
    		printf(""No"");
    		printf(""\n"");
    	}
    	return 0;
    }

",C
7896219,"
    #include <bits/stdc++.h>
    using namespace std;
    int dp[1005][1005];
    int arr[1005];
    int main() {
    	// your code goes here
    	int i,j,k,n;
    	scanf(""%d %d"",&n,&k);
    	//cin>>n>>k;//l;
    	
    	memset(dp,0,sizeof(dp));
    	for(i=0;i<n;i++)	
    		scanf(""%d"",arr+i);
    	/*for(i=0;i<n;i++)	
    		cout<<arr[i]<<' ';
    	cout<<endl;*/	
    	for(i=0;i<n;i++){
    		for(j=i+1;j<n;j++){
    			//for(int xx=i+1;xx<=j;xx++)
    				//cout<<arr[i]%arr[j]<<endl;
    				int xx=(arr[i]%arr[j]);
    				
    				if(k==xx)
    					dp[i][j]++;
    		}
    		
    	}
    	long long int ans=0;
    	for(i=0;i<n;i++){
    		j=i;
    		while(j<n && !dp[i][j])
    			j++;
    		ans+=j-i;
    	}
    	cout<<ans<<endl;
    	/*for(i=0;i<n;i++){
    		for(j=i;j<n;j++){
    			cout<<dp[i][j]<<' ';
    		}
    		cout<<endl;
    	}*/
    		
    	return 0;
    }

",C++
10841301,"
    #include <iostream>
    #include <cstdio>
    #include <string>
    #include <algorithm>
    #include <cmath>
    #include <cstdlib>
    #include <cstring>
    #include <vector>
    #include <queue>
    #include <stack>
    using namespace std;
    #define ll long long
    const int maxn=200;
    const ll Mod=1e9+7;
    int s[100005],sum[100005];
    
    ll f(ll x,ll c)
    {
        if(x==0) return x;
        if(c==0) return s[x];
        if(x&1) return f(x/2+1,c-1);
        else return f(x/2,c-1)+f(x/2+1,c-1);
    }
    
    ll dfs(ll x,ll c)
    {
        if(x==0) return x;
        if(c==0) return sum[x];
        if(x&1) return 3*dfs(x/2+1,c-1)-s[1]-f(x/2+1,c-1);
        else return 3*dfs(x/2,c-1)-s[1]+f(x/2+1,c-1);
    }
    
    void solve()
    {
        ll n,m,a,b;
        sum[0]=0;
        scanf(""%lld%lld%lld%lld"",&n,&m,&a,&b);
        for(int i=1;i<=n;i++)
        {
            scanf(""%lld"",&s[i]);
            sum[i]=(sum[i-1]+s[i])%Mod;
        }
        ll sum1=dfs(a-1,m),sum2=dfs(b,m);
        //cout<<sum2<<' '<<sum1<<endl;
        cout<<(sum2-sum1+Mod)%Mod<<endl;
    }
    
    int main()
    {
        int T;
        scanf(""%d"",&T);
        while(T--)
            solve();
    }
    

",C++
10347883,"
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <utility>
    using namespace std;
    long long* s0;
    
    long long big = 1000000007;
    
    long long s(long long i, long long m){
       // cout<<i<<"" ""<<m<<endl;
        if(i==0){
            return 0;
        }
        if(m == 0){
    return s0[i-1];
        }
    
        if(i%2 != 0)
        {
            long long new_i = (i+1)/2;
            long long ans1 = 2*s(new_i,(m-1));
            //ans1 = ans1%big;
            ans1 = ans1 - s(1,(m-1));
            ans1 = ans1 + s((new_i-1) ,(m-1) );
                    ans1 = ans1%big;
    
            return ans1;
        }
        else
        {
            long long new_i = i/2;
            long long ans1 = 2*s(new_i,(m-1));
            //        ans1 = ans1%big;
    
            ans1 = ans1 - s(1,(m-1));
            ans1 = ans1 + s((new_i+1) ,(m-1) );
                    ans1 = ans1%big;
    
            return ans1;
        }
    }
    int main()
    {
        ios::sync_with_stdio(false);
        long long T;
        cin>>T;
        for(long long t=0;t<T;t++)
        {
            long long N;
            long long m;
            long long x;
            long long y;
            cin>>N>>m>>x>>y;
            s0 = new long long[N];
            long long temp;
            long long sum = 0;
            for(long long i=0;i<N;i++){
                cin>>temp;
                sum = sum + temp;
                sum = sum % big;
                s0[i] = sum ;
        }
    long long ans  = s(y,m) - s(x-1,m);
    cout<<ans<<endl;
        }
    
           return 0;
    
    
    }

",C++
3958736,"
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    using namespace std;
    
    struct leaf{int val,k;}arr[100000];
    bool f(leaf a,leaf b){
        return a.val<b.val;
    }
    int cnt[400000],k;
    int query(int s,int e,int p){
        if(s>k) return 0;
        if(e<=k)    return cnt[p];
        int m=(s+e)/2;
        return query(s,m,p*2)+query(m+1,e,p*2+1);
    }
    void insert(int s,int e,int p){
        if(s>k || e<k)
            return;
        if(s==e){
            cnt[p]=1;
            return;
        }
        int m=(s+e)/2;
        insert(s,m,p*2);
        insert(m+1,e,p*2+1);
        cnt[p]=cnt[p*2]+cnt[p*2+1];
    }
    int main()
    {
        int n,a,ans=0;
        scanf(""%d"",&n);
        for(int i=0;i<n;i++){
            scanf(""%d"",&a);
            arr[i]=(leaf){a,i};
        }
        sort(arr,arr+n,f);
        for(int i=0;i<n;i++){
            k=arr[i].k;
            int d=query(0,n-1,1);
            if(d==0)    ans++;
            insert(0,n-1,1);
        }
        printf(""%d\n"",ans);
        return 0;
    }
    

",C++
7387422,"
        //sourav verma   ABV IIITM
    
    #include<bits/stdc++.h>
    
    #define ll long long int
    #define loop(i,a,b) for(int i=(int)a;i<(int)b;++i)
    #define rloop(i,a,b) for(int i=(int)a;i>=(int)b;--i)
    #define loopl(i,a,b) for(ll i=(ll)a;i<(ll)b;++i)
    #define rloopl(i,a,b) for(ll i=(ll)a;i>=(ll)b;--i)
    #define rep(i,a,b) for(int i=(int)a;i<=(int)b;++i)
    #define pb push_back
    #define ab(a) (a<0)?(-1*a):a
    #define pc putchar_unlocked
    #define gc getchar_unlocked
    #define mset(a,b,c) loop(i,0,b) a[i]=c
    #define F first
    #define S second
    #define mp make_pair
    #define clr(x) x.clear()
    #define MOD 1000000007
    #define MAX 1e9
    #define MIN -1e9
    #define itoc(c) ((char)(((int)'0')+c))
    #define vi vector<int>
    #define vvi vector<vi>
    #define pll pair<ll,ll>
    #define pii pair<int,int>
    #define all(p) p.begin(),p.end()
    #define max(x,y) (x>y)?x:y
    #define min(x,y) (x<y)?x:y
    #define mid(s,e) (s+(e-s)/2)
    #define mini INT_MIN
    #define sv() int t; scanf(""%d"",&t); while(t--)
    using namespace std;
    ll gcd(ll a, ll b) {if (a == 0 || b == 0) return max(a,b); if (b % a == 0) return a; return gcd(b%a, a);}
    ll hcf(ll a, ll b) {if(b>a) return (hcf(b, a)); if(a%b==0) return b; return (hcf(b, a%b));} 
    ll modpow(ll a,ll b) {ll res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
    inline void rdi(int &n) { n=0; char c=gc(); while(c<'0' or c>'9') c=gc(); while(c>='0' and c<='9') { n=(n<<3)+(n<<1)+c-'0'; c=gc(); }}
    inline void rdl(ll &n) { n=0; char c=gc(); while(c<'0' or c>'9') c=gc(); while(c>='0' and c<='9') { n=(n<<3)+(n<<1)+c-'0'; c=gc(); }}
    inline void print(int a) { char s[20]; int i=0; do { s[i++]=a%10+'0'; a/=10; } while(a); i--; while(i>=0) pc(s[i--]); pc('\n'); }
    inline void prlong(ll a) { char s[20]; int i=0; do { s[i++]=a%10+'0'; a/=10; } while(a); i--; while(i>=0) pc(s[i--]); pc('\n'); }
    
    int main()
    {
    	sv(){
    		int n; rdi(n);
            vector<pii> a(n+1);
            vi ans(n+1);
            rep(i,1,n){
                int m; rdi(m);
                int x,y,tx,ty;
                tx=mini;
                while(m--){
                    rdi(x);rdi(y);
                    tx=max(tx,x);
                }
                a[i].first=tx;
                a[i].second=i;
            }
            sort(a.begin()+1,a.end());
            rep(i,1,n){
                ans[a[i].second]=i;
            }
            rep(i,1,n) 
                cout<<ans[i]-1<<"" "";
    	}
    	return 0;
    }

",C++
7247140,"
    #include ""bits/stdc++.h""
    
    using namespace std;
    
    struct polygon{
    	int x2, i;
    };
    
    int ans[100000];
    
    bool comp(polygon a, polygon b)
    {
    	if (a.x2>b.x2)
    	return true;
    	else
    	return false;
    }
    
    int main()
    {
    	int t;
    	cin >> t;
    	while (t-->0)
    	{
    	int m;
    	cin >> m;
    	polygon x[m];
    	for (int i = 0; i<m; i++)
    	{
    		int n;
    		cin >> n;
    		int X = -INFINITY;
    		for (int j = 0; j<n; j++)
    		{
    			int a, b;
    			cin >> a >> b;
    			X=max(a, X);
    		}
    		x[i].x2=X;
    		x[i].i=i;
    	}
    	sort(x, x+m, comp);
    	for (int i = 0; i<m; i++)
    	{
    	ans[x[i].i]=m-i-1;
    	}
    	for (int i = 0; i<m; i++)
    	cout << ans[i] << "" "";
    	cout << endl;
    	}
    	return 0;
    }

",C++
11769489,"
    #include<iostream>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    /*int fact(int n){
    	if(n<=1)
    	return 1;
    	else
    	return n*fact(n-1);
    }*/
    int main(){
    	int n,m,q,a,b,dup1=0,dup2=0,max;
    	cin>>n>>m;
    	int arr[n][m];
    	for(int i=0;i<n;i++)
    	{
    		for(int j=0;j<m;j++)
    		{
    			cin>>arr[i][j];
    		}
    	}
    	cin>>q;
    	while(q--)
    	{
    		cin>>a>>b;
    		dup1=0,dup2=0;
    		long long ans=100000000000000;
    		if(a==1&&b==1)
    		cout<<0<<endl;
    		else
    		{
    			while(dup1<=n-a)
    			{
    			while(dup2<=m-b)
    			{	
    			long long sum=0,max=0;
    			for(int i=dup1;i<dup1+a;i++)
    			{
    				for(int j=dup2;j<dup2+b;j++)
    				{
    					if(arr[i][j]>max)
    					{
    						max=arr[i][j];
    					}
    				}
    			}
    			for(int i=dup1;i<dup1+a;i++)
    			{
    				for(int j=dup2;j<dup2+b;j++)
    				{
    					sum=sum+max-arr[i][j];
    				}
    			}
    			
    				if(sum<ans)
    				{
    					ans=sum;
    				}
    				dup2++;
    			}
    				dup1++;
    				dup2=0;
    			}
    		cout<<ans<<endl;
    		}
    	
    	}
    	return 0;
    } 

",C++
2736728,"
    #include<stdio.h>
    #include<math.h>
     int m,n,i,t,j,l;
     double k;
    void swap(int a,int b)
    {
     m=b;
     n=a;
    }
    
    int main()
    {
    
        scanf(""%d"",&t);
        while(t--)
        {
         scanf(""%d %d %lf"",&m,&n,&k);
         if(m>n)
         swap(m,n);
    
           if(m==1 && n<=2)
           printf(""0\n"");
           else if(m==1)
           {   l=k;
               printf(""%d\n"",l);}
           else
           {l=ceil(k/2);
               printf(""%d\n"",l);}
    
         }
         return 0;
    }
    

",C++
7025979,"
    #include<iostream>
    using namespace std;
    int main(void)
    {
        int t;
        cin>>t;
        while(t--)
        {
            int n,flag=0;
            cin>>n;
            int c[n];
            for(int i=0;i<n;i++)
            {
                cin>>c[i];
            }
            int sum=0;
            for(int i=0;i<n;i++)
            {
                sum+=c[i];
                if(sum>n || c[i]>=n || n==1)
                {
                    flag=1;
                    break;
                }
            }
            if(sum!=n)
                flag=1;
            if(flag==1)
            {
                cout<<endl<<""-1"";
            }
            else
            {
                int v[n];
                for(int i=0;i<n;i++)
                    v[i]=0;
                for(int i=0;i<n;i++)
                {  // int j=i;
    
                    /*while(a!=0)
                    {   if(v[((j+1)%n)]==0)
                       {
                           v[((j+1)%n)]=i;
                            a--;
                           j++;
                       }
                       else
                        j++;
    
                    }*/
    
                        for(int j=i+1;j!=i;j++)
                      {
                          if(j>n-1)
                            j=0;
    
                        if(c[j]>0)
                       {
                          v[i]=j;
                         c[j]--;
                         break;
                       }
                      }
    
                  }
                cout<<endl;
                for(int i=0;i<n;i++)
                {
                    cout<<v[i]<<"" "";
                }
    
            }
        }
    
        return 0;
    }
    

",C++
7006106,"
    import itertools
    
    def myf(c):
        s = []
        for index,item in enumerate(c):
            for i in xrange(item):
                s.append(index+1)
    
        s.sort()
        s.reverse()
        size= len(s)
        for subset in itertools.permutations(s, size):
            count= 0
            #print subset
            
            for idx, item in enumerate(subset):
                
                if item!=idx+1:
                    count+=1
                else:
                    break
            if count==len(subset):
                return subset
            
            
    
    def main():
        t = int(raw_input())
        for i in xrange(t):
            ans = [0]
            n = int(raw_input())
            c = map(int, raw_input().split() )
            if sum(c) > n:
                ans = [-1]
            #print ""count of c[0]= %d  is %d"" %(c[0], c.count(c[0]))
            if sum(c) == n and c.count(c[0])!= n:
                ans = [-1]
    
            elif ans != [-1]:
    
                dup = c
    
                ans = [0] * n
                ans = myf(c)
                
            print ' '.join(map(str, ans))
    
    if __name__ == ""__main__"":
        main()
    

",PYTH
8777133,"
    #include <iostream>
    
    using namespace std;
    
    
    int main(){
    
      int ncases;
      cin >> ncases;
      for (int i = 0; i < ncases; i++){
        int k;
        cin >> k;
    
        int cur;
        cin >> cur;
        long long int max = cur;
        long long int min = cur;
        for(int j = 0; j < k - 1; j++){
          cin >> cur;
          int oldmax = max;
          int oldmin = min;
          if(cur > 0){
            max = oldmax * cur;
            min = oldmin * cur;
            if(oldmin - cur < min){
              min = oldmin - cur;
            }
            if(oldmax + cur > max){
              max = oldmax + cur;
            }
          
          }
          else{
            min = oldmax * cur;
            max = oldmin * cur;
            if(oldmin + cur < min){
              min = oldmin - cur;
            }
            if(oldmax - cur > max){
              max = oldmax + cur;
            }
          }
        }
        cout << min << endl;
      }
    }
    

",C++
9776401,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
    
            long long int n,k;
            cin>>n>>k;
            long long int a[n],b[n];
            for(int i=0;i<n;i++)
                cin>>a[i];
            for(int i=0;i<n;i++)
                cin>>b[i];
                long  double c[n];
                int  minn=INT_MAX,i;
                for( i=0;i<n;i++)
                {
                    c[i]=b[i]/a[i];
                    minn=min(minn,i);
                }
    
               cout<<b[minn]*(k/a[minn])<<endl;
    
        }
    }
    

",C++
6060097,"
    /**
     *
     * @author hit1112
     */
    import java.util.*;
    
    class main
    {
       public static void main(String []str)
      {
          Scanner s=new Scanner(System.in);
          int t,n,k,maxi = 0,i;
          t=s.nextInt();
         while(t-->0)
         {
          n=s.nextInt();
          k=s.nextInt();
          int []a=new int[n];
          int []b=new int[n];
          i=0;
          while(i<n)
              a[i++]=s.nextInt();
          i=0;
          while(i<n)
              b[i++]=s.nextInt();
          i=0;
          while(i<n)
          {
            maxi=Math.max(maxi, k/a[i]*b[i]); i++;
            }
          System.out.println(maxi);
          }
      }
    }

",JAVA
5937520,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int T;
    	long  int N,K,j,max,temp;
    	long long int *A,*B;
    	cin>>T;
    	for(int i=0; i<T; i++) {
    		cin>>N>>K;
    		A=new long long int[N];
    		B= new long long int[N];
    		for( j=0; j<N; j++) {
    			cin>>A[j];
    					}
    		for(j=0; j<N; j++) {
    			cin>>B[j];
    		    } max=(K/A[0])*B[0];  
    		for(j=1;j<N;j++)
    		{   temp=(K/A[j])*B[j];
    		    if(max< temp )
        		    max=temp;
    		}
    		    cout<<max<<endl;
    		        delete A;
    		        delete B;
    		    
    	}
    	return 0;
    }
    

",C++
1197777,"
    // File Name   : cielmap.cpp
    // Development : July 22 2012 22:58:25 IST
    // Author      : Xeronix
    
    #include <iostream>
    #include <cstdio>
    #include <vector>
    #include <math.h>
    #include <algorithm>
    #include <string>
    #include <cstring>
    #include <string.h>
    #include <cstdlib>
    #include <sstream>
    #include <stack>
    #include <queue>
    #include <numeric>
    #include <utility>
    #include <cctype>
    #include <list>
    #include <limits.h>
    #include <signal.h>
    #include <time.h>
    #include <map>
    #include <set>
    #include <float.h>
    
    #define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ ) 
    #define FOR(i, a, b) for ( i = a; i <= b; i++ )
    #define ROF(i, a, b) for ( i = a; i >= b; i-- )
    #define ALL(v) (v).begin(), (v).end()
    #define SORT(v) sort( ALL(v) )
    #define MAX(a, b) ((a) >= (b) ? (a) : (b))
    #define MIN(a, b) ((a) <= (b) ? (a) : (b))
    #define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
    #define SWAP(a, b) {typeof(a) T; T=a; a=b; b=T;}
    #define SET(x,a) memset(x,a,sizeof(x))
    
    //#define LIM
    #ifdef LIM
    	int S, D, Y;
    	char *inp, *out, *ipos, *opos, DIG[30];
    	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
    	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
    	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
            #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
    	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
    	while(D--)*opos++=DIG[D];}
    	#define PUTC(c) *opos++=c;
    	#define PUTY	*opos++='Y';*opos++='e';*opos++='s';*opos++='\n';
    	#define PUTN	*opos++='N';*opos++='o';*opos++='\n';
    #endif
    
    #define SQ(x) (x)*(x)
    #define DIST(a,b) SQ(a.x-b.x)+SQ(a.y-b.y)
    #define CP(p,q,r) ( ( p.x-r.x )*( q.y-r.y ) - ( q.x-r.x )*( p.y-r.y ) )
    
    using namespace std;
    
    struct point {
    	int x, y;
    };
    
    point min_pt;
    
    bool compare( point m, point n )
    {
    	int a = CP( m,n,min_pt );
    
    	if( !a ) {
    		return DIST(m,min_pt)> DIST(n,min_pt);
    	} 
    
    	return a > 0;
    }
    
    bool intersect( point p1, point p2, point p3, point p4 )
    {
    	int d1 = CP( p1, p3, p4 );
    	int d2 = CP( p2, p3, p4 );
    	int d3 = CP( p3, p1, p2 );
    	int d4 = CP( p4, p1, p2 );
    
    	if( ( d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0 ) && ( d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0 ) ) {
    		return true;
    	} else {
    		return false;
    	}
    }
    
    inline double solve()
    {
    	point pt[4];
    	int i, j, k, l, z;
    	int res = INT_MIN;
    
    	FOR( i,0,3 ) {
    		scanf( ""%d%d"", &pt[i].x, &pt[i].y ); 
    	}
    
    	FOR( i,0,3 ) {
    		FOR( j,0,3 ) {
    			FOR( k,0,3 ) {
    				FOR( l,0,3 ) {
    					if( i != j && i != k && i != l && j != k && j != l && k != l ) {
    						if( !intersect( pt[i], pt[j], pt[k], pt[l] ) ) {
    							point tp[4];
    							tp[0] = pt[i];
    							tp[1] = pt[j];
    							tp[2] = pt[k];
    							tp[3] = pt[l];
    
    							FOR( z,0,3 ) {
    								res = MAX( res, DIST( tp[z], tp[(z+1)%4] ) );
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    
    	/*
    	int a[4] = { 0,1,2,3 };
    	int res = INT_MIN;
    
    	do {
    		if( !intersect( pt[a[0]], pt[a[1]], pt[a[2]], pt[a[3]] ) ) {
    			FOR( j,0,3 ) {
    				res = MAX( res, DIST( pt[a[j]], pt[a[(j+1) % 4]] ) );
    			}
    		}
    	} while( next_permutation( a,a+4 ) );
    */
    	return sqrt(res);
    }
    
    int main()
    {
    	
    	int t, n, q;
    	int i, j;
    	int min_index, ch_size;
    	int r, s, a, b;
    	int cp;
    	point temp;
    
    	scanf( ""%d"", &t ); 
    
    	while ( t-- ) { 
    		scanf( ""%d"", &n ); 
    			
    		if( n == 4 ) {
    			printf( ""%.10lf\n"", solve() );
    			continue;
    		}
    
    		point pt[n+1];
    		min_pt.x = min_pt.y = INT_MAX;
    		
    		FOR( i,0,n-1 ) {
    			scanf( ""%d%d"", &pt[i].x, &pt[i].y );
    
    			if( pt[i].y == min_pt.y ? pt[i].x < min_pt.x : pt[i].y < min_pt.y ) {	
    				min_pt = pt[i];
    				min_index = i;
    			}
    		}
    		/*
    		SWAP( pt[0], pt[min_index] );
    		sort( pt+1, pt+n, compare ); 
    
    		i = 1;
    
    		//remove duplicate of pt[0]
    		while( pt[i].x == pt[0].x && pt[i].y == pt[0].y ) {
    			i++;
    		}
    		
    		j = i;
    		i = i+1;
    
    		//remove other duplicate points + take farthest point        
    		while( i < n ) {
    			if( CP( pt[i], pt[j], min_pt ) ) {	     
    				pt[++j] = pt[i];		
    			}
    			
    			i++;
    		}
    
    		j++;
    		ch_size = MIN( j,2 );
    
    		//graham scan
    		FOR( i,2,j-1 ) {
    			while( ch_size > 1 && CP( pt[i],pt[ch_size-1],pt[ch_size-2] ) >= 0 ) {
    				ch_size--;
    			}
    
    			pt[ch_size++] = pt[i];
    		}
    		
    //		FOR( i,0,ch_size-1 ) {
    //			cout<< pt[i].x << "" "" << pt[i].y << endl;
    //		}
    	*/
    		int npa, npb; //no of points on either side of possible edge
    		int max_edge = INT_MIN;
    		int td;
    		
    		FOR( i,0,n-1 ) {
    			FOR( j,i+1,n-1 ) {
    				td = DIST( pt[i], pt[j] );
    				if( td > max_edge ) {
    					max_edge = td;
    				}
    			}
    		}
    		
    		printf( ""%.10lf\n"", sqrt(max_edge) );
    	}
    
    	return 0;
    }
    

",C++
8532357,"
    #include <iostream>
    
    using namespace std;
    //Ciel Numbers
    #define limit 50000
    int main()
    {
        long long int i,j,k,temp,count=0,c3,c5,c8;
        for(i=1;; i++)
        {
            //count=0;
            c3=0;
            c5=0;
            c8=0;
            temp=i;
            //Algorithm to check whether they contain only 3,5,8
            while(temp>0)
            {
                if(temp%10==3||temp%10==5||temp%10==8)
                {
                    if(temp%10==3) c3++;
                    if(temp%10==5) c5++;
                    if(temp%10==8) c8++;
                    temp=temp/10;
                }
                else
                    break;
            }
            if(temp==0&&c8>=c5&&c5>=c3)
            {
                cout<<i<<endl;
                count++;
            }
            if(count>=limit)
                break;
    
    
        }
    
        //cout << ""Hello world!"" << endl;
        return 0;
    }
    

",C++
1191385,"
    #include<stdio.h>
    #include<stdlib.h>
    int l=0;
    int isnum(int n)
    {
    	int i=10,c=0;
    	while(n)
    	{
    	if(n%i==3 || n%i==5 || n%i==8)
    	{
    	n=n/10;
    	}
    	else
    	return 0;
    	}
    return 1;
    }
    
    int iscount(int n)
    {
    	int i=10,num3=0,num5=0,num8=0;
    	while(n)
    	{
    	if(n%i==3)
    	num3++;
    	else if(n%i==5)
    	num5++;
    	else if(n%i==8)
    	num8++;
    	else 
    	break;
    	n=n/10;
    	}
    	if(num8>0 && num5>=0 && num3>=0 && num8>=num5 && num5>=num3)
    	return 1;
    	else
    	return 0;
    }
    
    void count(int n)
    {
    int i,j,k,count=0;
    	if(isnum(n))
    	{
    	if(iscount(n))
    	{
    	printf(""%d\n"",n);
    	l++;
    	if(l>49999)
    	{
    	exit(0);
    	}
    	}
    	}
    }
    int main()
    {
    	int k=1,c=0;
    	while(1)
    	{
    	count(k++);
    //	printf(""Hello\n"");
    	}
    	
    return 0;
    }

",C
4101272,"
    #include <assert.h>
    #include <limits.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define TARGET 'W'
    #define PAINTED '.'
    
    struct pair {
        unsigned int row;
        unsigned int col;
    };
    
    
    /*
    static void print_pair(const struct pair the_pair)
    {
        printf(""(%u, %u)\n"", the_pair.row, the_pair.col);
    }
    */
    
    
    struct bounds {
        unsigned int min_row;
        unsigned int max_row;
        unsigned int min_col;
        unsigned int max_col;
        /*@null@*/ struct bounds* next;
    };
    
    
    /*
    static void print_bounds(const struct bounds bounding_box)
    {
        printf(
                ""(%u, %u), (%u, %u)\n"",
                bounding_box.min_row,
                bounding_box.min_col,
                bounding_box.max_row,
                bounding_box.max_col);
        if (bounding_box.next != NULL)
        {
            print_bounds(*bounding_box.next);
        }
    }
    */
    
    
    static void delete_bounds(struct bounds* bounding_box)
    {
        struct bounds* next;
        while (bounding_box->next != NULL)
        {
            next = bounding_box->next;
            free(bounding_box);
            bounding_box = next;
        }
        free(bounding_box);
    }
    
    static void init_bounds(struct bounds* bounding_box)
    {
        bounding_box->min_row = UINT_MAX;
        bounding_box->min_col = UINT_MAX;
        bounding_box->max_row = 0;
        bounding_box->max_col = 0;
        bounding_box->next = NULL;
    }
    
    struct board
    {
        unsigned int num_rows;
        unsigned int num_cols;
        char **data;
    };
    
    
    /*
    static void print_board(const struct board* game_board)
    {
        unsigned int row;
        unsigned int col;
        printf(""# Game Board\n"");
        printf(""%u %u\n"", game_board->num_rows, game_board->num_cols);
        for (row=0; row<game_board->num_rows; row++)
        {
            for (col=0; col<game_board->num_cols; col++)
            {
                printf(""%c"", game_board->data[row][col]);
            }
            printf(""\n"");
        }
    }
    */
    
    
    static struct board* allocate_board_from_stream(FILE* stream)
    {
        int ret;
        char value;
        unsigned int row;
        unsigned int col;
        char **data;
        char *row_data;
        struct board* game_board;
        unsigned int num_rows;
        unsigned int num_cols;
        /* Board size */
        ret = fscanf(stream, ""%u %u\n"", &num_rows, &num_cols);
        assert(ret == 2);
        data = malloc(num_rows * sizeof(char*));
        assert(data!=NULL);
        /* Read the test case. */
        for (row=0; row<num_rows; row++)
        {
            row_data = malloc(num_cols * sizeof(char));
            assert(row_data!=NULL);
            for (col=0; col<num_cols; col++)
            {
                ret = fscanf(stream, ""%c"", &value);
                assert(ret == 1);
                assert(value=='W' || value=='B');
                row_data[col] = value;
            }
            ret = fscanf(stream, ""%c"", &value);
            assert(ret == 1);
            assert(value=='\n');
            data[row] = row_data;
        }
        /* Assumble board */
        game_board = malloc(sizeof(struct board));
        assert(game_board!=NULL);
        game_board->num_rows = num_rows;
        game_board->num_cols = num_cols;
        game_board->data = data;
        return game_board;
    }
    
    
    static void delete_game_board(/*@only@*/ struct board* game_board)
    {
        unsigned int row;
        for (row=0; row<game_board->num_rows; row++)
        {
            free(game_board->data[row]);
        }
        free(game_board);
    }
    
    
    static void paint_board(
            struct board* game_board,
            unsigned int row,
            unsigned int col,
            char from,
            char to,
            struct bounds* bounding_box)
    {
        assert(row <= game_board->num_rows);
        assert(col <= game_board->num_cols);
        /* Terminate recursion or update current loction */
        if (game_board->data[row][col] != from)
        {
            return;
        }
        game_board->data[row][col] = to;
        /* Update bounds */
        if (row > bounding_box->max_row)
        {
            bounding_box->max_row = row;
        }
        if (row < bounding_box->min_row)
        {
            bounding_box->min_row = row;
        }
        if (col > bounding_box->max_col)
        {
            bounding_box->max_col = col;
        }
        if (col < bounding_box->min_col)
        {
            bounding_box->min_col = col;
        }
        /* Perform BFS in each of the four directions */
        if (row > 0)
        {
            paint_board(game_board, row-1, col, from, to, bounding_box);
        }
        if (row < game_board->num_rows-1)
        {
            paint_board(game_board, row+1, col, from, to, bounding_box);
        }
        if (col > 0)
        {
            paint_board(game_board, row, col-1, from, to, bounding_box);
        }
        if (col < game_board->num_cols-1)
        {
            paint_board(game_board, row, col+1, from, to, bounding_box);
        }
    }
    
    
    static void paint_edge(struct board* game_board, char from, char to)
    {
        unsigned int index;
        struct bounds bounding_box;
        init_bounds(&bounding_box);
        for (index=0; index<game_board->num_cols; index++)
        {
            paint_board(game_board, 0, index, from, to, &bounding_box);
            paint_board(game_board, game_board->num_rows-1, index, from, to, &bounding_box);
        }
        for (index=0; index<game_board->num_rows; index++)
        {
            paint_board(game_board, index, 0, from, to, &bounding_box);
            paint_board(game_board, index, game_board->num_cols-1, from, to, &bounding_box);
        }
    }
    
    
    static struct bounds* find_group_bounds(struct board* game_board, char target)
    {
        unsigned int row;
        unsigned int col;
        struct bounds *bounding_box;
        struct bounds *head;
        head = NULL;
        for (row=0; row<game_board->num_rows; row++)
        {
            for (col=0; col<game_board->num_cols; col++)
            {
                bounding_box = malloc(sizeof(struct bounds));
                assert(bounding_box != NULL);
                init_bounds(bounding_box);
                if (game_board->data[row][col] != target)
                {
                    continue;
                }
                paint_board(game_board, row, col, target, PAINTED, bounding_box);
                if (head == NULL)
                {
                    head = bounding_box;
                }
                else
                {
                    bounding_box->next = head;
                    head = bounding_box;
                }
            }
        }
        return head;
    }
    
    
    static struct pair* solve_bounds(
            struct bounds* all_bounds, unsigned int num_rows, unsigned int num_cols)
    {
        unsigned int row;
        struct bounds* all_index;
        struct bounds* miss_list;
        struct bounds* miss_index;
        struct bounds* copy;
        unsigned int min_max = UINT_MAX;
        unsigned int max_min = 0;
        struct pair* solution;
        for (row=0; row < num_rows; row++)
        {
            /* Copy bounds that not handled by the current row selection. */
            miss_list = NULL;
            for (all_index=all_bounds; all_index!=NULL; all_index=all_index->next)
            {
                if (row >= all_index->min_row-1 && row <= all_index->max_row+1)
                {
                    continue;
                }
                copy = malloc(sizeof(struct bounds));
                assert(copy != NULL);
                memcpy(copy, all_index, sizeof(struct bounds));
                copy->next = miss_list;
                miss_list = copy;
            }
            /* Success if the row covered everything. */
            if (miss_list == NULL)
            {
                solution = malloc(sizeof(struct pair));
                assert(solution != NULL);
                solution->row = row;
                solution->col = 0;
                return solution;
            }
            /* Calculate the span of remaining bound columns */
            max_min = miss_list->min_col;
            min_max = miss_list->max_col;
            for (miss_index=miss_list; miss_index!=NULL; miss_index=miss_index->next)
            {
                if (miss_index->min_col > max_min)
                {
                    max_min = miss_index->min_col;
                }
                else if (miss_index->max_col < min_max)
                {
                    min_max = miss_index->max_col;
                }
            }
            delete_bounds(miss_list);
            /* Success if other chunks can be handled by a single column. */
            if (max_min-2 <= min_max)
            {
                solution = malloc(sizeof(struct pair));
                assert(solution != NULL);
                solution->row = row;
                solution->col = min_max + 1;
                return solution;
            }
        }
        return NULL;
    }
    
    
    int main()
    {
        unsigned int num_test_cases;
        int ret;
        struct board* game_board;
        struct bounds* bounds_list;
        struct pair *solution;
        /* Number of test cases. */
        ret = fscanf(stdin, ""%u\n"", &num_test_cases);
        assert(ret == 1);
        /* Read test case. */
        for (; num_test_cases > 0; num_test_cases--)
        {
            game_board = allocate_board_from_stream(stdin);
            paint_edge(game_board, TARGET, PAINTED);
            bounds_list = find_group_bounds(game_board, TARGET);
            if (bounds_list == NULL)
            {
                printf(""YES\n"");
                delete_game_board(game_board);
                return 0;
            }
            solution = solve_bounds(
                    bounds_list, game_board->num_rows, game_board->num_cols);
            if (solution != NULL)
            {
                printf(""YES\n"");
                free(solution);
            }
            else
            {
                printf(""NO\n"");
            }
            delete_game_board(game_board);
            delete_bounds(bounds_list);
        }
        return 0;
    }
    

",C
5188161,"
    #include<stdio.h>
    #include<math.h>
    
    int main(){
    	long N,i;
    	int t,a[100001];
    	long L,R;
    	long long M,prod=1;
    	scanf(""%ld"",&N);
    	for(i=0;i<N;i++){
    		scanf(""%d"",&a[i]);
    	}
    	//for(i=0;i<N;i++){
    	//	printf(""%d "",a[i]);
    	//}//printf(""\n"");
    	scanf(""%d"",&t);
    	while(t--){
    		scanf(""%ld%ld%lld"",&L,&R,&M);
    		//printf(""%ld %ld %lld \n"",L,R,M);
    		prod=1;
    		for(i=L-1;i<=R-1;i++){
    			prod=(prod*a[i])%M;
    		}
    		
    		printf(""%lld\n"",prod);
    		
    	}
    
    	printf(""\n"");
    	
    	return 0;
    }

",C
2731865,"
    #include<stdio.h>
    //#include<conio.h>
    #include<stdlib.h>
    int main(){
     int t,n,i,*arr,l,r,pro=1;
     long long m;
     int start[101]={0};
     
     //  memset(start,0,sizeof(start));        
      
       scanf(""%d"",&n);           
      
       arr=(int*)malloc(n*sizeof(int));
       
       for(i=0;i<n;i++){
      
        scanf(""%d"",&arr[i]);
       }
       
       scanf(""%d"",&t);
       
       while(t--){///queries
         pro=1;
         
         scanf(""%d%d%lld"",&l,&r,&m);  
         
         if(l==r)
         pro=arr[l-1]*arr[l-1]%m;
         else{
          pro=1;
          for(i=l-1;i<r;i++)
          {
             pro=(pro*arr[i])%m;
             //if(arr[i]==r)
            // break;
          }  
         }
         printf(""%d\n"",pro);      
       }   
    // getch();
     return 0;    
    }
    

",C++
9974160,"
    #include <bits/stdc++.h>
    using namespace std;
    unsigned long long C(unsigned long long n,unsigned long long r) {
        if(r > n / 2) r = n - r; // because C(n, r) == C(n, n - r)
        unsigned long long ans = 1;
        int i;
     
        for(i = 1; i <= r; i++) {
            ans *= n - r + i;
            ans /= i;
        }
     
        return ans;
    }
    int main()
    {
    	//ios::sync_with_stdio(0);
    	int T;
    	scanf(""%d"",&T);
    	while (T--)
    	{
    		unsigned long long n, k;
    	//	cin>>n>>k;
    		scanf(""%lld%lld"",&n,&k);
    		printf(""%lld\n"",C(n,k));
    	}
    }  

",C++
7299140,"
    //good qustn
    #include<iostream>
    using namespace std;
    long long int Gcd(long long int a,long long int b)
    {
    	if(b==0)
    	return a;
    	else
    	return Gcd(b,a%b);
    }
    int main()
    {
    	long long int test,n,i,ans,k,gcd;
    	cin>>test;
    	while(test--)
    	{
    		cin>>n>>k;
    		ans=1; i=1;
    		while(i<=k)
    		{
    			gcd=Gcd(ans,i);
    			ans/=gcd;
    			ans*=(n-i+1);
    			ans/=(i/gcd);
    			i++;
    		}
    		if(k>n)
    		cout<<""0\n"";
    		else
    		cout<<ans<<endl;
    	}
    	return 0;
    }

",C++
2981383,"
    #include<stdio.h>
    typedef unsigned long long ll;
    ll gcd(ll a,ll b)
    {
    //	if(b==0ll)return a;
    //	else return gcd(b,a%b);
    	ll t=0ll;
    	while (b>0ll)
    	{
    		t=a%b;
    		a=b;
    		b=t;
    	}
    	return a;
    }
    
    ll C(ll n, ll k)
    {
    	ll res = 1ll;
    	if ( k > n - k )
    		k = n - k;
    	for (ll i = 1ll; i <= k; ++i)
    	{
    		ll num=gcd(res,i);
    		res /= num;
    		res *= (n-i+1ll)/(i/num);
    	}
    	return res;
    }
    
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--) {
    		ll n,k;
    		scanf(""%llu%llu"",&n,&k);
    		printf(""%llu\n"",C(n,k));
    	}
    	return 0;
    }

",C++
7572029,"
    #include<stdio.h>
    
    float ans;
    
    
    
    
    int ary[100][3];
    
    float f_p(int n)
    
    {
    
     if(!ary[n][0])
    
     {
    
      return ans;
    
     }
    
     if(ary[n][0]==1)
    
     {
    
      return 1-((1-f_p(ary[n][1]))*(1-f_p(ary[n][2])));
    
     }
    
     else
    
     {
    
      return (f_p(ary[n][1]))*(f_p(ary[n][2]));
    
     }
    
    }
    
    int main()
    
    {
    
     int t,i,n;
    
     float p;
    
     for(scanf(""%d"",&t);t--;)
    
     {
    
      printf(""\n"");
    
      scanf(""%d"",&n);
    
      for(i=1;i<=n;++i)
    
      {
    
    
    
    
        scanf(""%d"",&ary[i][0]);
    
        if(ary[i][0])
    
    
          scanf(""%d %d"",&ary[i][1],&ary[i][2]);
    
      }
    
      p=1,ans=0;
    
      while((p/=10)>(.000001))
    
      {
    
       ans+=p;
    
    
    
       while(f_p(n)<=.5)
    
       {
    
        ans+=p;
    
       }
    
       ans-=p;
    
    
    
    
      }
    
      printf(""%.5f\n"",ans);
    
     }
    
     return 0;
    
    }
    

",C++
3366957,"
    #include<iostream>
    #include<string>
    #include<cmath>  //sin for radians
    #include<vector>
    using namespace std;
    #define repeat(x) for(int _iterator_i = 0, _iterator_limit = x; _iterator_i < _iterator_limit; _iterator_i ++)
    unsigned int test=0;
    class point {
    	public :
    	float x;
    	float y;
    	point(){
    		x=0;y=0;
    	}
    	point(float a,float b){
    		x=a;y=b;
    	}
    };
    
    class space {
    	vector <point> points;
    	unsigned int count;
    	public :
    	space(vector<point>& p){
    		points=p;count=0;
    	}
    	bool circle(point a,point b,point c){//cout<<""hi1"";
    		if(b.x==a.x || b.x==c.x){
    			if(b.x==c.x && a.x==b.x)return false;
    			else {return true;}
    		}
    		float slope1 = (b.y-a.y)/(b.x-a.x);
    		float slope2 = (b.y-c.y)/(b.x-c.x);
    		if(slope1!=slope2){return true;}
    		/*cout<<""circlefalse"";*/return false;
    	}
    	float distance(point a,point b){
    		return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
    	}
    	bool die(point a,point b,point c,point d){//d is ash and abc are tr
    		float A=distance(c,b);//cout<<""die""<<endl;
    		float B=distance(c,a);
    		float C=distance(a,b);//cout<<C<<endl;
    		float anglea,angleb,anglec;
    		anglea=acos((B*B+C*C-A*A)/(2*B*C));//cout<<anglea<<endl;
    		angleb=acos((A*A+C*C-B*B)/(2*A*C));
    		anglec=acos((B*B+A*A-C*C)/(2*B*A));
    		anglea=sin(anglea*2);angleb=sin(angleb*2);anglec=sin(anglec*2);
    		if(anglea < 0.000001)anglea=0;
    		if(angleb < 0.000001)angleb=0;
    		if(anglec < 0.000001)anglec=0;
    		
    		point f;
    		f.x=(a.x*anglea+b.x*angleb+c.x*anglec)/(anglea+angleb+anglec);
    		f.y=(a.y*anglea+b.y*angleb+c.y*anglec)/(anglea+angleb+anglec);
    		if(f.x <0.0001)f.x=0;
    		if(f.y<0.0001)f.y=0;
    		if(distance(f,d) <= distance (f,a))return true;
    		return false;
    	
    	
    	
    	
    	}			
    	unsigned int handle(){
    		for(int a=0;a<points.size()-2;a++){
    			for(int b=a+1;b<points.size()-1;b++){
    				for(int c=b+1;c<points.size();c++){
    					if(circle(points[a],points[b],points[c])){
    						for(int d=0;d<points.size();d++){
    							if(d!=a && d!=b && d!=c ){test++;
    								if(die(points[a],points[b],points[c],points[d]))count++;
    							}
    						}
    					}
    				}
    			}
    		}
    	return count;
    	}
    	
    		
    		
    		
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    };
    int factorial(int n)
    {
      return (n == 1 || n == 0) ? 1 : factorial(n - 1) * n;
    }
    float ncr(int n,int r){
    	return factorial(n)/((factorial(n-r))*(factorial(r)));
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    int main(){
    	
    	unsigned int testcases;
    	cin>>testcases;int noofpoints,count=0;point ptemp;
    	repeat(testcases){
    		vector<point> input;
    		count=0;
    		cin>>noofpoints;
    		repeat(noofpoints){
    			cin>>ptemp.x>>ptemp.y;
    			input.push_back(ptemp);
    		}
    		space s(input);count+=s.handle();
    		//cout<<test<<"" ""<<count<<endl;
    		cout<<count/(4*ncr(noofpoints,4))<<endl;
    			
    	
    	
    	
    	
    	}
    		
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    return 0;
    }
    

",C++
2385942,"
    import java.util.Arrays;
    import java.util.StringTokenizer;
    import java.io.*;
    class cirkill
    {
      static int x1,x2,x3,x4,y1,y2,y3,y4,counter=0;
      static boolean flag=false;
      static PrintWriter out=new PrintWriter(System.out);
     static  int area=0;
    public static void main(String[] args)throws IOException
    {	
    	BufferedReader ds=new BufferedReader(new InputStreamReader(System.in));
    	
    	cirkill obj=new cirkill();
    	int t=Integer.parseInt(ds.readLine());
    	for(;t>0;t--)
    	{	int count=0;counter=0;
    		int n=Integer.parseInt(ds.readLine());
    		int ar[][]=new int[n][2];
    		for(int q=0;q<n;q++)
    		{
    			StringTokenizer s=new StringTokenizer(ds.readLine());
    			ar[q][0]=Integer.parseInt(s.nextToken());
    			ar[q][1]=Integer.parseInt(s.nextToken());
    		}
    		
    		for(int i=0;i<n-2;i++)
    		{
    			for(int j=i+1;j<n-1;j++)
    			{
    				for(int p=j+1;p<n;p++)
    					{
    						
    						
    						 x1=ar[i][0];
    						 y1=ar[i][1];
    						 x2=ar[j][0];
    						 y2=ar[j][1];
    						 x3=ar[p][0];
    						 y3=ar[p][1];
    						 area=x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2);
    						 if(area!=0)
    						 {
    						for(int l=0;l<n;l++)
    						{	if(l!=i&&l!=j&&l!=p)
    							 {
    							 x4=ar[l][0];
    							 
    							 y4=ar[l][1];
    							//out.println(x1+"" ""+y1+""  ""+x2+"" ""+y2+""  ""+x3+"" ""+y3+""  ""+x4+"" ""+y4);
    							  double a=-((x1*x1+y1*y1)*(y2-y3)+(x2*x2+y2*y2)*(y3-y1)+(x3*x3+y3*y3)*(y1-y2));
    								a=a/area;
    								double g=a/2;
    								double h=-g;
    								double b=(x1*x1+y1*y1)*(x2-x3)+(x2*x2+y2*y2)*(x3-x1)+(x3*x3+y3*y3)*(x1-x2);
    								b=b/area;
    								double f=b/2;
    								double k=-f;
    								double c=-((x1*x1+y1*y1)*(x2*y3-x3*y2)+(x2*x2+y2*y2)*(x3*y1-x1*y3)+(x3*x3+y3*y3)*(x1*y2-x2*y1));
    								c=c/area;
    								double r1=g*g+f*f-c;
    								//out.println(r1);
    								double r2=(x4-h)*(x4-h)+(y4-k)*(y4-k);
    								//out.println(r2);
    								//out.println(h+"" ""+k);
    								if(r1-r2>=-0.000001)
    									{//if(r2<r1)
    									//out.println(""in the circle"");
    									//else
    										//out.println(""on the circle"");
    									counter++;
    									}
    								//int result=(int) ((x4*x4)+(y4*y4)+a*x4+b*y4+c);
    								//out.println(result);
    								//if(result==0)
    									//counter++;
    								
    							  
    							//out.println();
    							count++;
    							 }
    						}
    						 }
    					}
    			}
    		}
    		count = (n * (n - 1) * (n - 2) * (n - 3)) / 6;
    		//out.println(counter+"" ""+count);
    		
    		out.println((double)counter/count);
    	}
    	
    	out.close();
    }
    
    
    }

",JAVA
2383201,"
    #include<iostream>
    //using namespace std;
    int main()
    {int t, n, i, j, k, l, flag;
    double m1, m2, x[31], y[31], ans, a, b, r, pos, kill, total, eps=0.000001;
    scanf(""%d"",&t);
    while(t--)
    {scanf(""%d"",&n);
    ans=pos=m1=m2=a=b=0;
    kill=total=0;
    for(i=0;i<n;i++)
    scanf(""%lf%lf"",&x[i],&y[i]);
    for(i=0;i<n;i++)
    for(j=i+1;j<n;j++)
    for(k=j+1;k<n;k++)
    {m1=(y[j]-y[i])/(x[j]-x[i]);
    m2=(y[k]-y[j])/(x[k]-x[j]);
    flag=0;
    total=total+(n-3);
    if((m1==m2) || ((y[j]-y[i]==0) && (y[k]-y[j]==0)) || ((x[j]-x[i]==0) && (x[k]-x[j]==0)))
    continue;
    if(y[j]-y[i]==0)
    {//if(y[k]-y[j]==0)
    //continue;
    //else 
    if(x[k]-x[j]==0)
    {a=(x[i]+x[k])/2;
    b=(y[i]+y[k])/2;
    flag=1;}
    else if(x[i]-x[k]==0)
    {a=(x[j]+x[k])/2;
    b=(y[j]+y[k])/2;
    flag=1;}
    else 
    {flag=2;
    m1=(y[k]-y[j])/(x[k]-x[j]);
    m2=(y[k]-y[i])/(x[k]-x[i]);
    a=(m1*m2*(y[i]-y[j])+m1*(x[i]+x[k])-m2*(x[k]+x[j]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[k]-x[j])/2)+(y[k]+y[j])/2;}
    }
    else 
    if(y[k]-y[j]==0)
    {//if(y[i]-y[j]==0)
    //continue;
    //else 
    if(x[i]-x[j]==0)
    {a=(x[i]+x[k])/2;
    b=(y[i]+y[k])/2;
    flag=1;}
    else if(x[i]-x[k]==0)
    {a=(x[j]+x[i])/2;
    b=(y[j]+y[i])/2;
    flag=1;}
    else
    {flag=2;
    m1=(y[k]-y[i])/(x[k]-x[i]);
    m2=(y[j]-y[i])/(x[j]-x[i]);
    a=(m1*m2*(y[j]-y[k])+m1*(x[i]+x[j])-m2*(x[k]+x[i]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[k]-x[i])/2)+(y[k]+y[i])/2;}
    }
    else 
    if(y[k]-y[i]==0)
    {//if(y[k]-y[j]==0)
    //continue;
    //else 
    if(x[k]-x[j]==0)
    {a=(x[i]+x[j])/2;
    b=(y[i]+y[j])/2;
    flag=1;}
    else if(x[i]-x[j]==0)
    {a=(x[j]+x[k])/2;
    b=(y[j]+y[k])/2;
    flag=1;}
    else
    {flag=2;
    a=(m1*m2*(y[k]-y[i])+m1*(x[j]+x[k])-m2*(x[i]+x[j]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[i]-x[j])/2)+(y[i]+y[j])/2;}
    }
    else
    if(x[j]-x[i]==0)
    {flag=3;
    m1=(y[k]-y[j])/(x[k]-x[j]);
    m2=(y[k]-y[i])/(x[k]-x[i]);
    a=(m1*m2*(y[i]-y[j])+m1*(x[i]+x[k])-m2*(x[k]+x[j]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[k]-x[j])/2)+(y[k]+y[j])/2;}
    else
    if(x[k]-x[j]==0)
    {flag=3;
    m1=(y[k]-y[i])/(x[k]-x[i]);
    m2=(y[j]-y[i])/(x[j]-x[i]);
    a=(m1*m2*(y[j]-y[k])+m1*(x[i]+x[j])-m2*(x[k]+x[i]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[k]-x[i])/2)+(y[k]+y[i])/2;}
    else
    if(x[k]-x[i]==0)
    {flag=3;
    a=(m1*m2*(y[k]-y[i])+m1*(x[j]+x[k])-m2*(x[i]+x[j]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[i]-x[j])/2)+(y[i]+y[j])/2;}
    
    
    
                    
    
    
    /*if((x[j]-x[i]==0) || (y[j]-y[i]==0))
    m1=0;
    if((x[k]-x[j]==0) || (y[k]-y[j]==0))
    m2=0;*/
    
    if(!flag)
    {a=(m1*m2*(y[k]-y[i])+m1*(x[j]+x[k])-m2*(x[i]+x[j]))/(2*(m1-m2));
    b=(-1/m1)*((2*a-x[i]-x[j])/2)+(y[i]+y[j])/2;
    }
    
    
    //a=((x[i]*x[i]+y[i]*y[i])*(y[j]-y[k])+(x[j]*x[j]+y[j]*y[j])*(y[k]-y[i])+(x[k]*x[k]+y[k]*y[k])*(y[i]-y[j]))/(2*(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])));
    //b=((x[i]*x[i]+y[i]*y[i])*(x[k]-x[j])+(x[j]*x[j]+y[j]*y[j])*(x[i]-x[k])+(x[k]*x[k]+y[k]*y[k])*(x[j]-x[i]))/(2*(x[i]*(y[j]-y[k])+x[j]*(y[k]-y[i])+x[k]*(y[i]-y[j])));
    //a=(y[k]*(x[j]*x[j]+y[j]*y[j])-y[j]*(x[k]*x[k]+y[k]*y[k]))/(2*(x[j]*y[k]-y[j]*x[k]));
    //b=(x[j]*(x[k]*x[k]+y[k]*y[k])-x[k]*(x[j]*x[j]+y[j]*y[j]))/(2*(x[j]*y[k]-y[j]*x[k]));
    r=(x[i]-a)*(x[i]-a)+(y[i]-b)*(y[i]-b);
    for(l=0;l<n;l++)
    {if((l==i) || (l==j) || (l==k))
    continue;
    pos=(x[l]-a)*(x[l]-a)+(y[l]-b)*(y[l]-b)-r;
    if(pos<=eps)
    {kill++;
    //printf(""%lf %lf %lf %lf %lf %lf %lf %lf %lf\n"",x[i],y[i],x[j],y[j],x[k],y[k],x[l],y[l],pos);}
    }
    }          
    ans=kill/total;
    printf(""%.6lf\n"",ans); 
    //cout<<ans<<""\n"";                           
    }    
    return 0;}
    

",C++
10454993,"
    //Two strings ?
    import java.io.*;
    import java.util.*;
    
    class TwoString{
    public static void main(String args[]) throws IOException{
    InputStreamReader r = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(r);
           
           int T = Integer.parseInt(br.readLine());
    		
    		while(T!=0){
    			String s = br.readLine();
           		String t = br.readLine();
    			int min = 0,max = 0;
    			int n = s.length();
    			for(int i=0;i<n;i++){
    				if((s.charAt(i)=='?' || t.charAt(i)=='?'))
    					max++;
    				else if(s.charAt(i)!=t.charAt(i)){
    					min++;
    					max++;
    				}
    			}
    			StringBuffer output = new StringBuffer();
    			output.append(min).append("" "");
    			output.append(max);
    		
    			
    			System.out.println(output);
    			T--;
    		}
    		   	
    	}
    } 

",JAVA
10034910,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.TreeSet;
    
    public class Main {
    	static BufferedReader in = new BufferedReader( new InputStreamReader(System.in));
    	public static void main(String[] args) throws IOException {
    		int T = Integer.parseInt(in.readLine());
    		for (int i=0;i<T;i++){
    			String T1 = in.readLine();
    			String T2 = in.readLine();
    			char[] charArray1 = T1.toCharArray();
    			char[] charArray2 = T2.toCharArray();
    			int differencies = 0;
    			int similarities = 0;
    			TreeSet<Integer> max = new TreeSet<Integer>();
    			TreeSet<Integer> min = new TreeSet<Integer>();
    			for (int j=0; j<charArray1.length;j++){
    				if(charArray1[j]!=charArray2[j]) max.add(++differencies);
    				else{
    					if(charArray1[j]=='?' || charArray2[j]=='?') max.add(++differencies);
    					else continue;
    				}
    			}
    			for (int j=0; j<charArray1.length;j++){
    				if(charArray1[j]==charArray2[j]) min.add(++similarities);
    				else{
    					if(charArray1[j]=='?' || charArray2[j]=='?') min.add(++similarities);
    					else continue;
    				}
    			}
    			System.out.println(charArray2.length-min.last() + "" "" + max.last());
    		}
    	}
    }

",JAVA
9765110,"
    #include<stdio.h>
    #include<iostream>
    
    using namespace std;
    
    int main()
    {
    	int times,count1,count2,max,min;
    	string s1,s2;
    	scanf(""%d"",&times);
    	
    	while(times--)
    	{
    		cin >> s1 >> s2;
    		count1 = count2 = 0;			// count1 is the counter for ?, count2 is the counter for differences.
    		for(int i=0;i<s1.length(); i++)
    		{
    			if(s1[i]==s2[i] && s1[i]!='?')
    				count1++;
    			if(s1[i]!=s2[i] && s1[i]!='?' && s2[i]!='?')
    				count2++;
    		}
    		cout <<  count2++ << "" ""<< s1.length()-count1 << endl;
    	}
    }
    

",C++
8068726,"
    #include<bits/stdc++.h>
    
    using namespace std;
     int main()
     {
     	int t;
     	cin>>t;
     	while(t--)
     	{string s1[100],s2[100];int count=0,del=0;
     	cin>>s1[t];cin>>s2[t];
     	for(int i=0;i<s1[t].size();i++)
     		{if(s1[t][i]!=s2[t][i]&&s1[t][i]!='?'&&s2[t][i]!='?')
     			{
     				++count;
    			}else if(s1[t][i]==s2[t][i]&&s1[t][i]!='?'&& s2[t][i]!='?')++del;
    		 }
    		 
    		 cout<<count<<"" ""<<(s1[t].size()-del);
     		
    	 }
     }

",C++
1197099,"
    #include<iostream>
    #include<cstdio>
    #include<cmath>
    #include<cstring>
    #include<string>
    #include<map>
    #include<set>
    #include<sstream>
    #include<vector>
    #include<algorithm>
    #include<list>
    #include<queue>
    #include<stack>
    
    #define NN 550
    
    #define inf 1<<30
    
    #define maxv(A,B) (A>B?A:B)
    #define minv(A,B) (A>B?B:A)
    
    
    
    using namespace std;
    
    vector< pair<int,int> > g[NN];
    
    long long way[NN];
    int d[NN],par[NN];
    
    
    int main()
    {
    	int i,j,k,m,n,u,v,test,c,cc;
    	 scanf(""%d"",&test);
    	while( test-- )
    	{
    		scanf(""%d %d"",&n,&m);
    		for( i=0;i<=n;i++ )
    		{
    			d[i] =inf;
    			g[i].clear();
    			par[i]=-1;
    			way[i]=0;
    		}
    		for( i=0;i<m;i++ )
    		{
    			scanf(""%d %d %d"",&u,&v,&c);
    			u--;v--;
    			g[u].push_back( make_pair(v,c) );
    			g[v].push_back( make_pair(u,c) );
    		}
    		queue<int> q;
    		q.push(0);
    		d[0]=0;
    		way[0]=1;
    		while( !q.empty() )
    		{
    			u=q.front();
    			q.pop();
    			for( i=0;i<g[u].size();i++ )
    			{
    				v=g[u][i].first;
    				cc=g[u][i].second;
    				if( d[u]+cc<d[v])
    				{
    					d[v]=d[u]+cc;
    					par[v]=u;
    					q.push(v);
    					way[v]=way[u];
    				}
    				else if( d[u]+cc==d[v]  )
    				{
    					way[v]+=way[u];
    				}
    
    			}
    		}
    		printf(""%lld\n"",way[n-1]);
    
    	}
    	return 0;
    }

",C++
8973907,"
    import java.io.*;
    import java.util.*;
    
    class Chef{
    
    	public static void main(String[] args) {
    		
    		Scanner sc=new Scanner(System.in);
    		int n=sc.nextInt();
    		int [] array=new int[n];
    
    		for(int i=0;i<n;i++){
    
    			array[i]=sc.nextInt();
    
    		}
    		int cnt=0,max=-1;
    		for(int i=0;i<n;i++){
    
    			if(array[i]==0){
    
    				if(max<cnt){
    					max=cnt;
    				}
    				cnt=0;
    			}
    			else{
    
    				cnt++;
    			}
    		}
    		if(cnt>max)
    			max=cnt;
    		System.out.println(max);
    	}
    }

",JAVA
7728111,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int num;
    	long long int n,ans1,ans,i;
    	scanf(""%lld"",&n);
    	ans=ans1=0;
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&num);
    		if(i==0)
    		{
    			if(num!=0)
    			ans=ans1=1;
    		}
    		else
    		{
    			if(num!=0)
    			{
    				ans1++;
    				if(ans1>ans)
    				ans=ans1;
    			}
    			else ans1=0;
    		}
    	}
    	printf(""%lld\n"",ans);
    	return 0;
    	
    }

",C++
5624866,"
    #include<stdio.h>
    #include<iostream>
    #include<string.h>
    #include<math.h>
    #include<stdlib.h>
    
    using namespace std;
    
    int compare (const void * a, const void * b)
    {
    	return ( *(int*)a - *(int*)b );
    }
     
    int i=0,j=0;
    
    
    #define REP(i, a, b, c) for(i=a;i<b;i+=c)
    #define rep(i,n) REP(i, 0, n, 1)
    #define sort(arrr,n) qsort(arrr,n,sizeof(int),compare)
    #define MIN(a,b) (((a)<(b))?(a):(b))
    #define MAX(a,b) (((a)>(b))?(a):(b))
    #define Minimum(a, b, c) (min(min(a, b), c))
    #define Maximum(a, b, c) (max(max(a, b), c))
    #define mod(n) ((n>0)?n:-n)
    
    
    int a[100002],b[100002];
    int main()
    {
    	int n;
     	cin>>n;
     	j=0;
     	for(i=0;i<100002;i++)
     	{
     		a[i]=0;
     		b[i]=0;
     	}
     	for(i=0;i<n;i++)
     	{
    	 	cin>>a[i];
    	}
    	int res=0;
    	for(i=0;i<n;i++)
    	{
    		if(a[i]!=0)
    		{
    			b[j]++;
    		}
    		if(a[i]==0)
    		{
    			j++;
    			res=MAX(res,b[j-1]);
    		}
    	}
    	cout<<res<<endl;
     	return 0;
    }
    

",C++
4560571,"
    #include <bits/stdc++.h>
    #define MAX 100005
    using namespace std;
    int main() {
    	int n,i,count,res;
    	char a[MAX];
    	cin>>n;
    	
    	for(i=0;i<n;i++)
    	{
    		cin>>a[i];
    	}
    	
    	count=0;
    	res=0;
    	for(i=0;i<n;i++)
    	{
    		if(a[i]!='0')
    		{
    			count++;
    		}
    		
    		if(a[i]=='0' && count>res)
    		{
    		res=count;
    		count=0;
    		}
    	}
    	cout<<res<<endl;
    	return 0;
    }

",C++
11099662,"
    #include<bits/stdc++.h>
    
    using namespace std ;
    
    int main()
    {
        int t;
        cin >> t ;
        while ( t-- )
        {
            int n , p ,i ;
            cin >> n >> p ;
            int o[p];
            int h[p+1];
            int c=0 ;
            memset( h,0,sizeof(h)) ;
            for( i=0 ; i<p ; i++ )
            {
                cin >> o[i] ;
                h[o[i]] = 1 ;
            }
            if( n>=p )
            {
                cout << p << endl ;
            }
            else
            {
                for( i=0 ; i<=p ; i++ )
                {
                    if( h[i]==1 )
                        c++ ;
                }
                cout << c << endl ;
            }
        }
        return 0 ;
    }
    

",C++
10158028,"
    #include<bits/stdc++.h>
    using namespace std;
    int orders[500];
    vector<vector<int> > lst(500);
    bool occ[500];
    int main(){
    	int t;
    	scanf(""%d"", &t);
    	while(t--){
    		int N, M;
    		scanf(""%d%d"", &N, &M);
    		for(int i = 1;i <= M;++i){
    			scanf(""%d"", &orders[i]);
    		}
    		for(int i = M;i >= 1;--i){
    			lst[orders[i]].push_back(i);
    		}
    		memset(occ, 0, sizeof occ);
    		int cus = 0;
    		int ans = 0;
    		for(int i = 1;i <= M;++i){
    			if(!occ[orders[i]]){
    				if(cus < N){
    					++cus;
    					++ans;
    					occ[orders[i]] = true;
    					lst[orders[i]].pop_back();
    				} else{
    					int maxVal = 0;
    					int maxId = 0;
    					for(int j = 1;j <= 400;++j){
    						if(occ[j]){
    							if(lst[j].empty()){
    								maxId = j;
    								break;
    							} else if(lst[j][lst.size() - 1] > maxVal){
    								maxVal = lst[j][lst.size() - 1];
    								maxId = j;
    							}
    						}
    					}
    					occ[maxId] = false;
    					++ans;
    					occ[orders[i]] = true;
    					if(!lst[orders[i]].empty())
    					lst[orders[i]].pop_back();
    				}
    			}
    		}
    		printf(""%d\n"", ans);
    	}
    	return 0;
    }

",C++
5209055,"
    #include <cstdio>
    #include <iostream>
    #include <algorithm>
    #include <cstring>
    
    using namespace std;
    
    int t, a, table[205], waiting[405];
    int n,m,nm,brt,w;
    
    bool notattable(int x) {
         for(int i=1; i<=brt; i++)
           if (table[i]==x) return false;
         return true;
    }
    int whichtoclear() {  // onog koji je najdalje, a trenutno zauzima sto
         int first[405];
         memset(first, 0, sizeof(first));
         int sol=0;
         int tab=1;
         for(int i=1; i<=n; i++){
           bool notinwaitinglist=true;
           for(int j=w; j<=m; i++)
             if (waiting[j]==table[i]) {
                 if (sol<j) {sol=j; tab=i;}
                 notinwaitinglist=false;
                 break;
             }
           if (notinwaitinglist) {sol=99999999; tab=i; break;}
         }
         return tab;
    }
    int main() {
    //    freopen(""hex.in"", ""r"", stdin);
    //    freopen(""dule.out"", ""w"", stdout);
      scanf(""%d"", &t);
      for (int T=1; T<=t; T++) {
         scanf(""%d %d"", &n, &m);
         for(int i=1; i<=m; i++) scanf(""%d"", &waiting[i]);
         int resenje=0;
         brt=0;
         w=1;
         while (w<=m) {
            if (!notattable(waiting[w])) w++;
            else if (brt<n) {   // ima slobodnih stolova
                     table[++brt]=waiting[w++]; resenje++;
                 }
                 else {
                     table[whichtoclear()]=waiting[w++];
                     resenje++;
                 }
      //      printf(""sledeci na listi je %d(%d), resenje je %d\n"", w, waiting[w], resenje);
         }
         printf(""%d\n"", resenje);
      }
      return 0;
    }
    

",C++
4858019,"
    #include<stdio.h>
    int rsto();
    int main()
    {int t,i;
    scanf(""%d"",&t);
    for(i=0 ;i<t;i++)
    { 
      printf(""%d\n"",rsto());
    }
    return 0;
    }
    
    
    int rsto(){
    int i,j,flag=1,tale,order,min=400,addr=0,try=0,total=0;
    scanf(""%d%d"",&tale,&order);
    int m[order+1],c[400]={0}, n[tale+1];
    
    for(i=1;i<=order;i++)
    { 
     scanf(""%d"",&m[i]);
    c[m[i]]++;
    //printf(""%d "",c[m[i]]);
    } 
    n[1]=m[1];
    c[m[1]]--;
    total++;
    //printf(""\n%d\t"",total);
      for(i=2;i<=order;i++)
    {
      for(j=1;j<=flag;j++)
      { 
      if(m[i]==n[j]){
         c[m[i]]--; try=1;  
    	// printf(""n[%d]%dflag%d\t"",n[j],total,flag);
    	break;
    	
         }
     else{ try=0;
    	      if((c[n[j]])<min)
    	      {
    		  min=c[n[j]];
    		  addr=j;
    		 // printf(""min%d addr%d\t"",min,addr);
    		  }
    		 
            }
    		//printf(""flag%dmin%d\t"",flag,min);
    }
     
    if(try==0){
        if(min==0){
    	  n[addr]=m[i];
    	  total++;
    	  //printf(""n[addr%d]%d\t"",n[addr],total);
    	  c[m[i]]--;
    	  }
    	else{
    	     if(flag<tale)
    		 { flag++;
    	       n[flag]=m[i];
    	        total++;
    			//printf(""n[flag%d]%d\t"",n[flag],total);
    			c[m[i]]--;
    			}
    	     else{
    		 n[addr]=m[i];
    	       total++;
    	       //printf(""n[addr%d]%d\t"",n[addr],total);  c[m[i]]--;
    	   }
    	}
    
    }
    
    
    min=400;
    }
    return total;
    
    }

",C
10395005,"
    #include<iostream.h>
    #include <string.h>
    
    using namespace std;
     
    int main()
    {
    	
    	int c,d,g,h;
    	cin>>c;
    for(int i=0; i<c; i++){
    	
    string s;
     int e=0, f=0;
     cin>>s;
     int a= s.length();
    for (int j=0; j<a;j++){
    	if(s[j]=='a'){
    	e++;
    	}
    	else if(s[j]=='b')  {
    		f++;
    	}
    }
    
    
    if(e>f){cout <<a-e;}
    
    else{cout <<a-f;
    }}
    return 0;
        
    }   

",C++
10067647,"
    import java.io.*;
       class CHN09
       {
           public static void main(String[] args)throws IOException
           {
               BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
               int T=Integer.parseInt(br.readLine());
               long arN[]=new long [T];
               String arS[]=new String[T];
               for(int j=0;j<T;j++)
               arS[j]=br.readLine();
               for(int j=0;j<T;j++)
               {
                   String S=arS[j];
                   int N=S.length();
                   char ch[]=new char [(int)N];
                   int a[]=new int[2];
                   int i;
                   for(i=0;i<N;i++)
                   {
                       ch[i]=S.charAt(i);
                       if(ch[i]=='a')
                       a[0]++;
                       else if(ch[i]=='b')
                       a[1]++;
                    }
                    int res=0,pos=0,small=0;
                    if(a[0]==a[1])
                    res=a[0];
                    else
                    {
                        small=a[0]<a[1]?a[0]:a[1];
                        res=small;
                    }
                    System.out.println(res);
                }
            }
        }

",JAVA
9955874,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Main{
    
    	public static void main(String[] args) throws NumberFormatException, IOException {
    		// TODO Auto-generated method stub
    		BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));
    		int T=Integer.parseInt(buff.readLine());
    		int output[]=new int[T],a,b;
    		String s;
    		
    		for(int i=0;i<T;i++){
    			a=0;b=0;
    			s=buff.readLine();
    			
    			for(int j=0;j<s.length();j++){
    				char color=s.charAt(j);
    				
    				switch(color){
    				case 'a': a++;
    						break;
    				case 'b': b++;
    						break;
    				}
    			}
    			if(a<b)
    				output[i]=a;
    			else
    				output[i]=b;
    		}
    		
    		for(int i=0;i<T;i++)
    			System.out.println(output[i]);
    	}
    
    }
    

",JAVA
9682307,"
    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
    	// your code goes here
    	
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    	    char ch[100];
    	    scanf(""%s"",ch);
    	    int n=strlen(ch);
    	    int i,na=0,nb=0;
    	
    	    for(i=0; i<n; i++)
    	    {
    	        if(ch[i]=='a')
    	        na++;
    	        else
    	        nb++;
    	    }
    	    if(na>=nb)
    	    printf(""%d\n"",nb);
    	    else
    	    printf(""%d\n"",na);
    	}
    	
    	return 0;
    }
    
    

",C
9626210,"
    #include<iostream>
    #include<cstring>
    using namespace std;
    int main()
    {
        int t,i,a=0,b=0,l,j;
        
        char s[101];
        cin>>t;
        for(i=0;i<t;i++)
        {
            cin>>s;
            l=strlen(s);
            for(j=0;j<l;j++)
            {
                if(s[j]=='a')
                a++;
                else;
                b++;
            }
            if(a==0||b==0)
            cout<<0<<endl;
            if(a>b)
            cout<<a<<endl;
            if(b>a)
            cout<<b<<endl;
            if(a=b)
            cout<<a<<endl;
        }
        return 0;
    }

",C++
6580853,"
    #include <stdio.h>
    
    int fact (long int n)
    {
    	if(n==1 ||n==0)
    	return 1;
    	else
    	return n*fact(n-1);
    }
    int bin(long int n)
    {
    	int i,n1,c=0;
    	while(n>0)
    	{
    		n1=n%2;
    		if(n1==1)
    		c++;
    		n=n/2;
    	}
    	return c;
    }
    int main(void) {
    	// your code goes here
    	long int i,n,t,n1,n2,temp,fn1,fn2,count,b,g ;
    	scanf(""%ld"",&t);
    	while(t--)
    	{
    		count=0;
    		scanf(""%ld %ld"",&n,&g);
    		for(i=0;i<=n;i=i+2)
    		{
    			n1=n-i;
    			n2=i/2;
    			temp=fact(n1+n2);
    			fn1=fact(n1);
    			fn2=fact(n2);
    			temp=temp/fn1;
    			temp=temp/fn2;
    			count=count+temp;
    			count=count%1000000007;
    			b=bin(count);
    		}
    		if(b==g)
    		printf(""CORRECT\n"");
    		else
    		printf(""INCORRECT\n"");
    	}
    	return 0;
    }

",C
10512193,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int n,k,sum=0;
            cin>>n>>k;
            int arr[n];
            for(int i=0;i<n;i++)
            {
                cin>>arr[i];
                sum+=arr[i];
            }
            sort(arr,arr+n);
            int min=arr[0];
            if(k>sum)
                cout<<""-1""<<endl;
            else if(((sum-min)/k)==(sum/k))
                  cout<<""-1""<<endl;
            else
                cout<<(sum/k)<<endl;
    
        }
        return 0;
    
    }
    

",C++
9860617,"
    #include <iostream>
    using namespace std;
    int main(){
    	int t;
    	cin>>t;
    	int i;
    	for(i=0;i<t;i++)
    		{ int n,x;
    		  cin>>n>>x;
    		  int j,a[n],sum=0;
    		  for(j=0;j<n;j++)
    		  	{ cin>>a[j];
    		  	  sum=sum+a[j]; }
    		   int s=sum/x;
    		   int q,w;
    		   for(q=0;q<n;q++)
    		   	{ w=sum-a[q];
    		   	  if(w/x==s)
    		   	  	{ break; }
    		   	  }
    		   if(w/x!=s)
    		   	{ cout<<s<<""\n""; }
    		   else { cout<<""-1\n""; }
    		   }
    		   }
    		   	  
    		  
    		  

",C++
7603880,"
    #include<iostream>
    #include<stdio.h>
     
    using namespace std;
     
    int min1(int c[],int p)
    {  int min=100;
    for(int i=0;i<p;i++)
    if(min>c[i])
    min=c[i];
    return min;
    }    
        
    void solve()
    {
         
         int a,b,r[100],i,j=0;
         int sum=0;
         cin>>a;
         cin>>b;
         for(i=0;i<a;i++)
         {
                         cin>>r[i];
                         sum+=r[i];
                         }
    if(sum<b)
    cout<<-1<<endl;
    
                         
                        
     else if(sum%b==0)
          cout<<sum/b<<endl;
          else if(sum>b)
          {
                   if((sum-min1(r,a))/b==sum/b)
                   cout<<-1<<endl;
                   else
                   cout<<sum/b<<endl;
                   
          }
        
          
       
       
    }  
     
     
    int main()
    {
        int t;
        cin>>t;
        do{
               solve();
               }while(--t);
               
               return 0;
               } 
              
                                         
                         

",C++
5087751,"
    #include <iostream>
    #include <cstdio>
    #include <algorithm>
    using namespace std;
    
    #define MOD 1000000007
    #define FOR(i, n) for (int i = 0; i < n; i++)
    #define FORR(i, n) for (int i = n - 1; i >= 0; i--)
    #define S(n) scanf(""%d"", &n);
    #define P(n) printf(""%d\n"", n);
    
    int main() {
      int t, m, s, n, x, A[101];
      S(t);
      while (t--) {
        S(n); S(x);
        s = 0, m = 101;
        for (int i = 0; i < n; i++) {
          S(A[i]);
          s += A[i];
          m = min(m, A[i]);
        }
        if (s % x > m) {
          printf(""-1\n"");
        } else {
          P(s / x);
        }
      }
    }
    

",C++
4565631,"
    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    /**
     *
     * @author pallavi
     */
     class buyingsweets {
        public static void main(String args[]){
            Scanner sc= new Scanner(System.in);
            int test=sc.nextInt();
            int[] res= new int[test];
            for(int i=0;i<test;i++){
                int notes= sc.nextInt();
                int price = sc.nextInt();
                int[] arr= new int[notes];
                int sum=0;
                for(int j=0;j<notes;j++){
                    arr[j]=sc.nextInt();
                    sum+=arr[j];
                }
                if(sum%price==0) 
                    res[i]=sum/price;
                else{
                    if(notes==1)
                        res[i]=sum/price;
                    else
                    {
    //                    int left=sum%price;
    //                    int qnt= sum/price;
                        Arrays.sort(arr);
                        for(int h=0;h<arr.length;h++)
                        {
                                 int s=sum-arr[h];
                                if(s%price==0){
                                   res[i]=s/price;
                                   break;
                                }
                                else
                                 res[i]=-1;   
                        }
                     
                    }
                }
                
            }
            for(int i=0;i<test;i++)
            System.out.println(res[i]);
        }
        
    }
    

",JAVA
4156431,"
    #include<iostream>
    #include<cstdio>
    using namespace std;
    int main()
    {
    	int t,k,i,j,x,sum=0,MIN=0,n;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d%d"",&k,&x);
    		scanf(""%d"",&n);
    		MIN=n;
    		sum=n;
    		for(i=1;i<k;i++)
    		{
    			scanf(""%d"",&n);
    			sum=sum+n;
    			if(MIN>n)
    			MIN=n;
    		}
    		i=sum%x;
    		j=sum/x;
    		if(i>=MIN)
    		{
    			printf(""-1"");
    			printf(""\n"");
    		}
    		else
    			printf(""%d"",j);
    			printf(""\n"");
    	}
    return 0;
    }
    
    
    
    

",C++
9690061,"
    #include <stdlib.h>
    #include <string.h>
    #include <stdio.h>
    int main() 
    {
     int t,ans=0;
       char ch[102];
        scanf(""%d"",&t);
        gets(ch);
        while(t--)
        {
         gets(ch);
          int i,j,k,f;
         int a=0,b=0,c=0,d=0;
         k=strlen(ch);
         for(i=k-1;ch[i]!=' ' && i>0;i--)
         {f=ch[i]-48;
          //printf(""%d "",f);
          if(f==8)
             a++;
           else if(f==5)
             b++;
           else if(f==3)
             c++;
           else
           { d++;
            break;
           }
           
               
          
         }
        // printf(""%d "",i);
         if(d==0)
        {if(a>=b)
         {if(b>=c)
            ans++;
         }    
        }     
        }
        printf(""%d\n"",ans);
        return 0;
    } 

",C
1496981,"
    //Data Structure includes
    #include<vector>
    #include<stack>
    #include<set>
    #include<map>
    #include<queue>
    #include<deque>
    #include<string>
    //Other Includes
    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<cassert>
    #include<cstdlib>
    #include<cstdio>
    #include<cmath>
    //some common functionn
    
    #define maX(a,b)                     ( (a) > (b) ? (a) : (b))
    #define miN(a,b)                     ( (a) < (b) ? (a) : (b))
    #define FOR(i,a,b)              for(int i=a;i<b;i++)
    #define FORs(i,a,b)             for(int i=a;i>=b;i--)
    #define fill(a,v)               memset(a,v,sizeof a)
    #define abS(x)                  ((x)<0?-(x):(x))
    #define mp                      make_pair
    #define pb                      push_back
    
    
    // Input macros
    #define s(n)                        scanf(""%d"",&n)
    #define sc(n)                       scanf(""%c"",&n)
    #define sl(n)                       scanf(""%lld"",&n)
    #define sf(n)                       scanf(""%lf"",&n)
    #define ss(n)                       scanf(""%s"",n)
    
    // Output macros
    #define p(n)                        printf(""%d"",n)
    #define pc(n)                       printf(""%c"",n)
    #define pl(n)                       printf(""%lld"",n)
    #define pf(n)                       printf(""%lf"",n)
    #define ps(n)                       printf(""%s"",n)
    
    using namespace std;
    
    typedef long long LL;
    typedef pair<int,int> PII;
    typedef pair<LL,LL> PLL;
    typedef pair<int,PII> TRI;
    
    typedef vector<int> VI;
    typedef vector<LL> VL;
    typedef vector<PII> VII;
    typedef vector<PLL> VLL;
    typedef vector<TRI> VT;
    
    typedef vector<VI> VVI;
    typedef vector<VL> VVL;
    typedef vector<VII> VVII;
    typedef vector<VLL> VVLL;
    typedef vector<VT> VVT;
    
    using namespace std;
    /*  The Doer's code  */
    
    
    int n;
    int solve()
    {
    	int res=0;//char s[143];
    	char ch;
        string s;
        cin>>ch;
    	FOR(i,0,n)
    	{
    	   
    		
    		getline(cin,s);
    				//gets(s);
    		int m=s.length();
    		//int m=strlen(s);
    		int e=0,f=0,t=0,flag=1;
    		for(int j=m-1;flag && s[j]!=' ';j--)
    		{
    			//if(s[j]==' ')// && (e!=0 ||flag!=0 ||t!=0 ||f!=0 ))
    			  //break;
    			//else
    			 if(s[j]=='8')
    			  e++;  
    			else if(s[j]=='5')
    			  f++;
    			 else if(s[j]=='3')
    			   t++;
    			 else if(s[j]>='0' && s[j]<='9')
    			   {flag=0;}  
    		}
    		if(e>=f && f>=t && flag==1 && e!=0)
    		  res++;
    	}
    	cout<<res;
    
          return 1;
    }
    
    bool input()
    {
     s(n);
     //getchar();
       
        return true;
    }
    
    int main()
    {
        int T=1;
        //s(T);
        for(int testnum=1;testnum<=T;testnum++)
        {
            if(!input()) break;
    
            solve();
            //printf(""\n"");
    
        }
        
        return 0;
    }
    

",C++
1124469,"
    #include<iostream>
    #include<string>
    #include<cstring>
    using namespace std;
    int main()
    {
        char a[150]={'\0'};
        int e,f,t,T,c=0,flag,len,i,temp;
        scanf(""%d"",&T);cin.get();
        while(T--)
        {
                  e=f=t=0;flag=1;
                  cin.getline(a,'$');
                  len=strlen(a);
    
                  for(i=len-1;i>=0;i--)
                  {
                  if(a[i]!=' ')
                  {
                             temp=(int)a[i] -48;
                             if(temp==8)
                             e++;
                             else if(temp==5)
                             f++;
                             else if(temp==3)
                             t++;
                             else{
                             flag=0;
                             break;
                             }
                             if(a[i-1]==' ')
                             break;
                  }}
                  if(flag!=0)
                  {
                             if(e>=f && f>=t && e!=0)
                             c++;
                  }
                  }
                  printf(""%d\n"",c);
                  
                  }
    

",C++
8665265,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		int a,b,c;
    		scanf(""%d%d%d"",&a,&b,&c);
    	    if(c >= a+b) printf(""%d\n"",c-(a+b));
    	    else if(a >= b+c) printf(""%d\n"",a-(b+c));
    	    else if(b >= a+c) printf(""%d\n"",b-(a+c));
    	    else printf(""0\n"");
    	    
    	}
    	return 0;
    }

",C
7233615,"
    #include <stdio.h>
    #include <stdlib.h>
    #include<string.h>
    #include<math.h>
    #include<limits.h>
    #include<ctype.h>
    inline void si(int* x)
    {
    	register char c = getchar_unlocked();
    	*x = 0;
    	int neg = 0;
    	for(; ((c<48 || c>57) && c != '-');c = getchar_unlocked());
    	if(c=='-') {
            neg = 1;
            c = getchar_unlocked();
        }
    	for(; (c>47)&&(c<58);c = getchar_unlocked())
    		*x = (int)((((*x)<<1) + ((*x)<<3)) + c - 48);
        if(neg)
            *x = -*x;
    }
    int main()
    {
        int t,ds,dt,d;
        si(&t);
        while(t--)
        {
           si(&ds);
           si(&dt);
           si(&d);
           d=d-ds-dt;
           if(d>0)
            printf(""%d\n"",d);
           else
            printf(""0\n"");
        }
        return 0;
    }
    

",C++
7064343,"
    #include<iostream>
    #include<stdio.h>
    using namespace std;
    
    int main()
    {
        int t;
        cin>>t;
    
        while(t--)
        {
            int a,b;
            cin>>a>>b;
            int r;
            cin>>r;
    
            if(b>a)
            {
                b = r-b;
    
            float ans=b-a;
            if(b<a)
                cout<<""0""<<""\n"";
            else
                printf(""%.06f\n"",ans);
            }
    
            else
            {
                a = r-a;
    
            float ans=b-a;
            ans*=-1;
    
            if(a<b)
                cout<<""0""<<""\n"";
            else
                printf(""%.06f\n"",ans);
            }
    
        }
    }
    

",C++
4664598,"
    #include<stdio.h>
    #define gc getchar()
    inline void read(int *i)
    {
    	*i=0;
    	char ch=gc;
    	int sign=1;
    	while(ch<'0' || ch>'9')
    	{
    		if(ch=='-')
    			sign=-1;
    		ch=gc;
    	}
    	while(ch>='0' && ch<='9')
    	{
    		*i=(*i)*10+ch-'0';
    		ch=gc;
    	}
    	(*i)*=sign;	
    }
    int main()
    {
    	int t;
    	read(&t);
    	while(t--)
    	{
    		int ds,dt,d,ans=0;
    		read(&ds);read(&dt);read(&d);
    		if(d>=ds+dt)
    		printf(""%d\n"",d-ds-dt);
    		else if(ds>=d+dt)
    			printf(""%d\n"",ds-d-dt);
            	else if(dt>=d+ds) 
    			printf(""%d\n"",dt-d-ds);
    		else
    			printf(""0\n"");
    	}
    }

",C
3250008,"
    #include<stdio.h>
    int main()
    {
    	int t,ds,dt,d;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d%d%d"",&ds,&dt,&d);
    		if(ds+dt<=d)
    		printf(""%d\n"",d-ds-dt);
    		else if(ds>=dt+d)
    		printf(""%d\n"",ds-dt-d);
    		else if(dt>=ds+d)
    		printf(""%d\n"",dt=d-ds);
    		else
    		printf(""0\n"");
    	}
    	return 0;
    }

",C++
1840152,"
    #include <iostream>
    #include<cstdio>
    using namespace std;
    
    int main()
    {
        int t,d1,d2,d3;
        double ans;
        scanf(""%d"",&t);
        while(t--)
        {
            scanf(""%d%d%d"",&d1,&d2,&d3);
            if(d1+d2>d3&&d2+d3>d1&&d1+d3>d2)
            {
                ans=0;
                printf(""%0.8lf\n"",ans);
            }
            else if(d1>d3)
            {
                ans=d1-d2-d3;
                printf(""%0.8lf\n"",ans);
            }
            else if(d2>d3)
            {
                ans=d2-d1-d3;
                printf(""%0.8lf\n"",ans);
            }
            else
            {
                ans=d3-d1-d2;
                printf(""%0.8lf\n"",ans);
            }
        }
        return 0;
    }

",C++
1744584,"
    #include <stdio.h>
    
    int main()
    {
        int d, ds, dt;
          while(1)
          {
            scanf(""%d %d %d"",&ds,&dt,&d);
    
            if(d > (ds+dt))
              printf(""%d\n"", d-(ds+dt));
            else if(ds > (d+dt))
              printf(""%d\n"", ds-(d+dt));
            else if(dt > (d+ds))
              printf(""%d\n"", dt-(d+ds));
            else
              printf(""0\n"");
          }
    
      return 0;
    }
    

",C++
1626512,"
    #include<vector>
    #include<stack>
    #include<set>
    #include<map>
    #include<queue>
    #include<deque>
    #include<string>
    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<cassert>
    #include<cstdlib>
    #include<sstream>
    #include<bitset>
    #include<cstdio>
    #include<cmath>
    #include<climits>
    #include<ctime>
    #include<string>
    using namespace std;
    typedef long long LL;
    template<typename T> T gcd(T a, T b) { return (b == 0) ? abs(a) : gcd(b, a % b); }
    template<typename T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
    template<typename T> inline T mod(T a, T b) { return (a % b + b) % b; }
    template<typename T> inline T sqr(T x) { return x * x; }
    template<typename T> inline string tostring(const T& x) { ostringstream  os; os << x; return os.str(); }
    
    inline int toint(const string& s) { istringstream  is(s); int x; is >> x; return x; }
    inline double todouble(const string& s) { istringstream  is(s); double x; is >> x; return x; }
    inline string tobinary( int a) { string s; while( a != 0 ) { s = (char)(a%2+'0') + s; a>>=1; } return s; }
    inline int isvowel( char c ) { if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ) return 1; return 0; }
    inline int isprime( int a ) {  for ( int i = 2; i*i <= a; i++ ) if (!(a%i)) return 0; return 1; }
    
    #define forr(x, b, e)    for (int x = (b); x <= (e); x++)
    #define all(c)          (c).begin(), (c).end()
    #define mp      make_pair
    #define pb      push_back
    #define ii      pair<int,int>
    #define zero(a) memset(a, 0, sizeof(a))
    #define fill(a, x) memset(a, x, sizeof(a))
    #define mod 1000000007
    int dx[] = {0, 1, 0, -1};int dx2[] = {0, 1, 0, -1,1,-1,1,-1};
    int dy[] = {1, 0, -1, 0};int dy2[] = {1, 0, -1, 0,1,-1,-1,1};
    //long long modexp(int n, int p) {long long r = 1, b = n;while(p > 0) {if(p & 1) { r = r * b; if(r >= MOD) r %= MOD; }p >>= 1;b = b * b; if(b >= MOD) b %= MOD;}return r;}
    template<class T> inline void scan( T &n ) {n=0;T ch=getchar();T sign=1;while( ch < '0' || ch > '9' ){if(ch=='-')sign=-1; ch=getchar();}while( ch >= '0' && ch <= '9' )n=(n<<3)+(n<<1)+ ch-'0', ch=getchar();n=n*sign;}
    /*Main Code Begins Now*//////////////////////////////////////////////////////////////////////////////////////////////
    
    
    /*long long nCr(long long N,long long r)
    {
    	if(N<r)
    	return 0;
    	if(N-r<r)
    	  r=N-r;
    	LL c=1;
    	for(int i=1;i<=r;i++)
    	{c=c*(N-r+i);
    	 c=c/i;}
    	return c;
    }
    */
    /* This function calculates (a^b)%MOD */
    LL fact[8444444];
    LL factinv[8444444];
    long long pow(int a, int b, int MOD)
    {
    	long long x=1,y=a; 
    	while(b > 0)
    	{
    		if(b%2 == 1)
    		{
    			x=(x*y);
    			if(x>MOD) x%=MOD;
    		}
    		y = (y*y);
    		if(y>MOD) y%=MOD; 
    		b /= 2;
    	}
    	return x;
    }
    
    /* 	Modular Multiplicative Inverse
    	Using Euler's Theorem
    	a^(phi(m)) = 1 (mod m)
    	a^(-1) = a^(m-2) (mod m) */
    long long InverseEuler(int n, int MOD)
    {
    	return pow(n,MOD-2,MOD);
    }
    
    long long C(int n, int r, int MOD)
    {
    	if(n<r)
    	return 0;
    	return (fact[n]*((factinv[r] * factinv[n-r]) % MOD)) % MOD;
    }
    
    int main()
    {
    	fact[1]=1;
    	fact[0]=1;
    	for(LL i=1;i<=844444;i++)
    	{
    		fact[i]=(fact[i-1]*i)%mod;
    		
    	}
    	for(int i=0;i<=844444;i++)
    	{
    		factinv[i]=pow(i,mod-2,mod);
    	}
         int N,M,A,B;
         int test;
         scan(test);
         while(test--){
         LL ans=0;
         scan(N);
         scan(M);
         scan(A);
         scan(B);
         
         if(A==0||B==0)
         {
         	ans=ans+C(N+M,N,mod);
         	printf(""%lld\n"",ans);
         	assert(ans>0&&ans<mod);
         	continue;
         }
         for(int i=0;i<=N-A;i++)
         {
         	ans=ans+C(B-1+N-A-i,B-1,mod)*C(M-B+A+i,M-B,mod);
         	if(ans>mod)
         	ans%=mod;
         }
         assert(ans>0&&ans<mod);
         printf(""%lld\n"",ans);
     }
    
    
    	return 0;
    }
    
    
    
    
    
    
    

",C++
11373213,"
    #include <iostream>
    #include <vector>
    #include <queue>
    #include <cstring>
    
    using namespace std;
    
    bool v[100005];
    
    struct node{
        int a, b, c;
        node(int x, int y, int z)
        {
            a = x;
            b = y;
            c = z;
        }
    };
    
    struct Comparator
    {
        bool operator()(const node &A, const node &B)
        {
            return A.c>B.c;
        }
    };
    
    bool operator<(const node &A, const node &B)
    {
        return A.c < B.c;
    }
    
    int dsFind(int arr[], int pos)
    {
        //cout<<""Finding ""<<pos<<endl;
        if(arr[pos]<0)
        {
            //cout<<""Returning ""<<pos<<endl;
            return pos;
        }
        arr[pos] = dsFind(arr, arr[pos]);
        //cout<<""DS union return""<<endl;
        return arr[pos];
    }
    
    void dsUnion(int arr[], int A, int B)
    {
        int x = dsFind(arr, A), y = dsFind(arr, B);
        if(x<y)
        {
            arr[x] += arr[y];
            arr[y] = x;
        }
        else
        {
            arr[y] += arr[x];
            arr[x] = y;
        }
    }
    
    void coalScam(vector<node> &A, vector<node> &B, int n)
    {
        //cout<<""In function""<<endl;
        long long ans=0, ans1=0;
        priority_queue<node> Q1;
        priority_queue<node, vector<node>, Comparator> Q2;
        memset(v, 0, sizeof(v));
        int arr1[100005], arr2[100005];
        memset(arr1, -1, sizeof(arr1));
        memset(arr2, -1, sizeof(arr2));
        
        /*
        cout<<""A is""<<endl;
        for(int i=0; i<A.size(); i++)
        {
            cout<<A[i].a<<"" ""<<A[i].b<<"" ""<<A[i].c<<endl;
        }
        
        cout<<""B is""<<endl;
        for(int i=0; i<B.size(); i++)
        {
            cout<<B[i].a<<"" ""<<B[i].b<<"" ""<<B[i].c<<endl;
        }
        */
        
        for(int i=0; i<A.size(); i++)
        {
            Q1.push(A[i]);
        }
        for(int i=0; i<B.size(); i++)
        {
            Q2.push(B[i]);
        }
        while(!Q1.empty())
        {
            node t = Q1.top();
            //cout<<""Extracted ""<<t.a<<"" ""<<t.b<<endl;
            Q1.pop();
            if(dsFind(arr1, t.a)!=dsFind(arr1, t.b))
            {
                //cout<<""In fnctn""<<endl;
                ans += t.c;
                //cout<<""Adding ""<<t.c<<endl;
                dsUnion(arr1, t.a, t.b);
                v[t.a] = v[t.b] = 1;
                //cout<<""End""<<endl;
            }
        }
        while(!Q2.empty())
        {
            node t = Q2.top();
            Q2.pop();
            //cout<<""Extracted ""<<t.a<<"" ""<<t.b<<"" ""<<t.c<<endl;
            if(dsFind(arr1, t.a)!=dsFind(arr1, t.b))
            {
                dsUnion(arr1, t.a, t.b);
                ans1 += t.c;
                v[t.a] = v[t.b] = 1;
            }
        }
        for(int i=0; i<n; i++)
        {
            if(v[i]==0)
            {
                //cout<<""Returning due to ""<<i<<endl;
                cout<<""Impossible""<<endl;
                return;
            }
        }
        cout<<ans<<"" ""<<ans+ans1<<endl;
    }
    
    int main()
    {
        int t, n, m1, m2, a, b, c;
        vector<node> A, B;
        cin>>t;
        while(t--)
        {
            A.clear();
            B.clear();
            cin>>n>>m1>>m2;
            //cout<<m1<<"" ""<<m2<<endl;
            while(m1--)
            {
                //cout<<m1<<endl;
                cin>>a>>b>>c;
                node t(a, b, c);
                B.push_back(t);
                //cout<<""Inserting ""<<B[B.size()-1].a<<"" ""<<B[B.size()-1].b<<"" ""<<B[B.size()-1].c<<endl;
            }
            
            while(m2--)
            {
                //cout<<m2<<endl;
                cin>>a>>b>>c;
                node t(a, b, c);
                A.push_back(t);
                //cout<<""Inserting ""<<A[A.size()-1].a<<"" ""<<A[A.size()-1].b<<"" ""<<A[A.size()-1].c<<endl;
            }
            coalScam(A, B, n);
        }
        return 0;
    }

",C++
2771256,"
    	/*
    	author :  R Anirudh 
    	*/
    
    	#include <vector>
    	#include <list>
    	#include <map>
    	#include <set>
    	#include <queue>
    	#include <deque>
    	#include <stack>
    	#include <bitset>
    	#include <algorithm>
    	#include <functional>
    	#include <numeric>
    	#include <utility>
    	#include <sstream>
    	#include <iostream>
    	#include <iomanip>
    	#include <cstdio>
    	#include <cmath>
    	#include <cstdlib>
    	#include <cstring>
    	#include <queue>
    	#include <cassert>
    	#include <climits>
    	#include <limits>
    	using namespace std;
    	#define SIZE(A) ((int)(A.size()))
    	#define MSET(A,x) memset(A,x,sizeof(A));
    	#define FILL(A,x) fill(A.begin(),A.end(),x)
    	#define REP(i,N) for(int i=0;i<(int)(N);i++)
    	#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
    	#define REV(i,a,b) for(int i=(int)(a);i>=(int)(b);i--)
    	#define TR(c,i) for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
    	#define ALL(x) x.begin(),x.end()
    	#define INF (INT_MAX/2)
    	#define LLINF (LONG_LONG_MAX/2LL)
    	#define EPS 1e-12
    	#define GI ({int t;scanf(""%d"",&t);t;})
    	#define GL ({long long t;scanf(""%lld"",&t);t;})
    	#define GF ({double t;scanf(""%lf"",&t);t;})
    	#define bitCount(n) __builtin_popcount(n)
    	#define MOD 10000009
    	#define MAXN 1000005
    	#define FIX(a) (((a)%MOD+MOD)%MOD)
    	typedef long long LL;
    	typedef unsigned long long ULL;
    	#define pb push_back
    
    	/*
    
    	int n;
    	int bit[1025][1025];
    
    	void update(int x, int y, int v)
    	{
    	int y1;
    	while(x <= n)
    	{
    	y1 = y;
    	while(y1 <= n)
    	{
    	bit[x][y1] += v;
    	y1 += (y1 & -y1);
    	}
    	x += (x & -x);
    	}
    	}
    
    	int readsum(int n,int x, int y)
    	{
    	int v = 0, y1;
    	while(x > 0)
    	{
    	y1 = y;
    	while(y1 > 0)
    	{
    	v += bit[x][y1];
    	y1 -= (y1 & -y1);
    	}
    	x -= (x & -x);
    	}
    	return v;
    	}
    
    	*/
    
    	#define MAX 50005
    	int rank[MAX];
    	int parent[MAX];
    
    	typedef pair<int,int> pii;
    	typedef pair<int,pii> edge;
    
    	int find(int n) {
    		if(parent[n] != n) parent[n] = find(parent[n]);
    		return parent[n];
    	}
    	bool merge(int a,int b) {
    		int pa = find(a), pb = find(b);
    		if(pa==pb) return 0;
    		if(rank[pa] > rank[pb]) parent[pb] = pa;
    		else parent[pa] = pb;
    		if(rank[pa] == rank[pb]) rank[pb]++;
    		return 1;
    	}
    
    
    	int main(){  
    	int t;
    	scanf(""%d"",&t);
    	while(t--){
    	int n,m1,m2;
    	scanf(""%d %d %d"",&n,&m1,&m2);
    	FOR(i,0,n)
    	parent[i]=i;
    	memset(rank,0,sizeof rank);
    	vector<edge> edges;
    	for(int i=0;i<m1;i++)
    	{
    		int a,b,cost;
    		scanf(""%d %d %d"",&a,&b,&cost);
    		edges.pb(edge(cost,pii(a,b)));
    	}
    
    	for(int i=0;i<m2;i++)
    	{
    		int a,b,cost;
    		scanf(""%d %d %d"",&a,&b,&cost);
    		edges.pb(edge(-1*cost,pii(a,b)));
    	}
    
    	sort(edges.begin(),edges.end());
    
    	LL ans1=0,ans2=0;
    
    	for(int i=0;i<edges.size();i++)
    	{
    			if(merge(edges[i].second.first,edges[i].second.second))
    			{
    				if(edges[i].first<0)
    				{
    					ans1+=(-1*edges[i].first);
    					ans2+=(-1*edges[i].first);
    				}
    				
    				else
    				{
    					ans2+=edges[i].first;
    				}
    			}
    	}
    
    
    	LL count=0;
    	FOR(i,0,n)
    	{
    	if(parent[i]==i)
    	count+=1;
    	}
    	if(count>=2)
    	printf(""Impossible\n"");
    	else
    	printf(""%lld %lld\n"",ans1,ans2);
    
    	}
    	return 0;
    	}
    
    
    

",C++
10150095,"
    #include<bits/stdc++.h>
    using namespace std;
    long long arr[100005];
    long long sum[100005];
    long long n;
    long long k;
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		int i,j;
    		sum[0]=0;
    		scanf(""%lld %lld"",&n,&k);
    		for(i=1;i<=k;i++)
    		{
    			scanf(""%lld"",&arr[i]);
    		}
    		int co=0;
    		long long answ,tt;
    		sort(arr+1,arr+k+1);
    		for(i=1;i<=k;i++)
    		sum[i]=sum[i-1]+arr[i];
    		for(i=1;i<=k;i++)
    		{
    			tt=(arr[i]*(arr[i]+1))/2;
    			tt-=sum[i];
    			if(arr[i]<=tt)
    			{
    				
    			}
    			else
    			{
    				co=1;
    				answ=tt;
    				break;
    			}
    		}
    		if(co==1)
    		{
    			
    		}
    		else
    		{
    			tt=(n*(n+1))/2;
    			tt-=sum[k];
    		}
    		if(tt%2==0)
    		printf(""Chef\n"");
    		else
    		printf(""Mom\n"");
    	}
    	return 0;
    }

",C++
6987929,"
    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    #include<algorithm>
    #ifndef ONLINE_JUDGE
    #define gc getchar
    #else
    #define gc getchar_unlocked
    #endif // ONLINE_JUDGE
    
    using namespace std;
    
    
    
    inline int scanint(){
        char c = gc();
        int x = 0;
        while(c<'0'||c>'9'){
            c=gc();
        }
        while(c>='0'&&c<='9'){
            x=(x<<1)+(x<<3)+c-'0';
            c=gc();
        }
        return x;
    }
    
    
    int main(){
    int t = scanint();
    int *A;
    int prev,curr;
    
    while(t--){
        int n = scanint();
        int k = scanint();
        A = (int *)malloc((k+1)*sizeof(int));
        long long sum = ((n)*(n+1))/2;
        for(int i=0;i<k;++i){
            A[i] = scanint();
            sum -= A[i];
        }
        A[k] = n+1;
    
         long long cnt = sum;
        if(k==0){
            if(sum&1){
                printf(""Mom\n"");
            }
            else printf(""Chef\n"");
    
            continue;
        }
            prev = A[0]-1;
            sum = ((prev)*(prev+1))/2;
            for(int i=0;i<k;++i){
                if(A[i]!=A[i+1]){
                    curr = A[i]+1;
                    if(curr>sum) break;
                    prev = A[i+1]-1;
                    sum +=(((prev*(prev+1))/2)-((curr*(curr-1))/2));
                }
            }
            if(sum&1){
                printf(""Mom\n"");
    
            }
    
            else printf(""Chef\n"");
    
    
    }
    
    return 0;
    }
    

",C++
5887112,"
    #include <iostream>
    
    using namespace std;
    
    int main(){
    	long long int T,i=0,N,K,*a,j,sum;
    	cin>>T;
    	while(i<T){
    		i++;
    		sum=0;
    		cin>>N>>K;
    		a = new long long int [K];
    		for(j=0;j<K;j++)
    			cin>>a[j];
    		sum = (N*(N+1))/2;
    		for(j=0;j<K;j++)
    			sum -= a[j];
    		if(sum%2==0)
    			cout<<""Chef\n"";
    		else
    			cout<<""Mom\n"";
    		}
    	return 0;
    } 
    

",C++
8270022,"
    /* author: vaibhav */
    #include <cmath>
    #include <cstdio>
    #include <vector>
    #include <iostream>
    #include <algorithm>
    #include <bits/stdc++.h>
     
    using namespace std;
    long long ma=0;
    int t,N,D,K,M;
    int A[10005];
    long long dp[205][202][202];
     
    void solve(int i,int k,int d,long long sum)
    {
          if(i==N)
          {
            if(k!=K)
                 return ;
            ma = max(ma,sum);
            dp[i][k][d] = ma;
            return ;
          } 
          if(dp[i][k][d]!=-1)
          {
            ma=max(dp[i][k][d],ma);    
          }
        
          if(d<D)
          {
            solve(i+1,k,d+1,sum+(M*A[i]));
            dp[i][k][d]=ma;
          }
          else
          {
            solve(i+1,k,d+1,sum+(A[i]));
            dp[i][k][d]=ma;
          }
          solve(i+1,k+1,0,sum);
           dp[i][k][d]=ma;
    }
    int main() { 
       
        scanf(""%d"",&t);
        while(t--)
        {
          scanf(""%d %d %d %d"",&N,&K,&D,&M);
          for(int i=0;i<N;i++)
               scanf(""%d"",&A[i]);
           for(int i=0;i<=N;i++)
               for(int j=0;j<=N;j++)
                 for(int k=0;k<=N;k++)
                   dp[i][j][k]=-1;
            
          ma=0;
          solve(0,0,1000,0);
          printf(""%lld\n"",ma); 
        }
      
        return 0;
    }

",C++
7512961,"
    #include <cstdio>
    #include <vector>
    #include <algorithm>
    using std::vector;
    using std::sort;
    #define LL long long int
    
    int a[2005000];
    int mysteryvar;
    int main() {
      int n,t;
      scanf(""%d"", &t);
      while (t--) {
        scanf(""%d"", &n);
        for (int i = 0; i < n; i++) {
          scanf(""%d"", &a[i]);
        }
        sort(a, a + n);
        vector<LL> sum;
        LL diffsum = 0;
        LL tsum = 0;
        for (int i = 0; i < n; i++) {
          for (int j = 0; j < n; j++) {
            if (i == j)
              continue;
            sum.push_back(a[i] + a[j]);
            tsum += a[i] + a[j];
            diffsum += abs(a[i] - a[j]);
          }
        }
        diffsum *= (n - 2) * 4;
        diffsum *= -1;
        sort(sum.begin(), sum.end());
        LL psum = 0;
        int totsz = sum.size();
        for (mysteryvar = 0; mysteryvar < totsz; mysteryvar++) {
          psum += sum[mysteryvar];
          diffsum += (sum[mysteryvar] * (mysteryvar + 1) - psum);
          diffsum += (tsum - psum - (totsz - mysteryvar - 1) * sum[mysteryvar]);
        }
        printf(""%lld\n"", diffsum/4);
      }
      return 0;
    }
    

",C++
8170653,"
    #include<bits/stdc++.h>
    using namespace std;
    
    int main()
    {
    
        long long int i,k,s,a,b;
        double an,bn,ann,bnn,c,d;
        cin >> i >> k >> s ;
        cin >> a >> b ;
        an=a;
        bn=b;
        if(i%2 == k%2)
        {
            c=((pow(2.0,2*(k-i)-s))*(an+bn));
        }
        else
        {
            ann=sqrt(2.0)*((a+b)-sqrt(3.0)*(a-b));
            bnn=sqrt(2.0)*((a-b)-sqrt(3.0)*(a+b));
            c=((pow(2.0,2*(k-i-1)-s))*(ann+bnn));
        }
        printf(""%.30lf\n"",c);
        return 0;
    }
    

",C++
6561830,"
    #include<iostream>
    #include<stdlib.h>
    
    
    using namespace std;
    
    int main()
    {
        long int t,m;
        cin >> t;
        m=t;
        int value[t];
        while(t--)
        {
            int x,y,k;
            long int n;
            int flag=0;
            std::cin >> x >> y >> k >> n;
            int p[n],c[n];
            for(long int i=0;i<n;i++)
            {
                std::cin >> p[i] >> c[i];
                if(((x-y)<=p[i]) && (k>=c[i]))
                 flag=1;
            }
            if(flag==1)  cout<<""LuckyChef""<<endl; // value[t]=1;
            else        cout<<""UnluckyChef""<<endl; // value[t]=2;
        }
    
        return 0;
    }
    

",C++
6559803,"
    #include<iostream>
    
    using namespace std;
    
    int main()
    {
    	int t;
    	int y , x;
    	int k;
    	int n;
    	int p[1000],c[1000];
    	cin>>t;
    	int flag;
    	while(t--){
    		flag=0;
    		cin>>x>>y>>k>>n;
    		for(int i=0;i<n;i++){
    			cin>>p[i];
    			cin>>c[i];
    		}
    		for(int i=0;i<n;i++){
    			if(c[i]<=k){
    				if(y+p[i]>=x){
    					flag=1;
    				}
    			}
    		}
    		if(flag==0){
    			cout<<""UnluckyChef""<<endl;
    		}
    		else {
    			cout<<""LuckyChef""<<endl;
    		}
    		
    	}
    }
    

",C++
11228949,"
    import java.util.Scanner;
     
    class operater{
    	public static void main(String args[]){
    	Scanner in=new Scanner(System.in);
    	int t,a,b;
    	t=in.nextInt();
    	
    	while(t-->0){
    		
    		a=in.nextInt();
    		b=in.nextInt();
    		if(a>b){
    			System.out.println("">"");
    		}
    		else if(a<b){
    			System.out.println(""<"");
    		}
    		else if(a==b){
    			System.out.println(""="");
    		}
    	  }
    		
    	}
    	}
    	
    	

",JAVA
11184591,"
    #include<stdio.h>
    int main()
    {
    int t,a,b,i;
    scanf(""%d"",&t);
    for(i=0;i<t;i++)
    {
    scanf(""%d%d"",&a,&b);
    if(a>b)
    printf("">\n"");
    else if(b>a)
    printf(""<\n"");
    else
    printf(""=\n"");
    }
    return 0;
    }
    

",C
10131855,"
    #include<stdio.h>
    int main()
    {
       int T;
       long long int A,B;
       scanf(""%d"",&T);
       while(T)
       {
          scanf(""%lld%lld"",&A,&B);
          if(A>B)
            printf("">\n"");
          else if(A<B)
            printf(""<\n"");
          else
            printf(""=\n"");
          T--;
       }
       return 0;
    }

",C
8977555,"
    #include<stdio.h>
    int main()
    {
    long long int T,N,i,j,k,s;
    scanf(""%lld"",&T);
    while(T--)
    {
    scanf(""%lld%lld"",&i,&j);
    if(i>j)
    printf("">\n"");
    else if(i<j)
    printf(""<\n"");
    else
    printf(""=\n"");
    }
    return 0;
    }
    

",C
8773759,"
    import java.io.InputStreamReader;
    import java.util.List;
    import java.util.Scanner;
    //import java.util.ArrayList;
    
    
    class Lets_Start {
    
    	public static void main(String[] args){
    		// TODO Auto-generated method stub
    		Scanner a = new Scanner(System.in);
    		int t = a.nextInt();
    		String s, s1;
    		for(int i=0; i<t; i++){
    			s=a.next();
    			s1=a.next();
    			if(s.length()>s1.length()){
    				System.out.println("">"");
    			}
    			else if(s.length()<s1.length()){
    				System.out.println(""<"");
    			}
    			else{
    				for(int j=0;j<s.length();j++){
    					while(Integer.parseInt(s.substring(j, j+1))==Integer.parseInt(s1.substring(j, j+1))){
    						j++;
    						if(j==s.length()){
    							break;
    						}
    					}
    					if(j==s.length()){
    						System.out.println(""="");
    					}
    					else{
    						if(Integer.parseInt(s.substring(j, j+1))>Integer.parseInt(s1.substring(j, j+1))){
    							System.out.println("">"");
    						}
    						else{
    							System.out.println(""<"");
    						}
    					}
    				}
    			}
    		}
    		
    	}
    
    }
    

",JAVA
8204950,"
    #include <iostream.h>
    void main()
    {
    int i=0,a[10],b[10],t;
    cin>>t;
    for(i=0;i<t;i++)
    {cin>>a[i]>>b[i];
    }
    	for(i=0;i<t;i++)
    	  {if(a[i]>b[i])
    	  cout<<"">""<<""\n"";
    	  else if(a[i]<b[i])
    	  cout<<""<""<<""\n"";
    	  else
    	  cout<<""=""<<""\n"";
    	  }
    }

",C
8181911,"
    #include<iostream>
    using namespace std;
    int main()
    {
    int t,i;
    cin>>t;
    int a[t],b[t];
    for(i=0;i<t;i++)
    {cin>>a[i]>>b[i];}
    for(i=0;i<t;i++)
    if(a[i]>b[i])
    cout<<"">""<<endl;
    else if(a[i]<b[i])
    cout<<""<""<<endl;
    else if(a[i]==b[i])
    cout<<""=""<<endl;}
    

",C++
8117689,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int a;
    	cin>>a;
    	for(int i=1;i<=a;i++)
    	{
    		int b,c;
    		cin>>b>>c;
    		if(b==c)
    	cout<<""=""<<endl;
    		if(b>c)
    		cout<<"" > ""<<endl;
    		if(b<c)
    		cout<<"" <""<<endl;
    		
    		
    		
    	}
    	
    	
    	
    	
    }
    

",C++
12111665,"
    #include <stdio.h>
    
    int gcd(int a, int b) {
        return b ? gcd(b, a % b) : a;
    }
    
    int main(int argc, char const *argv[])
    {
        int i, j, k, t;
        char s[100005], c[100005];
        scanf(""%s"", s);
        for(t = s[0], c[0] = t, j = 1, i = 1 ; s[i] ; i++)
            if(s[i] != t) {
                c[j++] = s[i];
                t = s[i];
            }
        c[j++] = t;
        for(i = 0, t = 0; i < j - 3; i++) {
            if(c[i] == 'C' && c[i+1] == 'H' && c[i+2] == 'E' && c[i+3] == 'F') {
                i = i + 3;
                t++;
            }
        }
        printf(""%d\n"", t);
        return 0;
    }

",C
9963612,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	char a[ 100001];
    	cin>>a;
    	long long int i=0,b=0,c=0,d=0,e=0;
    	while(i<strlen(a))
    	{
    		if(a[i]=='C')
    		b++;
    		else if(a[i]=='H')
    		{
    		if(b>c)
    		c++;}
    		else if(a[i]=='E')
    		{
    		if(c>d)
    		d++;}
    		else if(a[i]=='F')
    		{
    		if(d>e)
    		e++;}
    		i++;
    	}
    	cout<<e<<endl;
    }

",C++
9299738,"
    #include <iostream>
    #include <string>
    using namespace std;
    
    main(){
    //	int no;
    //	cin >> no;
    //	string waste;
    //	getline(cin , waste);
    //	while(no--){
    		string line;
    		getline(cin, line);
    		int count[4]={0};
    		int sum=0;
    		for(int i=0; i<line.size(); i++){
    			if(line[i] == 'C')
    				count[0]++;
    			else if(line[i] == 'H' && count[0] > count[1])
    				count[1]++;
    			else if(line[i] == 'E' && count[1] > count[2])
    				count[2]++;
    			else if(line[i] == 'F' && count[2] > count[3]){			
    				count[3]++;
    			}
    		}
    		cout << count[3] << endl;
    		
    //	}
    }

",C++
8151089,"
    #include <iostream>
    using namespace std;
     
    int main() {
    	string s;
    	cin>>s;
    	int len=s.length();
    		int c=0,ch=0,che=0,chef=0;
    	for(int i=0;i<len;i++)
    	{
    	if(s[i]=='C')
    	c++;
    	else
    	if(s[i]=='H' && c>0)
    	{
    		c--;
    		ch++;
    	}
    	else
    	if(s[i]=='E' && ch>0)
    	{
    	ch--;
    	che++;
    	}
    	else
    	if(s[i]=='F' && che>0)
    	{
    	che--;
    	chef++;
    	}
    	}
    	cout<<chef<<endl;
    	return 0;
    } 
    

",C++
4060096,"
    #include<stdio.h>
    int main()
    {
        char s[100003];
        int c=0,h=0,f=0,e=0,i;
        scanf(""%s"",s);
        for(i=0;s[i];i++)
        {
            if(s[i]=='C')
                c++;
            else if(c>0&&s[i]=='H')
            {h++;c--;}
            else if(h>0&&s[i]=='E')
                {e++;h--;}
            else if(e>0&&s[i]=='F')
            {
                f++;
                e--;
            }
    
        }
        printf(""%d\n"",f);
        return 0;
    }
    

",C
3878276,"
    #include<iostream> 
    using namespace std; 
    #include<string.h> 
    int main() 
    { char s[100000];
    int a,b,c,d; 
    cin>>s; 
    int k=0; int m=0; 
    while(k<strlen(s)) 
    { 
      
    	for(int i=k;i<strlen(s);i++) 
    { 
    	if(s[i]=='C') 
    { 
    	a=i; 
    
    	 
    	break;
    } 
    } 
    for(int i=k;i<strlen(s);i++)
    { if(s[i]=='H')
    {  
    	b=i; 
    break; 
    }                 
    } 
    for(int i=k;i<strlen(s);i++) 
    { 
    	if(s[i]=='E') 
    { 
    	c=i; 
    	
    break;
    }
    }
    for(int i=k;i<strlen(s);i++) 
    {
    	if(s[i]=='F')
    { 
    	d=i;  break; } 
    }
    if(a<b&&b<c&&c<d) 
    m++,k=0,s[a]=s[b]=s[c]=s[d]='999',a=b=c=0; 
    else
    k++;
    } 
    cout<<m; 
    return 0;
    }

",C++
3845561,"
    #include<stdio.h>
    #include<string.h>
    #define max 1000002
    int main()
    {
    	long int len =0,k=0,i=0,j=0,l=0,count=0;
    	char c,h,e,f;
    	char arr[max];
        scanf(""%s"",&arr);
        
        len=strlen(arr);
        
       // printf(""%ld"",len);
        
        i=0;
        j=0;
        k=0;
        l=0;
        while(i<len-3 || j<len-2 || k<len-1 || l<len)
        {
        	
             if(arr[i]=='C')	
                {
                
           	     if(j==0)
        	      j=i+1;
        	      
        	      if(arr[j]=='H')
        	          {
        	    	    if(k==0)
        		         k=j+1;
        		         
        		            if(arr[k]=='E')
        		              {
        		      	        if(l==0)
        			             l=k+1;
        			       // printf(""i j k l are %ld %ld %ld %ld \n"",i,j,k,l);
        			            if(arr[l]=='F')
        			              {
        				          arr[i]='x';
        				          arr[j]='x';
        				          arr[k]='x';
        				          arr[l]='x';
        				          count++;
        				        //  printf(""new count is %lld\n"",count);
        				 			//i=0;
        							j=0;
        							k=0;
        							l=0;
        			               } 
    				                else l++;
    								if(l>=len)break;  
        		             }
        		    		else k++;
        		             if(k>=len-1)break;
        	         }
        	          else j++;
        	          if(j>=len-2) break;
              }
               else i++;
               if(i>=len-3) break;
        }
        printf(""%ld\n"",count);
        return 0;
    }

",C
3650031,"
    #include<stdio.h>
    int main()
    {
    	char str[100005]={0};
    	scanf(""%s"",str);
    	long int i=0,c=0,h=0,e=0,f=0;
    	while(str[i]!='\0')
    	{
       if(str[i]=='C')
       c++;
        if(c>0)
       {
       if(str[i]=='H')
       {h++;
       c--;
       }
       }
       if(h>0)
       {
       if(str[i]=='E')
       {e++;
       h--;
       }
      }
       if(e>0)
       {
    	if(str[i]=='F')
       {
    	f++;
        e--;
    	}
       }
       i++;
       }
    
       printf(""%ld\n"",f);
     // scanf(""%s"",str);
    return 0;
    }
    

",C++
3312597,"
    #include<iostream>
    #include<algorithm>
    #include<string.h>
    using namespace std;
    
    
    int main()
    {
        
        
        char s[100001],c[1000];
        strcpy(c,""CHEF"");
        
        
        cin>>s;
        int i,j,l,ctr=0;
        l=strlen(s);
        
        j=0;
        for(i=0;i<l;i++)
        {
         if(s[i]==c[j])
         {
         j++;
         if(j==4)
         j=0,ctr++;
         }
        }
        
        
        
        cout<<ctr<<endl;
        
        
      
        return 0;
    
    }
    

",C++
5463638,"
    #include <cstdio>
    #include <cmath>
    #include <iostream>
    #include <set>
    #include <algorithm>
    #include <vector>
    #include <map>
    #include <cassert>
    #include <string>
    #include <cstring>
    #include <queue>
    
    using namespace std;
    
    #define rep(i,a,b) for(int i = a; i < b; i++)
    #define S(x) scanf(""%d"",&x)
    #define SL(x) scanf(""%lld"",&x)
    #define P(x) printf(""%d\n"",x)
    
    typedef long long int LL;
    const int mod = 1000000007;
    const int N = 1<<20;
    LL A[N], B[N], C[N];
    
    int main() {
    	int n;
    	S(n);
    	rep(i,0,1<<n) SL(A[i]);
    	rep(i,0,1<<n) SL(B[i]);
    	rep(i,0,1<<n) SL(C[i]);
    
    	rep(j,0,n) rep(i,0,1<<n) {
    		 if((i>>j)&1) {
    			A[i] += A[i-(1<<j)];
    			B[i] += B[i-(1<<j)];
    
    			if(A[i] >= mod) A[i] -= mod;
    			if(B[i] >= mod) B[i] -= mod;
    		}
    	}
    
    	rep(i,0,1<<n) {
    		A[i] *= B[i];
    		A[i] %= mod;
    	}
    
    	rep(j,0,n) rep(i,0,1<<n) {
    		 if((i>>j)&1) {
    			A[i] -= A[i-(1<<j)];
    			if(A[i] < 0) A[i] += mod;
    		}
    	}
    
    	memcpy(B, C, sizeof(C));
    
    	rep(j,0,n) rep(i,0,1<<n) {
    		 if((i>>j)&1) {
    			A[i] += A[i-(1<<j)];
    			B[i] += B[i-(1<<j)];
    
    			if(A[i] >= mod) A[i] -= mod;
    			if(B[i] >= mod) B[i] -= mod;
    		}
    	}
    
    	rep(i,0,1<<n) {
    		A[i] *= B[i];
    		A[i] %= mod;
    	}
    
    	rep(j,0,n) rep(i,0,1<<n) {
    		 if((i>>j)&1) {
    			A[i] -= A[i-(1<<j)];
    			if(A[i] < 0) A[i] += mod;
    		}
    	}
    	LL ans = 0;
    	rep(i,0,1<<n) {
    		ans += A[i] * (1 << __builtin_popcount(i));
    		ans %= mod;
    	}
    	printf(""%lld\n"",ans);
    	return 0;
    }

",C++
358268,"
    #include<iostream>
    #include<string>
    #include<map>
    #include<climits>
    using namespace std;
    int n;
    string s;
    int memo[1000];//map<int,int>memo;
    bool ispalin[1002][1002];
    #define INF INT_MAX
    void ispal(){
    	int i=0;
    	int j;
    	int len=n;
    	for(j=1;j<=n;j++){
    		ispalin[1][j]=1;
    		ispalin[0][j]=1;
    		
    	}
    	for(i=2;i<=len;i++){
    		for(j=1;j+i-1<=n;j++){
    			if(s[j-1]==s[i+j-2]){
    				ispalin[i][j]=ispalin[i-2][j+1];
    			//	cout<<i<<"" ""<<j<<""\n"";
    			}
    			else ispalin[i][j]=0;
    		}
    	}
    	/*for(i=0;i<=n;i++){
    		for(j=0;j<=len;j++)cout<<ispalin[i][j]<<"" "";
    		cout<<""\n"";
    	}*/
    	return;
    }
    int memo1[10000];
    int fun1(int st){
    	if(st>n){
    		return memo1[st]=1;
    	}
    	if(st==n)return memo1[st]=1;
    	if(memo1[st])return memo1[st];
    	int i;
    	int count=0;
    	for(i=1;i+st-1<=n;i++){
    		if(ispalin[i][st]){
    			count=count+(fun1(st+i));
    			count %=1000000007;
    		}
    	}
    	return memo1[st]=count;
    }	
    
    int fun(int st){
    	if(st>n)return 0;
    	if(memo[st]){
    		return memo[st];
    	}
    	int i;
    
    	int minm=INF;
    	int count=0;
    	for(i=1;i+st-1<=n;i++){
    		if(ispalin[i][st]){
    			minm=min(minm,1+fun(st+i));
    	
    	
    		}
    	}
    	if(minm==INF)return -1;
    	//return memo[st]=count;
    	return memo[st]=minm;
    }
    int main(){
    	cin>>s;
    	n=s.size();
    	ispal();int i;
    //	cout<<ispalin[4][1]<<""\n"";
    //	cout<<fun(1);cout<<""\n"";
    	cout<<fun1(1);cout<<""\n"";
    //	for(i=1;i<=n;i++)cout<<memo1[i]<<"" "";
    	return 0;
    }
    

",C++
11950536,"
    #include <bits/stdc++.h>
    using namespace std;
    
    typedef pair<int,int> ii;
    typedef pair<ii,int> pii;
    typedef vector<int> vi;
    typedef vector<ii> vii;
    typedef vector<pii> vpii;
    typedef long long int ll;
    typedef unsigned long long int ull;
    
    #define mi 1000000007
    #define rep(i,a,b) for(i=a;i<b;i++)
    #define repv(i,a,b) for(i=b-1;i>=a;i--)
    #define pr(arr,n) rep(i,0,n) cout<<arr[i]<<"" ""; cout<<endl;
    #define pr1(arr,n) rep(i,1,n+1) cout<<arr[i]<<"" ""; cout<<endl;
    #define inf INT_MAX
    #define gc getchar_unlocked
    #define PB push_back
    #define MP make_pair
    #define fi first
    #define se second
    #define SET(a,b) memset(a,b,sizeof(a))
    #define MAX 500005
    #define gu getchar
    #define pu putchar
    #define si(n) scanf(""%d"",&n)
    #define dout(n) printf(""%d\n"",n)
    #define sll(n) scanf(""%lld"",&n)
    #define lldout(n) printf(""%lld\n"",n)
    
    #define TRACE
    
    #ifdef TRACE
    #define trace1(x)                cerr << #x << "": "" << x << endl;
    #define trace2(x, y)             cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << endl;
    #define trace3(x, y, z)          cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << "" | "" << #z << "": "" << z << endl;
    #define trace4(a, b, c, d)       cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << endl;
    #define trace5(a, b, c, d, e)    cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << "" | "" << #e << "": "" << e << endl;
    #define trace6(a, b, c, d, e, f) cerr << #a << "": "" << a << "" | "" << #b << "": "" << b << "" | "" << #c << "": "" << c << "" | "" << #d << "": "" << d << "" | "" << #e << "": "" << e << "" | "" << #f << "": "" << f << endl;
    
    #else
    
    #define trace1(x)
    #define trace2(x, y)
    #define trace3(x, y, z)
    #define trace4(a, b, c, d)
    #define trace5(a, b, c, d, e)
    #define trace6(a, b, c, d, e, f)
    
    #endif
    
    int mult(int x,int y)
    {
      ll ans,x1=(ll)x,y1=(ll)y;
      ans=(x1*y1)%mi;
      return (int)ans;
    }
    int gcd(int a,int b) { return b==0 ? a : gcd (b,a%b);}
    int lcm(int a,int b) { return a*(b/gcd(a,b));}
    
    ll pow1(ll a,ll b)
    {
      ll ans=1;
      while(b>0)
        {
          if(b&1) ans=(ans*a)%mi;	
          a=(a*a)%mi; b>>=1;
        }	
      return ans;
    }
    int mina(int arr[],int n)
    {
      int x=arr[0],i,pos=0;
      rep(i,1,n){ if(arr[i]<x) { x=arr[i]; pos=i; } }
      return x;
    }
    int maxa(int arr[],int n)
    {
      int x=arr[0],i,pos=0;
      rep(i,1,n){ if(arr[i]>x) { x=arr[i]; pos=i; } }
      return x;
    }
    bool prime[1100001];
    vi p;
    void sieve(int n)
    {
      ll i,j;
      memset(prime,true,sizeof(prime));
      prime[1]=false;
      for(i=4;i<=n;i=i+2)
        prime[i]=false;
      for(i=3;i*i<=n;i=i+2)
        {
          if(prime[i]==true)
            {
              for(j=i*2;j<=n;j=j+i)
                {
                  prime[j]=false;
                }
            }
        }
      rep(i,2,n)
        if(prime[i]==true)
          p.PB(i);
    }
    int a[100005],cnt[1000005];
    int main()
    {
      sieve(1000005);
      int n,i,j,mx=0;
      si(n);
      rep(i,0,n)
        {
          si(a[i]);
          mx=max(mx,a[i]);
          cnt[a[i]]++;
        }
      ll ans=0;
      rep(i,2,mx+1)
        {
          j=i;
          ll sum=0;
          while(j<=mx)
    	{
    	  sum+=cnt[j];
    	  j+=i;
    	}
          bool add=true;
          int sign=0;
          int x=i;
          for (j=2;j*j<=i;j++)
    	if(i%j==0)
    	  {
    	    i/=j;
    	    sign++;
    	    if(i%j==0)
    	      {
    		add=false;
    		break;
    	      }
    	  }
          if(i>1)
    	sign++;
          i=x;
          if(add==false)
    	continue;
          ll curr=((sum*(sum-1)*(sum-2))/6);
          if(sign%2)
    	ans+=curr;
          else
    	ans-=curr;
        }
      ans=(n*(n-1)*(n-2))/6-ans;
      lldout(ans);
      return 0;
    }
    

",C++
11483816,"
    //TEMPLATE---Akshit gUpta--///
    
    #include <bits/stdc++.h>
    using namespace std;
    
    #define ll long long
    #define f first
    #define s second
    #define F(i,a,b) for(ll i = (ll)(a); i < (ll)(b); i++)
    #define RF(i,a,b) for(ll i = (ll)(a); i >= (ll)(b); i--)
    #define inf LLONG_MAX
    #define mod 1000000007
    #define MAXN 100005
    #define pb(x) push_back(x)
    
    
    ll gcd(ll a , ll b){return b==0?a:gcd(b,a%b);}
    ll powmod(ll a,ll b)
     {ll res=1;if(a>=mod)a%=mod;for(;b;b>>=1){if(b&1)res=res*a;if(res>=mod)res%=mod;a=a*a;if(a>=mod)a%=mod;}return res;}
    
    long long C(int n, int r, int MOD)
    {
        vector< vector<long long> > C(n+1,vector<long long> (r+1,0));
    
        for (int i=0; i<=n; i++)
        {
            for (int k=0; k<=r && k<=i; k++)
                if (k==0 || k==i)
                    C[i][k] = 1;
                else
                    C[i][k] = (C[i-1][k-1] + C[i-1][k])%MOD;
        }
        return C[n][r];
    }
    
    int arr[100002];
    
    vector<int> divisors[1000001];
    
    long long int F[1000001],S[1000001];
    
    int main()
    {
    	int n;
    	scanf(""%d"",&n);
    	
    
    	for(int i=1;i<=1000000;i++)
        {
            for(int j=i;j<=1000000;j+=i)
            {
                divisors[j].push_back(i);
            }
        }
    
         for(int i=0;i<n;i++)
            {
            	scanf(""%d"",&arr[i]);
                for(int j=0;j<divisors[arr[i]].size();j++)
                {
                    F[divisors[arr[i]][j]]++;
                }
            }
    
             for(int i=1000000;i>=1;i--)
             {
                 long long int total,rem=0;
                 int j=2*i;
    
                 while(j<=1000000)
                 {
                     rem+=S[j];
                     j+=i;
                 }
    
               if(F[i]-2>0)
                 total=F[i]*(F[i]-1)*(F[i]-2),total/=6;
                else
                total=0;
                
                 S[i]=max((long long int)0,(long long int)total-rem);
    
             }
    
       long long int ans=S[1];
       printf(""%lld"",ans);
    
    	return 0;
    }
    

",C++
12102380,"
    #include <iostream>
    using namespace std;
     
    int M = 1000000007;
     
    long long int mypow(int n, int p)
    {
        long long int retval = 1;
        long long int temp = p;
        
        while(n!=0)
        {
            if(n%2==1)
            {
                retval = (retval*temp)%M;
                temp = (temp*temp)%M;
            }
            else
            {
                temp = (temp*temp)%M;
            }
            n = n/2;
        }
        
        return retval;
    }
     
    int main() {
    	int t,n;
    	long long int ans;
    	cin >> t;
    	while(t--)
    	{
    	  cin >> n;
    	  ans = (mypow(2,n-1)%M - 2)%M;
    	  cout << ans << endl;
    	}
    	return 0;
    }

",C++
5162812,"
    #include <cstring>
    #include <algorithm>
    #include <cstdio>
    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    int t, n;
    
    long long gcd(long long x, long long y) {if (y==0) return x; else return gcd(y, x%y);}
    
    int main() {
    //  freopen(""maxand.in"", ""r"", stdin);
    //  freopen(""maxand.out"", ""w"", stdout);
      scanf(""%d"",&t);
      for(int T=1; T<=t; T++) {
        scanf(""%d"",&n);
        long long sum=0LL;
        int k=sqrt(n);
        for(int i=1; i<=k; i++) sum=sum+n/i;
        sum=sum*2LL-k*k;
        long long nll=1LL*n*n;
        long long nzd=gcd(sum, nll);
        printf(""%lld/%lld\n"",sum/nzd, nll/nzd);
      }
      return 0;
    }

",C++
11660200,"
    #include<bits/stdc++.h>
    using namespace std;
    int main(){
      int t;cin>>t;
      while(t--){
        int n;cin>>n;
        int a[n+2];
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        int ans=1,cmp=a[1];
        for(int i=2;i<=n;i++){
            if(a[i]<=cmp){
                cmp=a[i];
                ans=ans+1;
            }
        }
        cout<<ans<<""\n"";
      }
      return 0;
    }
    

",C++
11512816,"
    /* package codechef; // don't place package name! */
    
    import java.util.*;
    import java.lang.*;
    import java.io.*;
    
    /* Name of the class has to be ""Main"" only if the class is public. */
    class Codechef
    {
    	public static void main (String[] args) throws java.lang.Exception
    	{
    		// your code goes here
    		
    		
    		//FileReader in = new FileReader(""/home/abhishek/workspace/codechef/src/testCases"");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
    	BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    	
    	int N= Integer.parseInt(br.readLine());
    	
    	for(int i=0 ;i<N ;i++)
    	{
    		
    		int noOfCar = Integer.parseInt(br.readLine());
    		int[] cars = new int[noOfCar];
    		//System.out.println(N);
    		int highCar = 1;
    		
    		
    		
    			
    			
    			
    			String[] strs = br.readLine().split("" "");
    			
    			
    			
    			
    			for (int j= 0; j < noOfCar; j++) 
    			{
    				cars[j] = Integer.parseInt(strs[j]);
    			    
    			}
    			
    			for(int h=1 ; h<noOfCar ; h++)
    			{
    				if(cars[h-1]>cars[h])
    				{
    					highCar++;
    				}
    				else
    				{
    					cars[h]=cars[h-1];
    				}
    				
    			}
    			
    			
    		
    		
    		out.write(highCar+""\n"");
    		
    		
    		
    		
    	}
    		
    		
    		
    		
    		
    		
    		
    		
    		
    		
    		
    		
    		
    		
    	out.flush();	
    
    	}
    }
    

",JAVA
9046442,"
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    int t,n,c,i;
    long long int a[10000],max;
    scanf(""%d"",&t);
    while(t--)
    {
        c=1;
    scanf(""%d"",&n);
    for(i=0;i<n;i++)
    {
    scanf(""%lld"",&a[i]);
    }
    max=a[0];
    for(i=1;i<n-1;i++)
    {
    if(a[i]<max)
    {
        max=a[i];
    c++;
    }
    }
    printf(""%d\n"",c);
    }
    return 0;
    }
    

",C
8119282,"
    #include <bits/stdc++.h>
    
    using namespace std;
    
    long speed[10001];
    
    int main(){
    
    	ios_base::sync_with_stdio(false);
    	cin.tie(0);
    
    	int T, N;
    	speed[0]= 10000000000000;
    
    	cin >> T;
    
    	while( T-- ){
    
    		cin >> N;
    		int count= 0;
    
    		for( int i= 1; i<= N; ++i ){
    			cin >> speed[i];
    			if( speed[i] < speed[i-1] )
    				count++;
    		}
    
    		assert( count <= N );
    
    		cout << count << endl;
    
    	}
    
    }

",C++
7562674,"
    #include<stdio.h>
    
    int main()
    {
    
    int t;
    scanf(""%d"",&t);
    
    int g,i,n,q;
    
    while(t>0)
    {
    
    t--;
    scanf(""%d"",&n);
    int b[n];
    
    for(g=0;g<n;g++)
        scanf(""%d"",&b[g]);
    
    i=1;
    int a=0;
    q=b[a];
    
    for(g=1;g<n;g++)
    {
    
        if(b[g]<=q)
        {i++;
        q=b[g];
        }
    }
    
    printf(""%d\n"",i);
    
    }
    
    
    
    return 0;
    
    }
    

",C
6340214,"
    #include <iostream>
    using namespace std;
    
    int main() {
    	ios::sync_with_stdio(false);
    	int t;
    	cin>>t;
    	while(t>0){
    		int n;
    		cin>>n;
    		int prev;
    		int counter=1;
    		for(int i=0;i<n;i++){
    			int x;
    			cin>>x;
    			if(i==0){
    				prev=x;
    				continue;
    			}
    			else{
    				if(x<=prev){
    					counter++;
    					prev=x;
    				}
    			}
    			
    		}
    		cout<<counter<<'\n';
    		t--;
    	}
    	return 0;
    }

",C++
5458510,"
    #include <cmath>
    #include<stdio.h>
    #include <cstdio>
    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    int main() {
        long n;
        cin>>n;
         for(long i=0;i<n;i++)
       {
        long s,min,k=1;
        cin>>s;
        long a[s];
        cin>>a[0];
        min=a[0];
        for(long j=1;j<s;j++)
       {
       cin>>a[j];
         if(a[j]<=min)
         ++k;
         if(a[j]<min)
         min=a[j];
    
       }
       cout<<k<<endl;
       }
        /* Enter your code here. Read input from STDIN. Prlong output to STDOUT */
        return 0;
    
    }
    

",C++
5198111,"
    #include<stdio.h>
    #include<stdlib.h>
    
    
    int main()
    {
        int t;
        scanf(""%d"",&t);
        
        while(t--)
        {
              int i,n;
              scanf(""%d"",&n);
              
              int a[n];
              for ( i =  0; i < n; i++ )
                    a[i] = 0;
              
              
              
              for ( i =  0; i < n; i++ )
                  scanf(""%d"",&a[i]);
              
              int count;
              count = 0;
                  
              for ( i = 0; i < n; i++)
              {
                  if ( a[i] >= a[i+1] )
                  {
                       count++;
                  }
              }
              
              count = count + 1;
              
              printf(""%d\n"",count);
        }
                  
      //  getchar();
      //  system(""pause"");
        return 0;
    }              
    

",C++
3623385,"
    #include<stdio.h>
    int main()
    {
        int t,c,i,n,x,y;
        scanf(""%d"",&t);
        while(t--)
        {
            c=1;
            scanf(""%d"",&n);
            scanf(""%d"",&x);
            for(i=1;i<n;i++)
            {
                scanf(""%d"",&y);
                if(y<=x){
                    c++;
                x=y;}
            }
            printf(""%d\n"",c);
        }
        return 0;
    }
    

",C
3447966,"
    #include<stdio.h>
    int main()
    {
     long int a[10009],b,c=1,j,l,i,n;
    scanf(""%d"",&b);
    for(i=0;i<b;i++)
    {
    	c=1;
    	scanf(""%d"",&n);
    		for(j=0;j<n;j++)
    	{
    	
    	scanf(""%ld"",&a[j]);
    	
    }
    	if(n==1)
    	{
    		printf(""%d\n"",c);
    	}
    	else
    	{
    	for(l=1;l<n;l++)
    	{
    		if(a[l]<=a[l-1])
    		{
    			c=c+1;
    		}
    	}
    
    	printf(""%d\n"",c);
    }
    
    }
    }

",C
3300808,"
    #include<stdio.h>
    int main()
    {
        int T,N,M,i,j;
        scanf(""%d"",&T);
        int C[T];
        for(i=0;i<T;i++)
        C[i]=1;
        for(i=0;i<T;i++)
        {
            scanf(""%d"",&N);
            int MAX[N];
    
            scanf(""%d"",&MAX[0]);
            M=MAX[0];
            for(j=1;j<N;j++)
            {
                scanf(""%d"",&MAX[j]);
                if(MAX[j]<M)
               {
                 C[i]=C[i]+1;
                 M=MAX[j];
               }
            }
        }
        for(i=0;i<T;i++)
        printf(""%d\n"",C[i]);
        return 0;
    }
    //4 6 5 1 2 3
    

",C
2511536,"
    #include<iostream>
    using namespace std;
     
     
     
    int N = 0; //Number of test cases
    int W = 0; //number of cars in each test case
    int input = 0; //next input , speed
    int allowed = 0; // max. speed possible after each input
    int counter = 1; //answer of each test case
     
     
     
    int main()
    {
     
     
    cin>>N;
     
     
    while(N--)
    {
    cin>>W;
     
    if(W==1)
    {
     
    cin>>input;
    cout<<""1""<<endl;
    }
    else
    {
    W--;
    cin>>input;
    allowed = input;
    counter = 1;
     
    while(W--)
    {
    cin>>input;
    if(input<=allowed)
    {
    allowed = input;
    counter++;
    }
     
    }
    cout<<counter<<endl;
    }
    }
     
    return 0;
    }

",C++
1469948,"
    #include <stdio.h>
    
    int scan(){
    	int t=0;
    	char c;
    	c=getchar_unlocked();
    	while(c<'0' || c>'9')
    		c=getchar_unlocked();
    	while(c>='0' && c<='9'){
    		t=(t<<3)+(t<<1)+c-'0';
    		c=getchar_unlocked();
    	}
    	return(t);
    }
    
    int main(){
    	int t,i,l;
    	char ch[5000];
    	t=scan();
    	while(t--){
    		scanf(""%s"", &ch);
    		l=1;
    		i=0;
    		int pr=ch[0];
    		for(i=0;ch[i];i++){
    			l++;
    			if(ch[i]<pr)
    				l=l+26+ch[i]-pr;
    			else
    				l=l+ch[i]-pr;
    			pr=ch[i];
    		}
    		if(l>11*i) printf(""NO\n"");
    		else printf(""YES\n"");
    		
    	}
    	return 0;
    }

",C
6961535,"
    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <algorithm>
    #include <cmath>
    #include <cstring>
    using namespace std;
    
    int main(){
    	int tcases;
    	scanf(""%d\n"",&tcases);
    	int currTime, x,l,f;
    	int N;
    	while(tcases--){
    	    scanf(""%d\n"",&N);
    	    currTime = 0;
    	    for(int i =0; i < N; i++){
    	        scanf(""%d %d %d\n"",&x,&l,&f);
    	        if(currTime < x){ currTime = x;}
    	        else{
    	            int a = ((currTime-x)/f);
    	            int b = (currTime-x)%f;
    	            currTime = x + a*f;
    	            if( b!= 0){ currTime += f; }}
    	        //currTime = currTime + (x- (currTime%f) + f)%f;
    	        
    	        currTime+= l;
    	    }
    	    cout << currTime << endl;
    	}
    	return 0;
    }
    

",C++
785273,"
    #include <stdio.h>
    
    int main()
    {
        short int T;
        short int n;
        short int xi;
        short int li;
        short int fi; 
        int t;
        int ReachedAtPrevStation;
        int reachedAtInitStation;
        long int time;
        
        scanf(""%hd"", &T);
        while(T--)
        {
           scanf(""%hd"", &n);
           time = -1;
           while(n--)
           {
               scanf(""%hd%hd%hd"", &xi, &li, &fi);
               if( time < 0 )
               {
                  time = 0; 
               }
               else
               {
                  for(; ReachedAtPrevStation > xi; xi += fi );
               }
               ReachedAtPrevStation = xi + li; 
           }
           time = ReachedAtPrevStation;
           printf(""%ld"", ReachedAtPrevStation);
        }
        return 0;
    }
    

",C
7576860,"
    #include<iostream>
    #include<string>
    #include<cstdlib>
    #include<cstdio>
    #include<string>
    #include<cstring>
    #include<cmath>
    #include<set>
    #include<functional>
    #include<algorithm>
    #include<climits>
    #include <vector>
    #include<list>
    #include<map>
    #include<stack>
    #include<queue>
    #include <vector>
    //#include <bits/stdc++.h>
    
    #define read(a) cin>>a
    #define write(a) cout<<a
    #define writeln(a) cout<<a<<endl
    #define endl() cout<<endl
    #define mp make_pair
    #define pb push_back
    #define REP(i,n) for(int i = 0;i < n; i++)
    #define REPMAP(i,mm) for(auto i = mm.begin();i !=mm.end(); i++)
    #define mod %
    #define NUM 1000000007
    //#define morethanonetestcases
    //#define testing
    #define LONG_LONG_MAX	9223372036854775807LL
    //#define M_PI   3.14159265358979323846264338327950288
    #define EPS 1e-6
    
    #define trace1(x)                cerr << #x << "": "" << x << endl;
    #define trace2(x, y)             cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << endl;
    #define trace3(x, y, z)          cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << "" | "" << #z << "": "" << z << endl;
    
    
    typedef long long int ll;
    
    using namespace std;
    
    typedef long long int ll;
    typedef vector<ll> VI ;
    typedef pair<ll,ll>  PP;
    
    
    
    /*
    
    ll combination(int n , int r){
    	if(n==r)
    		return 1;
    	if(r==0)
    		return 1;
    	if(r==1 || r==n-1)
    		return n;
    
    	ll d=1;
    
    	int i=1;
    	if(r > n/2)
    		r = n-r;
    
    	int x=n,y=1;
    
    	while(i<=r){
    		d *= x;
    		d /= y;
    		y++;
    		x--;
    		i++;
    	}
    
    	return d;
    }
    ll gcd(ll a,ll b){
    	if(b == 0 or a == 0)
    		return a+b;
    	return gcd(b,a mod b);
    }
    
    ll balance(ll ans){
    	if(ans >= NUM)
    		return ans mod NUM;
    	while(ans<0){
    		ans+=NUM;
    	}
    	return ans;
    }
    int getLength(ll x){
    	int len = 1;
    	while(x>10){
    		x/=10;
    		len++;
    	}
    	return len;
    }
    ll getReverse(ll x){
    	ll rev = 0;
    	while(x>0){
    		ll a = x%10;
    		rev = rev*10 + a;
    		x/=10;
    	}
    	return rev;
    }
    
    int noofones(ll x){
    	int a = 0;
    	while(x>0){
    		if(x%2 != 0)
    			a++;
    		x/=2;
    	}
    	return a;
    }
    
    int gcdExtended(int a, int b, int *x, int *y)
    {
        // Base Case
        if (a == 0)
        {
            *x = 0;
            *y = 1;
            return b;
        }
    
        int x1, y1; // To store results of recursive call
        int gcd = gcdExtended(b%a, a, &x1, &y1);
    
        // Update x and y using results of recursive
        // call
        *x = y1 - (b/a) * x1;
        *y = x1;
    
        return gcd;
    }
    
    // This function calculates (base^e)%MOD
    int powmod(int base, int exponent, int MOD) {
    int x = 1, y = base;
        while(exponent > 0) {
            if(exponent%2 == 1) {
                x=(x*y);
                if(x>MOD) x%=MOD;
            }
            y = (y*y);
            if(y>MOD) y%=MOD;
            exponent /= 2;
        }
        return x;
    }
    
    //Fermat�s Little Theorem to find modular multiplicative inverse
    //Fermat�s little theorem states that if m is a prime and a is an integer co-prime to m, then ap � 1 will be evenly divisible by m. That is [a^(m-1) = 1] (mod m). or [a^(m-2) = a^-1] (mod m).
    int modularMultiplicativeInverse(int a, int m) {
        return powmod(a,m-2,m);
    }
    
    
    */
    
    
    
    void solve(){
    
    	int n,q;
    	cin>>n>>q;
    	register int id,att,val,pr;
    	map<pair<int,int>,pair<int,int>> mm;
    	REP(i,n){
    		cin>>id>>att>>val>>pr;
    		PP p = mp(id,att);
    		if(mm.find(p) == mm.end())
    			mm[p] = mp(val,pr);
    		else{
    			int pr_old = mm[p].second;
    			if(pr_old<=pr){
    				mm[p] = mp(val,pr);
    			}
    		}
    	}
    	REP(i,q){
    		cin>>id>>att;
    		cout<<mm[mp(id,att)].first<<endl;
    	}
    
    }
    
    int main(){
    
    	cin.sync_with_stdio(0);
    	cout.sync_with_stdio(0);
    #ifdef testing
    	freopen(""input.txt"",""r"",stdin);
    #endif
    
    
    //	freopen(""output.txt"",""w"",stdout);
    
    #ifdef morethanonetestcases
    	int TC;
    	read(TC);
    #else
    	int TC = 1;
    #endif
    	for(int ZZ=1;ZZ<=TC;ZZ++){
    //		cout<<""Case #""<<ZZ<<"": "";
    		solve();
    		cout<<endl;
    	}
    	return 0;
    }
    

",C++
7583433,"
    #include<iostream>
    #include<limits.h>
    #define inf INT_MAX
    #define ll long long
    using namespace std;
    int main()
    {
    int t,n,m;
    cin>>t;
    while(t--)
    {
    cin>>n>>m;
    ll p[n][m];
    ll d[n][m];
    ll ans[n][m];
    for(int i=0;i<n;i++)
    {
    for(int j=0;j<m;j++)
    {
    cin>>p[i][j];
    }
    }
    for(int i=0;i<n;i++)
    {
    for(int j=0;j<m;j++)
    {
    cin>>d[i][j];
    }
    }
    ll f_minp=9999999999;
    ll minp=999999999999;
    for(int j=0;j<m;j++)
    {
    ans[0][j]=p[0][j];
    if(ans[0][j]<f_minp)
    f_minp=ans[0][j];
    }
    for(int i=1;i<n;i++)
    {
    minp=9999999999;
    for(int j=0;j<m;j++)
    {
    ll dis=(p[i][j]-d[i-1][j]);
    if(dis<0)
    dis=0;
    ans[i][j]=ans[i-1][j]+dis;
    ans[i][j]=min(ans[i][j],f_minp+p[i][j]);
    minp=min(minp,ans[i-1][j]);
    }
    f_minp=minp;
    }
    /*cout<<endl;
    for(int i=0;i<n;i++)
    {
    for(int j=0;j<m;j++)
    {
    cout<<ans[i][j]<<' ';
    }
    cout<<endl;
    }*/
    ll a=9999999999;
    for(int i=0;i<m;i++)
    a=min(a,ans[n-1][i]);
    cout<<a<<endl;
    }
    }
    

",C++
4759618,"
    // THe leaking robot
    #include<iostream>
    #include<string>
    #include<stdlib.h>
    #include<stdio.h>
    using namespace std;
    
    string point_visited(int,int);
    
    int main()
    {
    	std::ios_base::sync_with_stdio(0);
    #ifndef ONLINE_JUDGE
    	freopen(""ip.txt"", ""r"", stdin);
    	freopen(""output.txt"", ""w"", stdout);
    #endif
    
    	int T,x,y;
    	cin>>T;
    	for(int i=0;i<T;i++)
    	{
    		cin>>x;cin>>y;//y*=-1;
    		//scanf(""%d%d"", &x, &y);
    		if (x > 0 && x % 2 == 1 && y >= -x + 1 && y <= x + 1)		//right vertical lines
    			printf(""YES\n"");
    		else if (x < 0 && x % 2 == 0 && y >= x && y <= -x)			//left vertical lines
    			printf(""YES\n"");
    		else if (y > 0 && y % 2 == 0 && x >= -y && x < y)			//upper gorizontal lines
    			printf(""YES\n"");
    		else if (y <= 0 && y % 2 == 0 && x >= y && x <= -y + 1)		//down gorizontal lines
    			printf(""YES\n"");
    		else printf(""NO\n"");
    	}
    	return 0;
    }
    
    string point_visited(int x,int y)
    {
    	if((x==0 && y==0) || (x==1 && y==0))
    		return ""YES"";
    	if((x>0 && abs(x)%2==1) || (x<0 && abs(x)%2==0) )
    	{
    		//cout<<""xxx""<<endl;
    		if(abs(x)%2==1)
    		{//cout<<""xxxeven x=""<<x<<""  y=""<<y<<endl;
    			if(((-1*(x-1))<=y) && (y<=(x+1))){//cout<<""xxx y in x range""<<endl;
    				return ""YES"";}
    
    		}
    		else
    		{
    			if(x<=y && y<=-(x))
    				return ""YES"";
    		}
    	}
    	if(abs(y)%2==1)
    		return ""NO"";
    	if(y>0)
    	{
    		if(-(y)<=x && x<=(y+1))
    			return ""YES"";
    	}
    	else	
    		if((y)<=x && x<=(-1*(y)+1))
    			return ""YES"";
    	return ""NO"";
    }
    

",C++
9476498,"
    #include <bits/stdc++.h>
    using namespace std;
    
    int main()
    {
     ios_base::sync_with_stdio(false);
     int n, age, rating, diff, young, old, mid, i;
     set < pair <int, int> > st;
     cin >> n;
     while(n --)
     {
      cin >> age >> rating;
      young = 0;
      old = 0;
      st.insert(make_pair(age, rating));
      mid = ceil(st.size());
      for(i = 1; i <= st.size(); i ++)
      {
       if(i <= mid)
          young += st[i - 1].second;
       else
          old += st[i - 1].second;
      }
      diff = abs(young - old);
      cout << diff << '\n';
     }
     return 0;
    }

",C++
574023,"
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    struct arr{
           int age;
           int rate;
    };
    int abs1(int a)
    {
        if(a>0) return a ; return -a;
    }
    
    int insert(struct arr H[],int size)
    {
         int i=size-1;
         if(size==1)return 0;
         
         struct arr t;
         while(H[i].age< H[(i-1)/2].age && i>=0)
         {
                          t=H[i];
                          H[i]=H[(i-1)/2];
                          H[(i-1)/2]=t;
                          i=(i-1)/2;
         }
         return 0;
    }
    
    void delete1(struct arr H[],int size, int i)
    {
         struct arr t;
         if(H[i].age > H[2*i +1].age && 2*i +1 <size)
         {
                     if(H[2*i+2].age < H[(2*i + 1)].age && 2*i+2 <size)
                     {
                                t=H[i];
                                H[i]=H[2*i+2];
                                H[2*i+2]=t;
                                delete1(H,size,2*i +2);
                     }
                     else
                     {
                                t=H[i];
                                H[i]=H[2*i+1];
                                H[2*i+1]=t;
                                delete1(H,size,2*i +1);
                     }
         }     
          else if(H[i].age > H[2*i +2].age && 2*i +2 <size)
          {
                                 t=H[i];
                                H[i]=H[2*i+2];
                                H[2*i+2]=t;
                                delete1(H,size,2*i +2);
          }
         return ;
    }
    
                           
    int main()
    {
        int i,j=0,n,k,size1=0,size2=0,cmp,cmp1;
        scanf(""%d"",&n);
        arr Hmax[n+1],Hmin[n+1],t;
         int  s1=0,s=0;
        i=0;
        while(i<n)
        {
                  scanf(""%d%d"",&t.age,&t.rate);
                  s=s+t.rate;
                  if(i==0){Hmin[0]=t;Hmin[0].age=Hmin[0].age*-1;size1++;s1=Hmin[0].rate;}
                  else{
                        if(size1>=size2){cmp=-1*Hmin[0].age;cmp1=Hmin[0].rate;}
                        else{cmp=Hmax[0].age;cmp1=Hmax[0].rate;}
                        
                         if(t.age>cmp)
                         {
                              Hmax[size2]=t;
                              size2++;
                              insert(Hmax,size2);
                              //s1=s1+Hmax[0].rate;
                         }
                         
                         else
                         {
                             //printf(""%d %d\n"",s1,cmp1);
                             s1=s1 + t.rate;
                             
                             Hmin[size1]=t;
                             Hmin[size1].age=Hmin[size1].age*-1;
                             size1++;
                             insert(Hmax,size1);
                         }
                         
                         
                         if( size1-size2>1)
                         {
                             size1--;
                             s1=s1-Hmin[0].rate;
                             Hmax[size2]=Hmin[0];
                             Hmax[size2].age=-1*Hmin[size2].age;
                             size2++;
                             insert(Hmax,size2);
                             Hmin[0]=Hmin[size1];
                             delete1(Hmin,size1,0);
                         }
                         else if( size2-size1>1)
                          {
                             size2--;
                             s1=s1+Hmax[0].rate;
                             Hmin[size1]=Hmax[0];
                             Hmin[size1].age=-1*Hmin[size1].age;
                             size1++;
                             insert(Hmin,size1);
                             Hmax[0]=Hmax[size2];
                             delete1(Hmax,size2,0);
                         }
                        //if(size1>=size2){cmp=-1*Hmin[0].age;cmp1=Hmin[0].rate;}
                        //else{cmp=Hmax[0].age;cmp1=Hmax[0].rate;} 
                        
                        //if(i%2==0){s1=s1+cmp1;}
                          
                        
                  }
                  /*
                  for(j=0;j<size1;j++)
                   printf(""%d %d"",-1*Hmin[j].age,Hmin[j].rate);
                   
                   printf(""\n"");
                   
                   for(j=0;j<size2;j++)
                   printf(""%d %d"",Hmax[j].age,Hmax[j].rate);
                   
                   printf(""\n"");
                   
                   printf(""%llu %llu\n"",s,s1);*/
                   
                   if(size1>=size2)
                   printf(""%d\n"",abs1(s-2*s1));
                   else
                   printf(""%d\n"",abs1(s-2*s1 - 2*Hmax[0].rate));
                   i++;
        }
                  
                  return 0;
    }
    

",C++
7281160,"
    //written by raj_0jaiswal
    #include <bits/stdc++.h>
    using namespace std;
    #define crt()  int t; cin>>t; while(t--)
    #define ll long long
    #define mod 1000000007
    #define mxx 1000005
    #define sc(n) scanf(""%d"",&n)
    #define out(x) #x << "" = "" << x << ""   ""
    #define pb                      push_back
    #define vt                      vector<int>
    #define pi                      pair<int,int>
    #define mp                      make_pair
    #define ff                      first
    #define ss                      second
    #define maX(a,b)                ((a)>(b)?(a):(b))
    #define miN(a,b)                ((a)<(b)?(a):(b))
    #define INF                     (int)1e9
    #define SORT(_a,_b)             sort(_a,_b,greater<int>())
    /*inline int scan(){ register int t=0;char c=getchar_unlocked();while(c<'0' || c>'9')c=getchar_unlocked();
    while(c>='0' && c<='9'){t=(t<<3)+(t<<1)+c-'0';c=getchar_unlocked();} return(t);}*/
    ll power2(ll aa,ll pp){ ll xx=1,yy=aa%mod; while(pp>0){ if(pp&1) xx=(xx*yy)%mod; yy=(yy*yy)%mod; pp=pp>>1;} return xx%mod;}
    bool cmp(pi a,pi b){if(a.ff!=b.ff)return a.ff<b.ff; else return a.ss<b.ss;}
    void mul(ll a[][3],ll b[][3])
    {
        ll res[3][3];
        memset(res,0,sizeof(res));
        int i,j,k;
        for(i=0;i<3;i++)
            for(j=0;j<3;j++)
               for(k=0;k<3;k++)
                  res[i][j] = (res[i][j] + a[i][k]*b[k][j])%mod;
        for(i=0;i<3;i++)
            for(j=0;j<3;j++)
        a[i][j]=res[i][j];
    }
    ll power1(ll n)
    {
        ll f[3][3] = {{1,1,0},{1,0,1},{1,0,0}};
        ll tmp[3][3] = {{4,2,1},{0,0,0},{0,0,0}};
        while(n)
        {
            if(n&1)
            mul(tmp,f);
            mul(f,f);
            n=n>>1;
        }
        return tmp[0][0]%mod;
    }
    int main()
    {
        ios_base::sync_with_stdio(false);
        crt()
        {
            ll n,k,ans;
            cin>>n;
            if(n==1 || n==2){cout<<""0""<<endl; continue;}
            k=power2(2,n);
            ans=power1(n-2);
            cout<<(k-ans+mod)%mod<<endl;
        }
        return 0;
    }
    

",C++
7498071,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	int test,count=0,i,j,l;
    	char str[1000000];
    	scanf(""%d"",&test);
    	while(test--)
    	{
    	scanf(""%s"",str);
    	l=strlen(str);
    	for(i=0;i<l;i++)
    	{
    		for(j=i+1;j<l;j++)
    		if(str[i]== '<' )
    		if(str[j]=='>')
    		{
    		count=count+2;
    		str[j]='1';
    		break;
    	    }
    	}	
    	printf(""%d\n"",count);
    	
    	
    	}
    	return 0;
    }

",C
4890665,"
        //http://www.codechef.com/problems/COMPILER
        #include<stdio.h>
        #include<string.h>
        #define MAX 1000005
        char s[MAX];
        char stack[MAX];
        int top=-1;
        void push(char item);
        char pop();
        int main()
        {
        int t;
        scanf(""%d"",&t);
        while(t--){
        scanf(""%s"",s);
        int i,pos=0;
        long int l=0,max=-1,a=strlen(s);
        for(i=0;i<a;i++)
        {
        char ch=s[i];
        if(ch=='<')
        push(ch);
        else if(ch=='>')
        {
        char ch1;
        ch1=pop();
        if(ch1=='<')
        l+=2;
        else
        {l=0;pos=i;}
        if(l>max)
        max=l;
        }
        
        
        }
        top=-1;
        printf(""%ld\n"",max);
        }
        return 0;
        }
        void push(char item)
        {
        top++;
        stack[top]=item;
        }
        char pop()
        {
        if(top==-1)
        return;
        char ch;
        ch=stack[top];
        top--;
        return ch;
        }
    

",C
4406232,"
    #include<cstdio>
    #include<iostream>
    using namespace std;
    main()
    {
    int t;
    scanf(""%d"",&t);
    while(t--)
    {
    int ans=0,p=0,done=0;
    char s[1000011];
    scanf(""%s"",s);
    for(int i=0;s[i]!='\0';i++)
    {
    if(s[i]=='<')
    p++;
    else if(s[i]=='>')
    p--;
    if(p==0)
    ans=i+1;
    else if(p<0)
    {
    done=1;
    break;
    }
    }
    cout<<ans<<endl;
    }
    return 0;
    }
    

",C++
3182791,"
    // laflare
    // CUBESUM
    #include<iostream>
    #include<vector>
    #include<set>
    #include<map>
    #include<queue>
    #include<stack>
    #include<string>
    #include<algorithm>
    #include<functional>
    #include<iomanip>
    #include<cstdio>
    #include<cmath>
    #include<limits.h>
    #include<cstring>
    #include<cstdlib>
    #include<cfloat>
    #include<cassert>
    #define maxm(a,b) a>b?a:b;
    #define minm(a,b) a<b?a:b;
    using namespace std;
    //M lazy ;)
    typedef long long ll;
    typedef vector <int> vi;
    typedef pair< int ,int > pii;
    typedef istringstream iss;
    typedef ostringstream oss;
    typedef map<int,int> mp;
    #define pb push_back
    #define mp make_pair
    #define ff first
    #define ss second
    #define sz size()
    #define ln length()
    #define repb(i,n) for(i=n-1;i>=0;i--)
    #define rep(i,n) for(int i=0;i<n;i++)
    #define fu(i,a,n) for(int i=a;i<=n;i++)
    #define fd(i,n,a) for(int i=n;i>=a;i--)
    #define all(a)  a.begin(),a.end()
    #define ESP (1e-9)
    #define gi(n) scanf(""%d"",&n)
    #define gl(n) cin >> n
    #define pi(n) printf(""%d"",n)
    #define pl(n) cout << n
    #define ps printf("" "")
    #define pn printf(""\n"")
    #define dg(n,s); printf(""%s %d"",s,n)
    #define imax numeric_limits<int>::max()
    #define imin numeric_limits<int>::min()
    #define lmax numeric_limits<ll>::max()
    #define lmin numeric_limits<ll>::min()
    #define traverse_map(a,b) for(mp::iterator it=a;it!=b;++it)
    #define MOD 1000000007
    #define MAX 1000001
    #define cases() int t; cin>>t; while(t--)
    // fast input function
    #define getcx getchar_unlocked
    // fast input function
    #ifdef ONLINE_JUDGE
     inline void inp( int &n )
     {
        n=0;
        int ch=getcx();int sign=1;
        while( ch < '0' || ch > '9' ){if(ch=='-')sign=-1; ch=getcx();}
    
        while(  ch >= '0' && ch <= '9' )
                n = (n<<3)+(n<<1) + ch-'0', ch=getcx();
        n=n*sign;
      }
    #else
    inline void inp(int &n){
     cin>>n;
    }
    #endif
    /*
    inline long long inp(){
    	char c = getchar_unlocked();
    	long long n = 0;
    	while(c < '0' || c > '9') c = getchar_unlocked();
    	while(c >= '0' && c <= '9')
    		n = (n<<3) + (n<<1) + c - '0', c = getchar_unlocked();
    	return n;
    }
    
    #define pc putchar_unlocked
    inline void oup(int n){
    	if(!n) pc('0');
    	char pb[2];
    	int pi = 0;
    	while(n) pb[pi++] = (n%10) + '0', n /= 10;
    	while(pi) pc(pb[--pi]);
    }*/
    int main(){
     int t;
     inp(t);
     while(t--)
     {
    		int x,y,z,i,j,k;
    		
    		inp(x);
    		inp(y);
    		inp(z);
                int mat_3d[x][y][z];
    
    		rep(i,x)
    		 rep(j,y)
    		   rep(k,z)
    		      inp(mat_3d[i][j][k]);
    
    		int a,b,c,d;
                repb(i,x)
    		 repb(j,y)
    		 {
    				repb(k,z)
    				{
    					
    					a=0;
    					b=0;
    					c=0;
    					d=0;
    					if(i>0)
    					{
    						b=mat_3d[i-1][j][k];
    						if(j>0)
    						 b-=mat_3d[i-1][j-1][k];
    					}
    					if(k>0)
    					{
    						c=mat_3d[i][j][k-1];
    						if(j>0)
    						 c-=mat_3d[i][j-1][k-1];
    					}
    					if(i>0&&k>0)
    					{
    						d=mat_3d[i-1][j][k-1];
    						if(j>0)
    						 d-=mat_3d[i-1][j-1][k-1];
    					}
    					
    					 a=mat_3d[i][j][k];
    					 if(j>0)
    					  a-=mat_3d[i][j-1][k];
    				
    					  mat_3d[i][j][k]=a-b-c+d;
    				}
    		 }
    		 
    		 
    		 rep(i,x)
    		  rep(j,y)
    		  {
    				rep(k,z)
    				 printf(""%d "",mat_3d[i][j][k]);
    				   printf(""\n"");
    		  }
     }
     return 0;
    }
    

",C++
3003408,"
    import java.awt.Point;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.InputStreamReader;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.StringTokenizer;
    import java.util.Vector;
    import java.util.TreeSet;
    
    import java.math.BigInteger;
    
    public class Main {
    	
    	public static boolean debug = false;
    	
    	public static void main(String[] args) {
    		Reader in = null;
    		Writer out = null;
    		
    		if(debug) {
    			in = new Reader(args[0]);
    			out = new Writer(args[1]);
    		} else {
    			in = new Reader();
    			out = new Writer();
    		}
    		
    		int t = in.readInt();
    		
    		long[][][] b = new long[100][100][100];
    		
    		while(t-->0) {
    			int x = in.nextInt();
    			int y = in.nextInt();
    			int z = in.nextInt();
    			
    			for(int i=0; i<x; i++)
    				for(int j=0; j<y; j++)
    					for(int k=0; k<z; k++) {
    						b[i][j][k] = in.nextLong();
    					}
    			
    			
    			for(int i=0; i<x; i++)
    				for(int j=0; j<y; j++) {
    					for(int k=0; k<z; k++) {
    						long res = b[i][j][k];
    						if(i>0 && j>0 && k>0) {
    							res -= b[i-1][j][k] + b[i][j-1][k] + b[i][j][k-1] - ( 2*b[i-1][j-1][k-1] + b[i-1][j-1][k] + b[i-1][j][k-1] ) - ( b[i][j-1][k-1] ); 
    						} else if(i>0 && j>0) {
    							res -= b[i-1][j][0] + b[i][j-1][0] - b[i-1][j-1][0];
    						} else if(i>0 && k>0) {
    							res -= b[i-1][0][k] + b[i][0][k-1] - b[i-1][0][k-1];
    						} else if(j>0 && k>0) {
    							res -= b[0][j-1][k] + b[0][j][k-1] - b[0][j-1][k-1];
    						} else if(i>0) {
    							res -= b[i-1][0][0];
    						} else if(j>0) {
    							res -= b[0][j-1][0];
    						} else if(k>0) {
    							res -= b[0][0][k-1];
    						}
    						out.printf(""%d "",res);
    					}
    					out.println();
    				}
    		}
    		
    		out.close();
    	}
    	
    }
    
    class Writer {
    	
    	private BufferedWriter output;
    	
    	public Writer() {
    		output = new BufferedWriter(new OutputStreamWriter(System.out));
    	}
    	
    	public Writer(String s) {
    		try {
    			output = new BufferedWriter(new FileWriter(s));
    		} catch(Exception ex) { ex.printStackTrace(); System.exit(0);}
    	}
    	
    	public void println() {
    		try {
    			output.append(""\n"");
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    
    	public void print(Object o) {
    		try {
    			output.append(o.toString());
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public void println(Object o) {
    		try {
    			output.append(o.toString()+""\n"");
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    
    	public void printf(String format, Object... args) {
    		try {
    			output.append(String.format(format, args));
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public void printfln(String format, Object... args) {
    		try {
    			output.append(String.format(format, args)+""\n"");
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public void flush() {
    		try {
    			output.flush();
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public void close() {
    		try {
    			output.close();
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    }
    
    class Reader {
    	private BufferedReader input;
    	private StringTokenizer line = new StringTokenizer("""");
    	
    	public Reader() {
    		input = new BufferedReader(new InputStreamReader(System.in));
    	}
    
    	public Reader(String s) {
    		try {
    			input = new BufferedReader(new FileReader(s));
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public void fill() {
    		try {
    			if(!line.hasMoreTokens()) line = new StringTokenizer(input.readLine());
    		} catch(IOException io) { io.printStackTrace(); System.exit(0);}
    	}
    	
    	public double nextDouble() {
    		fill();
    		return Double.parseDouble(line.nextToken());
    	}
    	
    	public String nextWord() {
    		fill();
    		return line.nextToken();
    	}
    	
    	public int nextInt() {
    		fill();
    		return Integer.parseInt(line.nextToken());
    	}
    
    	public long nextLong() {
    		fill();
    		return Long.parseLong(line.nextToken());
    	}
    	
    	public double readDouble() {
    		double d = 0;
    		try {
    			d = Double.parseDouble(input.readLine());
    		} catch(IOException io) {io.printStackTrace(); System.exit(0);}
    		return d;
    	}
    	
    	public int readInt() {
    		int i = 0;
    		try {
    			i = Integer.parseInt(input.readLine());
    		} catch(IOException io) {io.printStackTrace(); System.exit(0);}
    		return i;
    	}
    	
    	public int[] readInts(int n) {
    		int[] a = new int[n];
    		for(int i=0; i<n; i++)
    			a[i] = nextInt();
    		return a;
    	}
    	
    	public void fillInts(int[] a) {
    		for(int i=0; i<a.length; i++)
    			a[i] = nextInt();
    	}
    	
    	public long readLong() {
    		long l = 0;
    		try {
    			l = Long.parseLong(input.readLine());
    		} catch(IOException io) {io.printStackTrace(); System.exit(0);}
    		return l;
    	}
    	
    	public String readLine() {
    		String s = """";
    		try {
    			s = input.readLine();
    		} catch(IOException io) {io.printStackTrace(); System.exit(0);}
    		return s;
    	}
    }

",JAVA
3130381,"
    #include<iostream>
    #include<stdio.h>
    #include<algorithm>
    #include<cstring>
    #include<cmath>
    double EPS=1e-8;
    using namespace std;
    int C[41][41][41];
    int main()
    {
    	int T,n,x;
    	char s1[41*41*41],s2[41*41*41];
    	scanf(""%d"",&T);
    	while(T--)
    	{
    		scanf(""%d%d"",&n,&x);
    		scanf(""\n%[^\n]\n%[^\n]"",s1,s2);
    		if(x==0)printf(""%d %d\n"",n,1);
    		else
    		{
    			double p=(double)x/100;
    			for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)
    			{
    				int d=(i-1)*n*n+(j-1)*n;
    				for(int k=1;k<=n;k++)
    				C[i][j][k]=C[i][j-1][k]+C[i][j][k-1]-C[i][j-1][k-1]+C[i-1][j][k]-C[i-1][j-1][k]-C[i-1][j][k-1]+C[i-1][j-1][k-1]+(s1[d+k-1]==s2[d+k-1]);
    			}
    			
    			int size,cmn,p1,count=0;
    			for(size=n;size>=1 && count==0;size--)
    			{
    				x=size*size*size;
    				for(int i=1;i+size-1<=n;i++)
    				{
    					for(int j=1;j+size-1<=n;j++)
    					{
    						for(int k=1;k+size-1<=n;k++)
    						{
    							cmn=C[i+size-1][j+size-1][k+size-1]-C[i+size-1][j+size-1][k-1]-C[i+size-1][j-1][k+size-1]-C[i-1][j+size-1][k+size-1]+C[i-1][j-1][k+size-1]+C[i-1][j+size-1][k-1]+C[i+size-1][j-1][k-1]-C[i-1][j-1][k-1];
    							//cout<<sim<<endl;
    							if((double)cmn/x > p-EPS)count++;
    						}
    					}
    				}
    			}
    			if(count==0)
    			printf(""%d\n"",-1);
    			else
    			printf(""%d %d\n"",size+1,count);			
    		}
    	}
    	return 0;
    }

",C++
10731394,"
    #include<stdio.h>
    int min(int a,int b) {
    if (a<b)
     return a;
    else 
    return b;}
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{Int n;
    scanf(""%d"",&n);
    
    		char s[100001];
    		int r=0,g=0,b=0,i,ans=0;
    		scanf(""%s"",s);
    		i=0;
    		while(s[i]!='\0')
    		{
    			if(s[i]=='R')
    			r++,i++;
    		else	if(s[i]=='G')
    			g++,i++;
    		else	if(s[i]=='B')
    			b++,i++;}
    			ans=min(r,min(g,b));
    			printf(""%d"",ans);
    			}
    	}

",C++
9969999,"
    #include <stdio.h>
    int main(void) {
    int tc,n,cR=0,cG=0,cB=0,i;
    	scanf(""%d"",&tc);
    	while(tc--){
    		cR=0;
    		cG=0;
    		cB=0;
    	scanf(""%d"",&n);
        char colors[n];
        scanf(""%s"",&colors);
        for(i=0;i<n;i++)
    	{
    		if(colors[i]=='R')
    		cR++;
    		else if(colors[i]=='G')
    		cG++;
    		else
    		cB++;
    	}
    	if(cB>=cG && cB>=cR)
    	printf(""%d\n"",n-cB);
    	if(cG>=cB && cG>=cR)
    	printf(""%d\n"",n-cG);
    	if(cR>=cG && cR>=cB)
    	printf(""%d\n"",n-cR);
    	if(cG==cB && cG==cR)
    	printf(""%d\n"",n-cG);
    	}
    	return 0;
    }

",C
9964423,"
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace CodeChef
    {
       public class Program
        {
            static void Main(string[] args)
            {
                try
                {
                    int test = Convert.ToInt32(Console.ReadLine());
                    while (test-- != 0)
                    {
                        ChefAndColoring obj = new ChefAndColoring();
                        obj.Driver(obj);
                    
                        Console.WriteLine(obj.Function(obj));
    
    
                    }
                }
                catch (Exception ex)
                {
                    Console.Write(ex.Message);
                
                }
            }
    
          
        }
       
    
        public class ChefAndColoring
        {
        public void Driver(ChefAndColoring obj)
            {
                obj.Rooms = Convert.ToInt32(Console.ReadLine());
                obj.Paints=Console.ReadLine().ToArray<char>();
                
            }
            public long Function(ChefAndColoring obj)
            {
                Array.Sort(obj.Paints);
                long Broom = obj.Paints.LongCount(b => b == 'B');
                long Groom=   obj.Paints.LongCount(b=>b=='G');
                long Rroom = obj.Paints.LongCount(b => b == 'R');
                long color=  obj.Rooms-Math.Max(Math.Max(Broom,Groom),Rroom);
                return color;
    
    
            }
            public long Rooms { get; set; }
    
            public char[] Paints { get; set; }
        }
    
    }
    

",C#
9961807,"
    package codechef
    
    import java.io.{InputStreamReader, BufferedReader}
    import java.util.StringTokenizer
    
    /**
     * Created by dragons on 4/23/16.
     */
    object COLOR {
      def main(args: Array[String]) {
        val br = new BufferedReader(new InputStreamReader(System.in))
        val token = new StringTokenizer("""")
        val numTest = br.readLine().toInt
        (1 to numTest).foreach {
          p => {
            br.readLine()
            val input = br.readLine()
            val noPaint = input.toCharArray.groupBy(p => p).map(_._2.size).reduceLeft(math.max)
            println(input.length - noPaint)
          }
        }
      }
    }
    

",SCALA
9917186,"
    #include<stdio.h>
    #include<string.h>
    void main()
    {
    	char color[100];
    	int T,R,i,lcolor,r=0,b=0,g=0;
    	scanf(""%d"",&T);
    	while(T--)
    {
    	scanf(""%d"",&R);/*No of rooms is unnnecessary parameter..The no of colours in the string is equal to the no of colours*/
    	scanf(""%s"",color);
    	lcolor=strlen(color);
    	for(i=0;i<lcolor;i++)
    	{
    	switch(color[i])
    	{
    	case 'R':
    		r++;
    		break;
    	case 'G':
    		g++;
    		break;
    	case 'B':
    		b++;
    		break;
    	}
    	}
    	if(r==g&&b==r&&g==b)
    	{
    	printf(""0\n"");
    	}
    	if(r>=g&&r>=b)
    	{
    	printf(""%d\n"",lcolor-r); 
    	}
    	else 
    	{
    	 if(g>=r&&g>=b)
    	 {
    	 printf(""%d"",lcolor-g);
    	 }
    	 else
    	 {
    	 printf(""%d\n"",lcolor-b);
    	 }
    	}
    	r=0;
    	g=0;
    	b=0;
    }
    }
    

",C
12016930,"
    #include<stdio.h>
    #include<math.h>
    int r,R;
    float max(float a, float b)
    {
    	if(b>a)return b;
    	else return a;
    }
    float findmax(float b)
    {
    	return max(b-r,R-b);
    }
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		int i,n;
    		float min;
    		scanf(""%d%d%d"",&r,&R,&n);
    		int a[n][2];float b[n];
    		for(i=0;i<n;i++){scanf(""%d%d"",&a[i][0],&a[i][1]);b[i]=sqrt(a[i][0]*a[i][0]+a[i][1]*a[i][1]);}
    		min=findmax(b[0]);
    		for(i=1;i<n;i++)if(min>findmax(b[i]))min=findmax(b[i]);
    		printf(""%.3f\n"",min);
    		//for(i=0;i<n;i++){printf(""%d   %d    %f\n"",a[i][0],a[i][1],b[i]);}
    	}
    	return 0;
    }

",C
1569191,"
    #include<stdio.h>
    #include<math.h>
    int main()
    {
     float tem,d[4]={0},D[4];
     int co[4][2],i,j,c,r,R,k ,t;
     printf(""test\n"");
     scanf(""%d"",&t);
     while(t--)
     {
      printf(""R r cones\n"");
      scanf(""%d%d%d"",&R,&r,&c);
      for(i=0;i<c;i++)
      {
       for(j=0;j<2;j++)
       {
        printf(""coordinate %d"",i+1);
        scanf(""%d"",&co[i][j]);
       }
       d[k]=sqrt((co[i][0]*co[i][0])+(co[i][1]*co[i][1]));
       if((R-d[k])>(d[k]-r))
       {
        D[k]=(R-d[k]);
       }
       else
       {
        D[k]=(d[k]-r);
       }
       k++;
      }
      for(i=0;i<c;i++)
      {
       for(j=0;j<c;j++)
       {
        if(D[i]>D[j])
        {
         tem=D[i];
         D[i]=D[j];
         D[j]=tem;
        }
       }
      }
      printf(""%f\n"",D[c-1]);
     }
     return 0;
    }
    

",C
311105,"
    #include <cstdio>
    #include <math.h>
    using namespace std;
    int main()
    {
        int t,r,rr,n,a,b;
        float d,l1,l2,ln,le=25000;
        scanf(""%d"",&t);
        for(int i=0;i<t;i++)
        {
            scanf(""%d%d%d"",&r,&rr,&n);
            for(int j=0;j<n;j++)
            {
                scanf(""%d%d"",&a,&b);
                d=sqrt(a*a+b*b);
                l1=d-r;
                l2=rr-d;
                if (l1>l2)
                    ln=l1;
                else
                    ln=l2;
                if(le>ln)
                    le=ln;
            }
            printf(""%5.3f\n"",le);
        }
    }
    

",C++
8244496,"
    #include<bits/stdc++.h>
    #define N 400010
    #define M 1000010
    #define mod 1000000007
    #define ll long long
    using namespace std;
    struct st{int x,y;}a[N];
    int j,ux,vx,T;
    int dad[N],n,m,q,semi[N],fa[N],gs[N],i,tmp,l,head[N],ne[N],v[N];
    bool cmp(st a,st b){return a.y==b.y?a.x>b.x:a.y<b.y;}
    void add(int x,int y){v[++l]=y;ne[l]=head[x];head[x]=l;}
    int find(int x)
    {
    	if(dad[x]==x)return dad[x];
    	int u=find(dad[x]);
    	semi[x]=min(semi[x],semi[dad[x]]);
    	return dad[x]=u;
    }
    int main()
    {
    	scanf(""%d"",&T);
    	while(T--)
    	{
    		scanf(""%d%d%d"",&n,&m,&q);l=0;
    		for(i=1;i<=n;i++)fa[i]=dad[i]=gs[i]=head[i]=semi[i]=0;
    		for(i=1;i<=m;i++)
    		{
    			scanf(""%d%d"",&a[i].x,&a[i].y);
    			if(a[i].x==a[i].y&&a[i].x==1)gs[1]++;
    			add(a[i].y,a[i].x);add(a[i].x,a[i].y);
    		}
    		sort(a+1,a+m+1,cmp);tmp=2;
    		for(i=1;i<=m&&tmp<=n;i++)
    			if(a[i].y==tmp&&a[i].x<tmp)
    				fa[tmp]=a[i].x,tmp++;
    		for(i=n;i>1;i--)
    		{
    			semi[i]=fa[i];
    			for(j=head[i];j;j=ne[j])if(j&1)
    			{
    				if(v[j]<i)semi[i]=min(semi[i],v[j]);
    				else find(v[j]),semi[i]=min(semi[i],semi[v[j]]);
    			}
    			dad[i]=i;
    			for(j=head[i];j;j=ne[j])
    			if(!(j&1)&&fa[v[j]]==i)
    			{
    				semi[v[j]]=min(semi[v[j]],semi[i]);
    				dad[v[j]]=i;
    			}
    			gs[semi[i]]++;
    		}
    		while(q--)scanf(""%d"",&ux),printf(""%d "",gs[ux]);puts("""");
    	}
    }

",C++
11817666,"
    #include<bits/stdc++.h>
    using namespace std;
    
    int main()
    {
      int t, n, f, a[100], b[100];
      
      cin>>t;
      
      while(t--)
      {
          int c=0;
          cin>>n>>f;
          for(int i=0; i<n; i++)
          {
              cin>>a[i];
          }
          
          for(int i=0; i<f; i++)
          {
              cin>>b[i];
          }
         
          for(int i=0; i<n; i++)
          {
              if(a[i]==b[c])
              {
                  c++;
              }
              
              else
              {
                  c=0;
              }
              if(c==f)
              {
                  printf(""Yes\n"");
                  break;
              }
          }
          
          if(c<f)
          {
              printf(""No\n"");
          }
      }
        
       return 0; 
    }
        
        

",C++
10141257,"
    for t in range(int(raw_input())):
        n=raw_input()
        seq=raw_input()
        f=raw_input()
        seqf=raw_input()
        c=0
        for i in seqf:
            if i in seq:
                c+=1
        if c==len(seqf):
            print 'Yes'
        else:
            print 'No'

",PYTH
9908660,"
    #include <bits/stdc++.h>
    using namespace std;
    
    int main()
    {
        int t,i,n,j,k;
        char a[10005],b[10005];
        cin >> t;
        while(t--)
        {
        cin >> n;
        j=0;
        for(i=0;i<n;++i)
        {
            cin >> a[j++];
        }
        a[j]='\0';
        cin >> k;
        j=0;
        for(i=0;i<k;++i)
        {
            cin >> b[j++];
        }
        b[j]='\0';
        
        if(strstr(a,b))
        cout << ""Yes\n"";
        else
        cout << ""No\n"";
        }
        return 0;
    }
    

",C++
8847566,"
    #include<bits/stdc++.h>
    
    using namespace std;
    int SIZE = 100000;
    int main()
    {
        int N,F,T,i,j,flag;
        cin>>T;
        int seq[SIZE],subseq[SIZE];
        while(T--)
        {
            cin>>N;
            for(i=0;i<N;i++)
                cin>>seq[i];
            cin>>F;
            for(i=0;i<F;i++)
                cin>>subseq[i];
            j = flag = 0;
            for(i=0;i<N;i++)
            {
                if(j == F-1)
                {
                    flag = 1;
                    break;
                }
                else if(seq[i] == subseq[j])
                {
                    j++;
                }
                else if(seq[i] != subseq[j])
                {
                    j = 0;
                }
            }
            if(flag)
                cout<<""Yes""<<endl;
            else
                cout<<""No""<<endl;
        }
        return 0;
    }
    

",C++
8279867,"
    #include<stdio.h>
    
    int main()
    {int t,l1,l2,i,j,flag,n[20],f[20];
     scanf(""%d"",&t);
     while(t--)
     { 
       
       if(l2>l1)
       printf(""no "");
       
       if(l2==l1)
       {flag=0;
        for(i=0;i<l1;++i)
         { if(n[i]!=f[i])
           {flag=1;
           break;}
           }  
        if(flag==1)
        printf(""no "");
        if(flag==0)
        printf(""yes "");
       }
       
       if(l1>l2)
       {flag=0;
        for(i=0;i<l1;++i)
        { if(n[i]==f[0])
          { for(j=0;j<l2;j++)
            { if(n[i+j]==f[j])
              flag=1;
              else
              { flag=0;
                break;
                }
            }   
           
           if(flag==1)
           break;
           }
           
         }
         if(flag==1)
        printf(""yes "");
        if(flag==0)
        printf(""no "");
       }
    }
    return 0;
    }
    

",C
8205571,"
    #include<stdio.h>
    
    int main()
    {
    	int i,j=0,k,t,a[10],b[10],c,d,f;
    	
    	scanf(""%d"",&t);
    	
    	while(t--)
    	{
    		scanf(""%d"",&c);
    		for(i=0;i<c;i++)
    			scanf(""%d"",&a[i]);
    		scanf(""%d"",&d);
    		for(i=0;i<d;i++)
    			scanf(""%d"",&b[i]);
    			
    		for(i=0;i<c;i++)
    		{
    			if(a[i] == b[j])
    			{
    				k=i;
    				while(k<c && j<d)
    				{
    					k++;
    					j++;
    					if(a[k]==b[j])
    					{f=0;}
    					else
    					{f=1;
    					 break;}
    				}
    			}
    			
    				if(f==0)
    				{return(""Yes"");
    				break;}
    		}
    		
    			if(f==1)
    			return(""No"");	
    //return(0);				
    }		
    				
    				
    		

",C
8694820,"
    #include<iostream>
    #include<cstdlib>
    using namespace std;
     
    /*int getk( int n,  int *p){
    	if(n==1)return 1;
    	if(n==2)return 3;
    	if(p[n-1] != -1)return p[n-1];
    	p[n-1] = (2*(( getk(n-1,p)+getk(n-2,p))%1000000007))%1000000007;
    	return p[n-1];
    }*/
    int main (){
    	int T;
    	cin>>T;
    	int a = 1;
    	int b = 3;
    	int np =2;
    	for(int i=0; i<T; i++){
    		int n;
    		cin>>n;
    		if(n==1){
    			cout<<1<<endl;
    		}else if(n==2){
    			cout<<3<<endl;
    		}else{
    			if(n<np){
    				np = 2;
    			}
    			int temp;
    			for( int j=np+1; j<n+1; j++){
    				temp = (2*((a+b)%1000000007))%1000000007;
    				a = b;
    				b = temp;
    			}
    			np = n;
    			cout<<b<<endl;
    		}
    	}
    	return 0;
    }
     

",C++
5940780,"
    /*
    ***************************************************************************************************************
    
    							Author : Yash Sadhwani
    
    **************************************************************************************************************
    */
    #include<stdio.h>
    #include<iostream>
    #include<vector>
    #include<string.h>
    #include<algorithm>
    #include<deque>
    #include<map>
    #include<set>
    #include<stdlib.h>
    #include<math.h>
    #include<queue>
    #include<functional>
    using namespace std;
    #define ll long long
    #define si(x) scanf(""%d"",&x)
    #define sl(x) scanf(""%lld"",&x)
    #define sc(x) scanf(""%c"",&x)
    #define vl vector<ll>
    #define vi vector<int>
    #define vvl vector< vl >
    #define vvi vector< vi >
    #define pb push_back
    #define mod 1000000007
    #define mem(x,y) memset(x,y,sizeof(x))
    #define f(i,a,b) for(int i=(a);i<(b);i++)
    #define max_int_value 2147483647
    #define max_long_value 9223372036854775807
    
    //thanks to Vinay Guthal(win_ay) for the below fast IO functions
    #define llu long long unsigned
    #define ld long
    #define F first
    #define S second
    int scan_d()    {int ip=getchar_unlocked(),ret=0,flag=1;for(;ip<'0'||ip>'9';ip=getchar_unlocked())if(ip=='-'){flag=-1;ip=getchar_unlocked();break;}for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return flag*ret;}
    ld scan_ld()    {int ip=getchar_unlocked(),flag=1;ld ret=0;for(;ip<'0'||ip>'9';ip=getchar_unlocked())if(ip=='-'){flag=-1;ip=getchar_unlocked();break;}for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return flag*ret;}
    ll scan_ll()    {int ip=getchar_unlocked(),flag=1;ll ret=0;for(;ip<'0'||ip>'9';ip=getchar_unlocked())if(ip=='-'){flag=-1;ip=getchar_unlocked();break;}for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return flag*ret;}
    llu scan_llu()    {int ip=getchar_unlocked();llu ret=0;for(;ip<'0'||ip>'9';ip=getchar_unlocked());for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return ret;}
     
    //end of fast input
    //fast output
     
    //no line break
    void print_d(int n)     {if(n<0){n=-n;putchar_unlocked('-');}int i=10;char output_buffer[10];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar_unlocked(output_buffer[i]);}while(++i<10);}
    void print_ld(ld n)     {if(n<0){n=-n;putchar_unlocked('-');}int i=11;char output_buffer[11];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar_unlocked(output_buffer[i]);}while(++i<11);}
    void print_ll(ll n)     {if(n<0){n=-n;putchar_unlocked('-');}int i=21;char output_buffer[21];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar_unlocked(output_buffer[i]);}while(++i<21);}
    void print_llu(llu n)     {int i=21;char output_buffer[21];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar_unlocked(output_buffer[i]);}while(++i<21);}
    
    
    
    //qsort(ww,cc,sizeof(tp),compare);
    /*int compare(const void *a,const void *b){
    	ll y=((((tp*)a)->w)-(((tp*)b)->w));
    	if(y>0)return 1;
    	else if(y==0)return 0;
    	else return -1;
    }
    bool way(ii x,ii y){
    	return x.first<y.first or x.first==y.first and x.second<y.second;
    }
    */
    
    
    #define MAXN 1010
    #define ls (node<<1)
    #define rs ((node<<1)+1)
    #define ii pair<int,int>
    
    struct matrix{
    	ll mat[2][2];
    };
    
    matrix mul(matrix A,matrix B){
    	matrix ret;
    	ret.mat[0][0]=(((A.mat[0][0]*B.mat[0][0]))+((A.mat[0][1]*B.mat[1][0])))%mod;
    	ret.mat[0][1]=(((A.mat[0][0]*B.mat[0][1]))+((A.mat[0][1]*B.mat[1][1])))%mod;
    	ret.mat[1][0]=(((A.mat[1][0]*B.mat[0][0]))+((A.mat[1][1]*B.mat[1][0])))%mod;
    	ret.mat[1][1]=(((A.mat[1][0]*B.mat[0][1]))+((A.mat[1][1]*B.mat[1][1])))%mod;
    	return ret;
    }
    
    matrix pow(matrix A,int p){
    	if(p==1)return A;
    	if(p&1){
            matrix temp=pow(A,p/2);
    		return mul(A,mul(temp,temp));
    	}else{
            matrix temp=pow(A,p/2);
    		return mul(temp,temp);
    	}
    }
    
    int N;
    matrix F1;
    matrix F2;
    
    inline void ReadInput(void){
    	N=scan_d();
    }
    
    inline void solve(void){
    	if(N==1){
    		//print_ll(F2.mat[0][0]);
    		//printf(""\n"");
    		cout<<F2.mat[0][0]<<endl;
    		return;
    	}
    	matrix ret=pow(F1,N-1);
        //cout<<ret.mat[0][0]<<endl;
    	ret=mul(ret,F2);
    	//print_ll(ret.mat[0][0]);
    	//printf(""\n"");	
    	cout<<ret.mat[0][0]<<endl;
    }
    
    inline void Refresh(void){
    
    }
    
    int main()
    {
        ios_base::sync_with_stdio(false);
        F1.mat[0][0]=0; F1.mat[0][1]=1; F1.mat[1][0]=F1.mat[1][1]=2;
        F2.mat[0][0]=1;
        F2.mat[1][0]=3;
        int t=scan_d();
        while(t--){
        	N=scan_d();
            //ReadInput();
        	solve();
        }
    	return 0;
    }

",C++
1182555,"
    #include <string.h>
    #include <iostream>
    #include <sstream>
    #include <algorithm>
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <vector>
    #include <map>
    #include <list>
    #include <time.h>
    
    #define rep(i,a,b) for(int i = a; i < b; i++)
    #define REP(i,n) rep(i,1,n+1)
    using namespace std;
    
    typedef unsigned long long ull;
    typedef vector<vector<ull> > matrix;
    
    const ull mod = 1000000007;
    map<int, vector<ull> > done;
    
    // A * B
    vector<ull> mul(vector<ull> A, vector<ull> B){
    	vector<ull> C;
    	C.push_back((A[0] * B[0] + A[1] * B[2]) % mod);
    	C.push_back((A[0] * B[1] + A[1] * B[3]) % mod);
    	C.push_back((A[2] * B[0] + A[3] * B[2]) % mod);
    	C.push_back((A[2] * B[1] + A[3] * B[3]) % mod);
    	return C;
    }
    
    // A ^ p
    vector<ull> pow(vector<ull> A, int p){
    	if(p==1)
    		return A;
    	vector<ull> rtn; 
    	rtn.push_back(1);
    	rtn.push_back(0);
    	rtn.push_back(0);
    	rtn.push_back(1);
    	int i = 1;
    	while(p!=0){
    		if(p & 1) {
    			rtn = mul(rtn, done[i]);
    		}
    		i++;
    		p >>= 1;
    	}
    	return rtn;
    }
    
    void populatePowerOf2(vector<ull> m, int n){
    	int i = 2;
    	done[1] = m;
    	while(pow(2.0,i-1) < n){
    		done[i] = mul(done[i-1], done[i-1]);
    		i++;
    	}
    }
    
    int main()
    {
    	//freopen(""in.txt"", ""r"", stdin);
       // freopen(""out.txt"", ""w"", stdout);
    
    	int T; scanf(""%d"",&T);
    
    	//int t;
    	//t = clock();
    
    	vector<ull> M;
    	M.push_back(2);
    	M.push_back(2);
    	M.push_back(1);
    	M.push_back(0);
    
    	populatePowerOf2(M, 1000000000);
    
    	//vector<ull> P;
    
    	int N;
    
    	for(int i = 0; i < T; i++){
    		scanf(""%d"", &N);
    		if(N==1) {
    			printf(""1\n"");
    		}
    		else if(N==2) {
    			printf(""3\n"");
    		}
    		else{
    			vector<ull> P = pow(M, N-2);
    			ull res = (3 * P[0] + 1 * P[1])% mod;
    			printf(""%d\n"", res);
    		}
    	}
    
    	//cout << ""Diff: "" << ((float)t/CLOCKS_PER_SEC);
    
    	return 0;
    }
    

",C++
10936997,"
    t = int(input())
    for i in range(t):
        houses  = [0 for i in range(100)]
        count = 0
        m,x,y = map(int,input().split())
        cops = list(map(int,input().split()))
        for j in cops:
            minrange = j-(x*y)-1
            maxrange = j+(x*y)-1
            for k in range( max(0,minrange) , min(maxrange+1,100) ):
                houses[k] = 1
        count = 0
        for k in houses:
            if(k == 0):
                count += 1
        print(count)

",PYTH
10056257,"
    #include<stdio.h>
    
    main()
    {
    int testcase,M,x,y,i=0,j=0,a=0,houseno,h,s=0,q=0,p=0,N=100,r=0,flag=0,flag1=0;
    
    scanf(""%d"",&testcase);
    for(i=0;i<testcase;i++)
    {
    scanf(""%d%d%d"",&M,&x,&y);
    h=x*y;
    while(j<M)
    {
    scanf(""%d"",&houseno);
    if(h>=houseno)
    {
    p=h+houseno; //house no 1->p occupied by cops
    
    if(j==0)
    else if(p>=100)
    {
    p=100;}
    flag1=1;
    a=a+p;
    if(p>=100)
    break;
    }
    else
    {
    s=houseno-h;   //house no  houseno -h -> houseno occupied by cops
    q=h+houseno;    //house no houseno->q occupied by cops means house no s->q occupied by cops
    if(houseno>=a && flag1==1)
    {
    r=r+q-houseno+1 ;
    }
    else
    {
    r=r+q-s+1;
    }
    }
    j++;
    }
    j=0;
    if(N>=r && N>=a)
    {
    flag=N-r-a;
    printf(""\n%d\n"",flag);
    }
    else
    {
    
    printf(""\n0\n"");
    }
    r=0,a=0,flag=0,flag1=0,p=0,s=0,q=0;
    }
    
    }
    

",C
8536726,"
    #include<bits/stdc++.h>
    using namespace std;
    
    int main(){
        int t; cin >> t;
        while(t--){
            int m,x,y; cin >> m >> x >> y;
            int i,a[m];
            for(i=0;i<m;i++)
                cin >> a[i];
            sort(a,a+m); int min1,max1,d = x*y;
            int min11[m],max11[m];
            for(i=0;i<m;i++){
                min1 = a[i]-d; max1 = a[i]+d;
                min11[i] = min1; max11[i] = max1;
            }
            int sum=0;
            for(i=1;i<m;i++){
                if(min11[i]>max11[i-1])
                    sum+= min11[i]-max11[i-1]-1;
            }
            if(min11[0]>1)
                sum+=min11[0]-1;
            if(max11[m-1]<100)
                sum+=100-max11[m-1];
            cout << sum << endl;
        }
        return 0;
    }
    

",C++
42748,"
    #include <iostream>
    using namespace std;
    int main()
    {
    int n=500;
    for(int i=0;i<n;i++)
            {
                    for(int j=i+1;j<n;j++)
                    {
                          //  if()
                            for(int ii=j+1;ii<n;ii++)
                            {
                                    
                            }
                    }
            }
            return 0;
    }

",C++
9076962,"
    /*******************  https://www.codechef.com/problems/CVOTE  ********************/
    
    #include<iostream>
    #include<cstring>
    #include<cmath>
    #include<bits/stdc++.h>
    #include<vector>
    #include<map>
    #define MOD 1000000007
    using namespace std;
    int main()
    {
        std::ios_base::sync_with_stdio(false);
        int n,m;
        cin>>n>>m;
        string chef_name[n],country_name[n],vote,winning_country,winning_chef;
        map<string,string> chef_to_country;
        map<string,int> chef_count,country_count;
        std::map<string,string>::iterator it;
        for(int i=0;i<n;i++)
        {
            cin>>chef_name[i]>>country_name[i];
            chef_to_country[chef_name[i]]=country_name[i];
        }
        for(it=chef_to_country.begin();it!=chef_to_country.end();it++)
        {
            chef_count[it->first]=0;
            country_count[it->second]=0;
        }
        for(int i=0;i<m;i++)
        {
            cin>>vote;
            chef_count.find(chef_to_country.find(vote)->first)->second++;
            country_count.find(chef_to_country.find(vote)->second)->second++;
        }
        //sort(chef_name,chef_name+n);
        //sort(country_name,country_name+n);
        winning_chef=chef_name[0];
        winning_country=country_name[0];
        for(map<string,int>::iterator it=chef_count.begin();it!=chef_count.end();it++)
        {
            if((chef_count.find(winning_chef)->second)<it->second)
                winning_chef=it->first;
            if((chef_count.find(winning_chef)->second)==it->second)
            {
                if(winning_chef>it->first)
                    winning_chef=it->first;
            }
    
        }
        for(map<string,int>::iterator it=country_count.begin();it!=country_count.end();it++)
        {
            if((country_count.find(winning_country)->second)<it->second)
                winning_country=it->first;
            if((country_count.find(winning_country)->second)==it->second)
            {
                if(winning_country>it->first)
                    winning_country=it->first;
            }
        }
        cout<<winning_country<<""\n""<<winning_chef;
    }
    

",C++
6302372,"
    #include<iostream>
    #include<map>
    #include<string>
    using namespace std;
    int main()
    {
        int n,m;
        cin>>n>>m;
        int o=n;
        int p=m;
        string chef,country;
    
        map <string, string> chefcountry;
        while(o--)
        {
            cin>>chef>>country;
    
            chefcountry[chef]=country;
        }
    
        map <string, int> chefvote;
        map <string, int> countryvote;
    
        while(p--)
        {
            cin>>chef;
            chefvote[chef]=chefvote[chef]+1;
    
            country= chefcountry[chef];
    
            countryvote[country]=countryvote[country]+1;
        }
    
        map <string, int> :: iterator it;
    
        int maxvote=0;
    
        for(it=chefvote.begin();it!=chefvote.end();++it)
        {
            if (it->second>maxvote)
            {
                maxvote=it->second;
                chef=it->first;
            }
        }
    
        maxvote=0;
    
        for(it=countryvote.begin();it!=countryvote.end();++it)
        {
            if (it->second>maxvote)
            {
                maxvote=it->second;
                country=it->first;
            }
        }
    
        cout<<country<<'\n'<<chef;
        return 0;
    }
    

",C++
9275817,"
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    vector< vector<int> > moz(10);
    
    void gen()
    {
        moz[0].push_back(0);
        moz[0].push_back(8);
    
        moz[1].push_back(0);
        moz[1].push_back(1);
        moz[1].push_back(3);
        moz[1].push_back(4);
        moz[1].push_back(7);
        moz[1].push_back(8);
        moz[1].push_back(9);
    
        moz[2].push_back(2);
        moz[2].push_back(8);
    
        moz[3].push_back(3);
        moz[3].push_back(8);
        moz[3].push_back(9);
    
        moz[4].push_back(4);
        moz[4].push_back(8);
        moz[4].push_back(9);
    
        moz[5].push_back(5);
        moz[5].push_back(6);
        moz[5].push_back(8);
        moz[5].push_back(9);
    
        moz[6].push_back(6);
        moz[6].push_back(8);
    
        moz[7].push_back(0);
        moz[7].push_back(3);
        moz[7].push_back(7);
        moz[7].push_back(8);
        moz[7].push_back(9);
    
        moz[8].push_back(8);
    
        moz[9].push_back(8);
        moz[9].push_back(9);
    }
    
    int main()
    {
        ios_base::sync_with_stdio(0);
        gen();
        int t;
        cin >> t;
        for (int i = 0; i < t; ++i)
        {
            string s, m;
            cin >> s >> m;
            string odp;
            while (s.size() < m.size()) s = ""0"" + s;
            odp = s;
            for (int j = 0; s[j] == '0'; ++j) s[j] = 'x';
            string x = s;
            for (int j = 0; j < s.size(); ++j)
            {
                if (s[j] == 'x') x[j] = '9';
                else x[j] = moz[s[j] - '0'][moz[s[j] - '0'].size() - 1] + '0';
            }
            for (int j = 0; j < m.size(); ++j)
            {
                char maxi = '$';
                if (s[j] != 'x')
                {
                    for (int k = 0; k < moz[s[j] - '0'].size(); ++k)
                    {
                        if (moz[s[j] - '0'][k] < m[j] - '0') maxi = moz[s[j] - '0'][k] + '0';
                    }
                }
                else maxi = m[j] - 1;
                if (maxi != '$')
                {
                    x[j] = maxi;
                    odp = max(odp, x);
                }
                bool mozna = false;
                if (s[j] != 'x')
                {
                    for (int k = 0; k < moz[s[j] - '0'].size(); ++k)
                    {
                        if (moz[s[j] - '0'][k] == m[j] - '0') mozna = true;
                    }
                }
                else mozna = true;
                if (mozna) x[j] = m[j];
                else break;
                if (j == m.size() - 1) odp = m;
            }
            while (odp.size() != 0 && odp[0] == '0') odp.erase(0, 1);
            if (odp.size() != 0) cout << odp << endl;
            else cout << ""0"" << endl;
        }
        return 0;
    }
    

",C++
4605850,"
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.List;
    import java.util.StringTokenizer;
    
    public class Deface {
    	BufferedReader reader;
        StringTokenizer tokenizer;
        PrintWriter out;
        Boolean check = false;
    
    	public static void main(String[] args){
                  
    		new Deface().start();
    		
    	}
    	
        public int[][] build(){
        	int[][] transform = new int[10][];
        	transform[0] = new int[]{0, 8};
        	transform[1] = new int[]{0, 1, 3, 4, 7, 8, 9};
        	transform[2] = new int[]{2, 8};
        	transform[3] = new int[]{3, 8, 9};
        	transform[4] = new int[]{4, 8, 9};
        	transform[5] = new int[]{5, 6, 8, 9};
        	transform[6] = new int[]{6, 8};
        	transform[7] = new int[]{0, 3, 7, 8, 9};
        	transform[8] = new int[]{8};
        	transform[9] = new int[]{8, 9};    	
        	return transform;
        }
        
        public void task() throws IOException {
        	
        	check = false;
        	
        	int[][] transform = build();
        	
        	System.out.println( ""The system started"" );
        	
        	int SVal = nextInt();
        	if(SVal < 0 ){
        		SVal = 0;
        	}
        	if(SVal > 20130120){
        		SVal = 20130120;
        	}
        	String SS = Integer.toString(SVal); 
        	int[] S = new int[SS.length()];
        	for(int i = 0; i < SS.length(); i++)
        		S[i] = Character.getNumericValue( SS.charAt(i) );    	
        	
        	int MVal = nextInt();
        	if(MVal < 0 ){
        		MVal = 0;
        	}
        	if(MVal > 20130120){
        		MVal = 20130120;
        	}
        	String MM = Integer.toString(MVal);
        	int[] M = new int[MM.length()];
        	for(int i = 0; i < MM.length(); i++)
        		M[i] = Character.getNumericValue( MM.charAt(i) );
        	
        	String YY = MM;
        	int[] Y = M;
        	int j = 0;
        	int ans = 0;
        	
            ans = dataTransform(SS,MM,M,Y,S);
    	
        	
    		out.println( ans );
        }
    	
        public int[]  dataReduction(String SS,int[] M,int[] Y,int[] S){
        	
    		int total = 0;
    		for(int i = 0; i < Y.length; i++){
    			total = total * 10 + Y[i];
    		}
    		total = total - 1;
    		
    		String DD = String.valueOf(total);
    		int[] tempans = new int[DD.length()];
        	for(int i = 0; i < DD.length(); i++)
        		tempans[i] = Character.getNumericValue( DD.charAt(i) );
    		
    		return tempans;
        }
        
        
    
        
        public int dataTransform(String SS,String MM,int[] M,int[] Y,int[] S){
        	int[][] transform = build();
        	int data = 0;
        	int[] L = new int[Y.length];
    		while (!check) {
    			data = 0;
    			int j = Y.length - 1;
    			int l = Y.length - 1;
    			L = new int[Y.length];
    			Object[] arr1 = { Y }; // arr1 contains only one element
    			Object[] arr2 = { L }; // arr2 also contains only one element
    
    			for (int k = SS.length() - 1; k >= 0; k--, j--) {
    				int[] transformData = transform[S[k]];
    				List<Integer> transformList = new ArrayList<Integer>();
    				for (int d : transformData) {
    					transformList.add(d);
    				}
    
    				if (transformList.contains(Y[j])) {
    					L[j] = Y[j];
    					check = true;
    				} else {
    					if (!(Arrays.deepEquals(arr1, arr2))) {
    						check = false;
    						Y = dataReduction(SS, M, Y, S);
    						break;
    					}
    				}
    			}
    			int finalVal = 0;
    			for (int i = 0; i < Y.length; i++) {
    				finalVal = finalVal * 10 + Y[i];
    			}
    			data = finalVal;
    
    		}
        	return data;
        	
        }
        
        
    	public void calc() throws IOException{
    		int T = nextInt();
    		for(int t = 1; t <= T; t++){			
    			task();
    		}	
    	}
    	
        int nextInt() throws IOException {
            return Integer.parseInt(token());
        }
    	
        String token() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine());
            }
            return tokenizer.nextToken();
        }
     
    	public void start(){
            try {
                reader = new BufferedReader(new InputStreamReader(System.in));
                tokenizer = null;
                out = new PrintWriter(System.out);
                solve();
                reader.close();
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
    	}
    }

",JAVA
1755858,"
    #include<iostream>
    #include<set>
    #include<stdlib.h>
    #include<math.h>
    #include<string.h>
    #include<stdio.h>
    struct nums
    { public:
       std::set<int> s;
    }n[10];
    using namespace std;
    int main()
    {  
       n[0].s.insert(8); n[0].s.insert(0);
       n[1].s.insert(8); n[1].s.insert(0); n[1].s.insert(1); n[1].s.insert(3); n[1].s.insert(4); n[1].s.insert(7);n[1].s.insert(9);
        n[2].s.insert(2); n[2].s.insert(8);
       n[3].s.insert(3); n[3].s.insert(8); n[3].s.insert(9);
       n[4].s.insert(4); n[4].s.insert(8); n[4].s.insert(9);
      n[5].s.insert(5); n[5].s.insert(6); n[5].s.insert(8); n[5].s.insert(9);
      n[6].s.insert(6); n[6].s.insert(8);
      n[7].s.insert(6); n[7].s.insert(3); n[7].s.insert(8); n[7].s.insert(9);  n[7].s.insert(0); n[7].s.insert(7);
       n[8].s.insert(8);
       n[9].s.insert(8); n[9].s.insert(9);
      int t; scanf(""%d"",&t);
         while(t--)
         {
              int S,M;  scanf(""%d%d"",&S,&M);  int result=0,check=0;
                          int Slen,Mlen; Slen=(S==0)?1:(floor(log10(abs(S))) + 1);  Mlen=(M==0)?1:(floor(log10(abs(M))) + 1);
                    result=M/(int)(pow(10.0,Slen));  M=M%(int)pow(10.0,Slen);  
                         while(Slen!=0)
                          {  
                             int r=S/(pow(10.0,Slen-1)),m=M/(pow(10.0,Slen-1)); 
                            if(check==0)
                             {
                              if(n[r].s.find(m)==n[r].s.end())
                                 {
                                        check=1; int temp=m-1;  int yes=0;
                                      while(temp>=0)
                                     {
                                         if(n[r].s.find(temp)!=n[r].s.end()){yes=1; break;}
                                          temp--;
                                     }
                                      if(yes==1) result=result*10+temp;
                                         else 
                                             {if(r<m||result==0)  result=result*10+r;
                                              else 
                                                  {std::set<int>::reverse_iterator rit=n[r].s.rbegin(); 
                                                      result=(result-1)*10+(*rit);
                                                  }
                                              }
                                 }
                               else
                                 {
                                     result=result*10+m;
                                 }
                             }
                           else if(check==1){std::set<int>::reverse_iterator rit=n[r].s.rbegin();  result=result*10+(*rit);}
                             Slen--;   S=S%(int)pow(10.0,Slen);   M=M%(int)pow(10.0,Slen); 
                          }
                  
        
         cout<<result<<""\n"";
         }
    }
    

",C++
9664080,"
    #include <bits/stdc++.h>
    
    
    #define fst first
    #define snd second
    #define all(x) (x).begin(), (x).end()
    #define rall(x) (x).rbegin(), (x).rend()
    #define clr(a, v) memset( a , v , sizeof(a) )
    #define pb push_back
    #define mp make_pair
    #define sz size()
    #define FORN( i , s , n ) for( int i = (s) ; i < (n) ; i++ )
    #define FOR( i , n ) FORN( i , 0 , n )
    #define FORIT(it,A)   for( typeof(A.begin())  it = A.begin(); it!=A.end(); it++  )
    #define trace(x)    cout << #x << "": "" << x << endl;
    #define trace2(x, y) cout << #x << "": "" << x << "" | "" << #y << "": "" << y << endl;
    #define trace3(x, y, z) cerr << #x << "": "" << x << "" | "" << #y << "": "" << y << "" | "" << #z << "": "" << z << endl;
    #define read ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    
    
    #define MAX 2000010
    #define NUM 2005
    
    using namespace std;
    
    typedef long long int64;
    typedef vector <int> vi;
    typedef pair <int,int> ii;
    typedef vector <string> vs;
    typedef vector <ii> vii;
    
    
    
    int n,m;
    
    int MM[MAX][22];
    int A[MAX];
    map<int,int> L;
    
    
    void preproL(){
    
        int64 ac = 0;
        int pos =0;
        
        L[0]=0;
        
        FORIT(it, L){
            ac += it->snd;
            ac = ac&1LL;
            it->snd = ac;
            
        }
    
        L[ 1000000005 ]=ac;
    
        //mapeo.pb( 1000000005 );
        //LL[pos] = ac;     
    }
    
    
    
    
    int opera(int i, int j){
    
        if(A[i]>=A[j] ) return i;
        return j;
    
    }
    
    
    
    void preproA(){
    
        FOR(i,n) MM[i][0]=i;
        
        FOR(j,20){    
        int ii = 1<<j;
        for(int i =0; ii < n ; i++, ii++ ){
            MM[i][j+1] = opera( MM[i][j] , MM[ii ][ j ]  );    
        }
        }
    }
    
    
    
    int posMAX(int ini, int fin){
    
        int dif = fin-ini+1;
    
        int cnt = log(dif)/log(2);
            
        return opera(  MM[ini][cnt] , MM[fin-(1<<cnt)+1][cnt]   );    
    
    }
    
    
    
    void sol(int i, int j){
        if(i>j) return ;
        int ind = posMAX(i,j);
        L[ A[ ind  ] ] +=  ((ind-i+1)%2)*((j-ind+1)%2);   
         
        sol(i,ind-1);
        sol(ind+1,j);
    
    }
    
    
    int64 change( char op, int x ){
    
        map<int, int> ::iterator it;
        
        if( op=='=' ){
            it = L.find(x);
            
            if( it != L.end() ){
                int64 ans = it->snd;
                it--;
                ans -= it->snd;
                
                return (ans+2)%2;
            }  
            else return 0;    
        }    
    
        if(op=='>'){
            it = L.lower_bound( x+1 );
            it--;
            return (n*1LL*(n+1))/2 - it->snd;
        
        }
        if(op=='<'){
            it = L.lower_bound( x );
            it--;
            return it->snd;    
        }
    
    }
    
    
    int main(){
        char op[10], emp[10];
        int x;
    
    
        cin>>n>>m;
        
        FOR(i,n) scanf(""%d"",&A[i]);
        L.clear();
        preproA();	
            
            
        sol(0,n-1);
    
    
        preproL();
            
        FOR(i,m){
            scanf(""%s %d %s"",op, &x, emp );
        
            
            
            if( ! (change( op[0], x )&1LL) ){
                printf(""%c"", emp[0]=='D'?'C':'D'  ); 
            }
            else{
                printf(""%c"",emp[0]);
            }
        
        }
        printf(""\n"");
    
    
        return 0;
    }
    
    									
    

",C++
7989674,"
    #include<bits/stdc++.h>
    using namespace std;
    #define ll long long int
    ll n,m;
    pair<ll,ll> p[1000005];
    char rev(char init)
    {
        if(init=='D')
            return 'C';
        else  return 'D';
    }
    ll find_k(ll k)
    {
        ll i=0,j=n+1;
        while(i<j-1)
        {
            int mid=(i+j)/2;
            if(p[mid].first<=k)
                i=mid;
            else
                j=mid;
        }
        return p[i].second;
    }
    int main()
    {
        std::ios::sync_with_stdio(false);
        scanf(""%lld %lld"",&n,&m);
        ll a[n+1],left[n+1],rgt[n+1];
        for(ll i=1; i<=n; i++)
            scanf(""%lld"",&a[i]);
        stack<ll> s,s1;
    
        for(ll i=1; i<=n; i++)
        {
            while(!s.empty() && a[s.top()]<=a[i])
            {
                s.pop();
            }
            if(s.empty())
                left[i]=0;
            else
                left[i]=s.top();
    
            s.push(i);
        }
    
        for(ll i=n; i>0; i--)
        {
            while(!s1.empty() && a[s1.top()]<a[i])
            {
                s1.pop();
            }
            if(s1.empty())
                rgt[i]=n+1;
            else
                rgt[i]=s1.top();
    
            s1.push(i);
        }//
        p[0].first=-1*INT_MAX;
        p[0].second=0;
        for(ll i=1; i<=n; i++)
        {
            p[i].first=a[i];
            p[i].second= (i-left[i])*(rgt[i]-i);
        }
        sort(p,p+n+1);
    
    
        for(ll i =1; i<=n; i++)
            p[i].second+=p[i-1].second;
        string res="""";
        while(m--)
        {
            char c,pl;
            ll num;
            cin>>c;
            cin>>num;
            cin>>pl;
            if(c=='>')
            {
                ll x,ans=0;
                x=find_k(num);
                ans=(n*(n+1))/2-x;
                if(ans%2==1)
                {
                    res+=pl;
                }
                else
                    res+=rev(pl);
            }
            else  if(c=='<')
            {
                ll x,ans=0;
                x=find_k(num-1);
                if(x%2==1)
                {
                    res+=pl;
                }
                else
                    res+=rev(pl);
            }
            else
            {
                ll x=find_k(num)-find_k(num-1);
                if(x%2==1)
                {
                    res+=pl;
                }
                else
                    res+=rev(pl);
            }
    
        }
        cout<<res<<endl;
    }
    

",C++
7875331,"
    #include <algorithm>
    #include <stdio.h>
    #include <vector>
    #define  fi        first
    #define  se        second
    #define  maxn      1000003
    #define  pb        push_back
    using    namespace std;
    typedef  long long LL;
    typedef  pair<int,LL> pi;
    
    int n,m;
    LL sum[maxn];
    int p2[maxn];
    int dp[maxn][20];
    vector<pi>v;
    
    bool check(int l , int r , int x)
    {
      int t=p2[r-l+1];
      if(max(dp[l][t],dp[r-(1<<t)+1][t])==x)
        return true;
      return false;
    }
    
    int main()
    {
      scanf(""%d%d"",&n,&m);
      for(int i=1 ; i<=n ; i++)
        scanf(""%d"",&dp[i][0]);
      for(int k=1 ; (1<<k)<=n ; k++)
        for(int i=1 ; i+(1<<k)-1<=n ; i++)
          dp[i][k]=max(dp[i][k-1],dp[i+(1<<(k-1))][k-1]);
      for(int i=0 ; (1<<i)<=n ; i++)
        p2[(1<<i)]=i;
      for(int i=3 ; i<=n ; i++)
        if(!p2[i])
          p2[i]=p2[i-1];
      for(int i=1 ; i<=n ; i++)
      {
        int l1=1,r1=i,p1=i;
        while(l1<=r1)
        {
          int mid=(l1+r1)>>1;
          if(check(mid,i,dp[i][0]))
            p1=mid,r1=mid-1;
          else
            l1=mid+1;
        }
        int l2=i,r2=n,p2=i;
        while(l2<=r2)
        {
          int mid=(l2+r2)>>1;
          if(check(i,mid,dp[i][0]))
            p2=mid,l2=mid+1;
          else
            r2=mid-1;
        }
        v.pb(pi(dp[i][0],(LL)(i-p1+1)*(LL)(p2-i+1)));
      }
      sort(v.begin(),v.end());
      for(int i=0 ; i<n ; i++)
        sum[i+1]=sum[i]+v[i].se;
      for(int i=0 ; i<m ; i++)
      {
        int numb,pl,pr;
        char com[3],per[3];
        scanf(""%s%d%s"",com,&numb,per);
        if(com[0]=='<')
        {
          pl=0;
          pr=lower_bound(v.begin(),v.end(),pi(numb,0))-v.begin();
        }
        else if(com[0]=='>')
        {
          pr=n;
          pl=lower_bound(v.begin(),v.end(),pi(numb+1,0))-v.begin();
        }
        else
        {
          pl=lower_bound(v.begin(),v.end(),pi(numb,0))-v.begin();
          pr=lower_bound(v.begin(),v.end(),pi(numb+1,0))-v.begin();
        }
        LL tot=sum[pr]-sum[pl];
        if(tot%2LL)
          printf(""%c"",per[0]);
        else if(per[0]=='C')
          printf(""D"");
        else
          printf(""C"");
      }
      return 0;
    }
    

",C++
7873230,"
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Scanner;
    
    class DevuChuruCodechef {
    
    	public static void main(String[] args) {
    
    		Scanner in = new Scanner(System.in);
    		String churu =""C"";
    		String Devu=""D"";
    		int size = in.nextInt();
    		int games = in.nextInt();
    		int[] array = new int[size];
    		Map<Integer, Integer> countMap = new HashMap<Integer, Integer>(); 
    		for(int i=0; i< size; i++){
    			array[i]= in.nextInt();
    			countMap.put(array[i], i+1);
    		}
    	//	System.out.print(""\n"");
    		for(int j=0; j<games; j++){
    			
    			String sign=in.next();
    			int value = in.nextInt();
    			String player = in.next();
    			if(sign.equalsIgnoreCase("">"")){
    				if(findWinnerForGT(value, countMap, array)){
    					System.out.print(player.equalsIgnoreCase(""C"")?""C"":""D"");
    				}
    				else{
    					System.out.print(player.equalsIgnoreCase(""D"")?""C"":""D"");
    				}
    			}else if(sign.equalsIgnoreCase(""<"")){
    				if(findWinnerForLT(value, countMap, array)){
    					System.out.print(player.equalsIgnoreCase(""C"")?""C"":""D"");
    				}
    				else{
    					System.out.print(player.equalsIgnoreCase(""D"")?""C"":""D"");
    				}
    		//	}else if(sign.equalsIgnoreCase(""="")){
    			}else{
    				if(findWinnerForEqual(value, countMap, array)){
    					System.out.print(player.equalsIgnoreCase(""C"")?""C"":""D"");
    				}
    				else{
    					System.out.print(player.equalsIgnoreCase(""D"")?""C"":""D"");
    				}
    			}	
    			
    			
    		}
    		
    		
    		
    	}
    	
    	static boolean findWinnerForGT(int value, Map<Integer, Integer> countMap, int[] array){
    		
    	//	int posOfValue= countMap.get(value) ;
    		if(value > array[array.length - 1]){
    			return false;
    		}
    		
    		int posOfValue=0; 
    		
    		if(countMap.get(value) !=null){
    			posOfValue = countMap.get(value);
    		}else{
    			for(int a= 0; a < array.length ; a++){
    				if(array[a] > value){
    					posOfValue = a;
    					break;
    				}
    			}
    			
    			
    		}	
    		
    		
    		int totalChancesAvailable = 0;
    		for (int z= (posOfValue+1); z<= array.length ;z++){
    			totalChancesAvailable= totalChancesAvailable + z;
    		}
    		if(!checkEven(totalChancesAvailable)){
    			return true;
    		}
    		return false;
    	}
    	
    	static boolean findWinnerForLT(int value, Map<Integer, Integer> countMap, int[] array){
    		
    		int posOfValue=0; 
    		
    		if(countMap.get(value) !=null){
    			posOfValue = countMap.get(value);
    		}else{
    			for(int a= array.length-1; a>=0; a--){
    				if(array[a] < value){
    					posOfValue = a+2;
    					break;
    				}
    			}
    			
    		}	
    		
    		
    		int totalChancesAvailable = 0;
    		for (int z= 1; z< posOfValue ;z++){
    			totalChancesAvailable= totalChancesAvailable + z;
    		}
    		if(!checkEven(totalChancesAvailable)){
    			return true;
    		}
    		return false;
    	}
    
    	static boolean findWinnerForEqual(int value, Map<Integer, Integer> countMap, int[] array){
    	
    	int posOfValue = 0;
    	if(countMap.get(value) != null){
    		posOfValue = countMap.get(value) ;
    	}else{
    		return false;
    	}
    	
    	
    	int totalChancesAvailable = posOfValue;
    	
    	if(!checkEven(totalChancesAvailable)){
    		return true;
    	}
    	return false;
    }
    	
    	
    	static boolean checkEven(int value){
    		
    		if ((value % 2)==0){
    			return true;
    		}
    		return false;
    		
    	}
    
    }
    

",JAVA
7849003,"
    nNk = input()
    n = int(nNk[0])
    k = int(nNk[2])
    
    listOfNumbers = []
    
    solved = 0
    
    for i in range(0, n):
    	if(int(input()) % k ==0):
    		solved = solved + 1
    		
    print(solved)
    

",PYTH
7712056,"
    import java.util.Scanner;
    
    
    public class Main {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		int testCases = 0;
    		Scanner sc = new Scanner(System.in);
    	    testCases = sc.nextInt();
    	    
    	    int count = 0;
    	    int L = 0;
    	    int R = 0;
    	    
    	    while(count < testCases){
    	    	L = sc.nextInt();
    	    	R = sc.nextInt();
    	    	
    	    	int possibilities = 0;
    	    	int innerCount = L;
    	    	
    	    	while(innerCount<=R){
    	    		if(deliciousTest(innerCount)){
    	    			possibilities++;
    	    		}
    	    		innerCount++;
    	    	}
    	    	
    	    	
    //	    	System.out.println(""count: "" + count);
    //	    	System.out.println(""L: "" + L);
    //	    	System.out.println(""R: "" + R);
    //	    	System.out.println(""Test Cases: "" +testCases);
    	    	System.out.println(possibilities);
    	    }
    	    
    	}
    	
    	public static boolean deliciousTest(int x){
    		int[] test = {0,0,0,0,0,0,0,0,0,0}; 
    		while(x>0){
    			test[x%10]++;
    			if(test[x%10]>1){
    				return false;
    			}
    			x /= 10;
    		}
    		
    		return true;
    	}
    
    }
    

",JAVA
4296895,"
    #include<stdio.h>
    #include<string.h>
    
    
    void main()
    {
    int TC,Lower_lim,Higher_lim;
    char dish[7];
    int digilen;
    int i,j,k,l;
    int no_found = 0, nd = 0,total_choice;
    memset(dish, NULL, 7);
    scanf(""%d"",&TC);
    for ( i = 0; i < TC; i++)
    	{
    	total_choice = 0;
    	scanf(""%d"",&Lower_lim);
    	scanf(""%d"",&Higher_lim);
    	for ( j = Lower_lim; j <= Higher_lim; j++)
    		{
             if (j == 121)
    			 no_found = 0;
    		sprintf(dish,""%d"",j);
    		digilen = strlen(dish);
    		for ( k = 0; k < digilen; k++)
    			{
    			for ( l = k; l < digilen; l++)
    				{
    				if (dish[k] == dish[l+1])
    					{
    					nd = 1;
    					break; 
    					}
    				}
    			if (nd)
    				{
    					nd = 0;
    					break;
    				}
    			else if((k+1) == digilen)
    			   		no_found = 1;
    			}
    		if(no_found)
    		{
    		no_found = 0;
    		++total_choice;
    		}
    		}
    	printf(""%d\n"",total_choice);
    
    	}
    
    return;
    }
    

",C
2183520,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
     long int mai,bot,pr,lim,len1,j,n,c[12],len2,i,test,k=1;
     long int t,it,ans1,ans,ans2,arr[19]={9,9,9,9,9,9,9,9,9,9,0,0,0,0,0,0,0,0,0};
     char l[23],r[23];
     scanf(""%ld"",&test);
     for(i=0;i<=12;i++)
     {
      n=9;
      for(j=1;j<=i;j++)
      {
       arr[i]=arr[i]*n;
       n--;
      }
     }
    
    /* for(i=0;i<=10;i++)
     {
      printf(""%ld "",arr[i]);
    }*/
     do
     {
      for(i=0;i<12;i++)
      c[i]=0;
      pr=0;
      ans1=0;
      ans2=0;
      ans=0;
      mai=0;
      scanf(""%s"",l);
      scanf(""%s"",r);
      len1=strlen(l);
      len2=strlen(r);
      for(i=0;i<len1-1;i++)
      {
       ans=ans+arr[i];
      }
      if(len1==1)
      {
       ans=ans+l[0]-48;
      }
      else
      {
      for(i=0;i<len1-1;i++)
      {
       t=1;
       for(n=0;n<12;n++)
       {
        c[n]=0;
       }
       mai=0;
       lim=l[i]-48;
       if(i==0)
       {
        t=t*(lim-1);
      //  printf(""%ld lim yrrr"",t);
    // if(lim>=0)      //loll//
     //{                  //
        it=9;
        for(j=1;j<len1;j++)
        {
         t=t*it;
         it--;
        }
        ans=ans+t;
        printf(""%ld gg"",ans);
        continue;
       }
       else
       {         //elsecondtition//
        for(n=0;n<i;n++)
        {
         if(c[l[n]-48]==0)
         {
         c[l[n]-48]++;
         continue;
         }
         else
        {
         mai=1;
         break;
         }
        }
      if(mai==0)
      {
       bot=lim;
        for(j=0;j<i;j++)
        {
         if(l[j]-48<bot)
         lim--;
    	}
        t=t*(lim);
        it=10-(i+1);
        for(j=i+1;j<len1;j++)
        {
          t=t*(it);
          it--;
         }
        // printf(""%ld"",t);
         ans=ans+t;
        }
        }
       }
       mai=0;
       for(i=0;i<11;i++)
       c[i]=0;
       for(i=0;i<len1-1;i++)
       {
        if(c[l[i]-48]==0)
        {
         c[l[i]-48]++;
         continue;
        }
        else
        {
         mai=1;
         break;
         }
        }
      if(mai==0)
      {
       lim=l[len1-1]-48+1;
       for(j=0;j<len1-1;j++)
       {
        if(l[len1-1]>=l[j])
        lim--;
       }
       ans=ans+lim;
       }
    // }//main condition//
       }
      for(i=0;i<len2-1;i++)
      {
       ans2=ans2+arr[i];
      }
      if(len2==1)
      {
       ans2=ans2+r[0]-48;
      }
      else
      {
      for(i=0;i<len2-1;i++)
      {
       t=1;
       if(r[i]=='0')
       continue;
       for(n=0;n<12;n++)
       {
        c[n]=0;
       }
       mai=0;
       lim=r[i]-48;
       if(i==0)
       {
        t=t*(lim-1);
        it=9;
        for(j=1;j<len2;j++)
        {
         t=t*it;
         it--;
        }
        ans2=ans2+t;
        continue;
       }
       else
       {
        for(n=0;n<i;n++)
        {
         if(c[r[n]-48]==0)
        { c[r[n]-48]++;
        continue;
        }
         else
         {
          mai=1;
          break;
         }
        }
       if(mai==0)
        {
    // printf(""UUU"");
        bot=lim;
        for(j=0;j<i;j++)
        {
         if(r[j]-48<bot)
         lim--;
        }
        t=1;
      //  printf(""ma %ld"",t);
        t=t*(lim);
        it=10-(i+1);
        for(j=i+1;j<len2;j++)
        {
          t=t*(it);
          it--;
         }
        // printf(""%ld yy"",t);
         ans2=ans2+t;
        }
       } //diff for unit digit and rest before unit digit
       }
       mai=0;
       for(i=0;i<11;i++)
       {
       c[i]=0;
       }
       for(i=0;i<len2-1;i++)
       {
        if(c[r[i]-48]==0)
        {
        c[r[i]-48]++;
        continue;
        }
        else
        {
         mai=1;
         break;
         }
       }
       if(mai==0)
       {
        lim=r[len2-1]-48+1;
       for(j=0;j<len2-1;j++)
       {
        if(r[len2-1]>=r[j])
        lim--;
       }
       ans2=ans2+lim;
       }
     }
    //   }//main condition//
    //printf(""%ld %ld\n"",ans,ans2);
       ans=ans2-ans;
       for(i=0;i<11;i++)
       c[i]=0;
       for(i=0;i<len1;i++)
       {
        lim=l[i]-48;
        if(c[lim]==0)
        {
        c[lim]=1;
        pr=0;
        continue;
        }
        else
        {
         pr=1;
         break;
         }
        }
        if(pr==0)
        ans=ans+1;
       printf(""%ld\n"",ans);
      k++;
    }
     while(k<=test);
     return 0;
    }

",C
9664879,"
    #include<iostream>
    using namespace std;
    int combi(int,int);
    int main()
    {
    	int x,n,i,j,k,a[54],sum,count;
    	cin>>x>>n;sum=0;
    	while(n--)
    	{
    		for(i=0;i<54;i++)
    		cin>>a[i];
    		for(i=0;i<9;i++)
    		{
    			j=(4*i);count=0;
    			for(k=1;k<=4;k++)
    			{
    				if(a[j]==0)
    				count++;
    			}
    			if(a[53-(2*i)]==0)
    			count++;
    			if(a[52-(2*i)]==0)
    			count++;
    			sum+=combi(count,x);
    		}
    	}
    	cout<<sum;
    }
    int combi(int n,int r)
    {
    	int i,pro1=1,pro2=1;
    	for(i=n;i>n-r;i--)
    	pro1*=i;
    	for(i=1;i<=r;i++)
    	pro2*=i;
    	return pro1/pro2;
    }
    

",C++
6557173,"
    #include <stdio.h>
    #include <math.h>
    
    int main()
    {
        int t,type,n,i,j,k;
        scanf (""%d"",&t);
        char str[100009];
        while (t--)
        {
            scanf (""%d"",&type);
            getchar();
            gets(str);
            int count1=0,count2=0,ans1=0,ans2=0;
            for (i=0; str[i]!='\0'; ++i)
                if (str[i]=='B')
                    count1++;
                else if (str[i]=='G')
                    count2++;
            if (fabs(count1-count2)>1)
                printf(""-1\n"");
            else
            {
                if (type==0)
                {
                    if (count1>count2)
                    {
                        for (i=0; str[i]!='\0'; ++i)
                        if (str[i]=='B' && i%2!=0)
                            ans1++;
                        else if (str[i]=='G' && i%2==0)
                            ans1++;
                        printf (""%d\n"",ans1/2);
                    }
                    else if (count1<count2)
                    {
                        for (i=0; str[i]!='\0'; ++i)
                        if (str[i]=='G' && i%2!=0)
                            ans2++;
                        else if (str[i]=='B' && i%2==0)
                            ans2++;
                        printf (""%d\n"",ans2/2);
                    }
                    else
                    {
                        for (i=0; str[i]!='\0'; ++i)
                        if (str[i]=='B' && i%2!=0)
                            ans1++;
                        else if (str[i]=='G' && i%2==0)
                            ans1++;
    
                        for (i=0; str[i]!='\0'; ++i)
                        if (str[i]=='G' && i%2!=0)
                            ans2++;
                        else if (str[i]=='B' && i%2==0)
                            ans2++;
    
                        if (ans1<ans2)
                            printf (""%d\n"",ans1/2);
                        else
                            printf (""%d\n"",ans2/2);
                    }
                }
                else
                    printf (""%d\n"",count1);
            }
        }
        return 0;
    }
    

",C
6556981,"
    #include<string.h>
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<iostream>
    
    using namespace std;
     long long int l=0,b,g,count;
    char s[100001];
    int main()
    {long long int t,i,type;
    
    cin>>t>>type;
    
    
    while(t--){
      gets(s);
      l=strlen(s);
      for(i=0;i<l;i++){
    
          if(s[i]=='b')
          b++;
    
      }
      g=l-b;
      if(b-g>1||b-g<-1||b==g)
      count=-1;
     else if(type==0){
    
      char ch='b';
    
      if(b>g)
        ch='g';
      for(i=0;i<l;i+=2)
    	 if(s[i]==ch)
    	     count++;
    }
    
    else
    { long long int aa=0,bb=1;
    char ch1='g',ch2='b';
    if(b>g)
    {ch1='b';ch2='g';
    
    }
    for(i=0;i<l;i+=2)
    {    if(s[aa]==ch1)
    	 aa+=2;
         if(s[bb]==ch2)
    	 bb+=2;
         if(aa<=l&&bb<=l)
         if(s[aa]==ch2&&s[bb]==ch1)
         { aa+=2;bb+=2;count+=abs(aa-bb);
         }
    
    }
    if(type==2)
    count*=count;
    }
    
    
    cout<<count<<""\n"";
    }
    
    
    return 0;
    }

",C++
6533437,"
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <string>
    #include <cmath>
    #include <algorithm>
    using namespace std;
    int ans;
    int type;
    void merge(int x,int y,int z,int a[],int d[]) {
    	int i = x;
    	int j = y+1;
    	int ctr = x;
    	while (i <= y && j <= z) {
    		if (a[i] <= a[j]) {
    			d[ctr++] = a[i++];
    		}
    		else   {
    			d[ctr++] = a[j++];
    			int temp = (y+1-i);
    			if (type == 0)
    				ans += 1;
    			else if (type == 1)
    				ans += temp;
    			else 
    				ans += temp*temp;
    		}
    	}
    	while (i <= y){
    		d[ctr++] = a[i++]; }
    		
    	while (j <= z) {
    		d[ctr++] = a[j++];
    		
    	}
    	int l = x;
    	while (l <= z) {
    		a[l] = d[l];
    		l++;
    	}
    }
    void mergesort(int i,int j,int a[],int d[]) {
    	if (i < j) {
    		int temp = (i+j)/2;
    		mergesort(i,temp,a,d);
    		mergesort(temp+1,j,a,d);
    		merge(i,temp,j,a,d);
    	}
    }
    int main() {
    	int t;
    	scanf(""%d"",&t);
    	while (t--) {
    		int cost = 0,cost1 = 0;
    		scanf(""%d"",&type);
    		string s;
    		cin >> s;
    		int ctr = 0,ctr1 = 0;
    		int j = 1,k = 2;
    		int n = s.size();
    		int a[n];
    		int d[n];
    		for (int i = 0; i < n; i++) {
    			if (s[i] == 'B') {
    				a[i] = j;
    				j = j+2;
    			}
    			else {
    				a[i] = k;
    				k = k+2;
    			}
    		}
    		mergesort(0,n-1,a,d);
    		cost = ans;
    		ans = 0;
    		int f1 = 1;
    		for (int i = 0; i < n; i++) {
    			if (a[i] != (i+1)) {
    				f1 = 0;
    			}
    		}
    		j = 1,k = 2;
    		for (int i = 0; i < n; i++) {
    			if (s[i] == 'B') {
    				a[i] = k;
    				k = k+2;
    			}
    			else {
    				a[i] = j;
    				j = j+2;
    			}
    		}
    		mergesort(0,n-1,a,d);
    		cost1 = ans;
    		ans = 0;
    		int f2 = 1;
    		for (int i = 0; i < n; i++) {
    			if (a[i] != (i+1))
    				f2 = 0;
    		}
    		if (f1 == 0 && f2 == 0)
    			printf(""-1\n"");
    		else if (f1 == 1 && f2 == 1)
    			printf(""%d\n"",min(cost,cost1));
    		else if (f1 == 1)
    			printf(""%d\n"",cost);
    		else
    			printf(""%d\n"",cost1);
    			
    	}
    	return 0;
    }

",C++
8660847,"
    #include <iostream>
    #include <cstdio>
    #include <vector>
    #include <algorithm>
    #include <ctype.h>
    #include <cmath>
    #include <map>
    #include <cstring>
    using namespace std;
     
    int main() {int t;
                scanf(""%d"",&t);
                long long a[10000],min_l[10000],max_l[10000],min_r[10000],max_r[10000];
                while(t--)
                {
                    int n;
                    scanf(""%d"",&n);
                    for(int i=0;i<10000;i++){min_r[i]=0;min_l[i]=0;max_r[i]=0;max_l[i]=0;}
                    for(int i=0;i<n;i++)
                      scanf(""%lld"",&a[i]);
                    long long sum1=a[0],sum2=a[0];
                    unsigned long long ans=0;  
                    max_l[0]=sum1;min_l[0]=sum2;
                    for(int i=1;i<n;i++)
                     {if (sum2> 0) sum2 = 0;
                         sum1+=a[i];
                        max_l[i]=max(sum1,max_l[i-1]);
                       
                         sum2+=a[i];
                       
                        min_l[i]=min(min_l[i-1],sum2); 
                      if (sum1 <0) sum1 = 0;    
                     }
                     sum1=a[n-1],sum2=a[n-1];  
                     max_r[n-1]=sum1;min_r[n-1]=sum2;
                    for(int i=n-2;i>=0;i--)
                     {if (sum2> 0) sum2 = 0;
                        sum1+=a[i];
                        max_r[i]=max(sum1,max_r[i+1]);
                       
                         sum2+=a[i];
                       
                        min_r[i]=min(min_r[i+1],sum2); 
                        if (sum1 <0) sum1 = 0;
                     }
                    for(int i=0;i<n-1;i++)
                     if(max((max_l[i]-min_r[i+1]),(max_r[i+1]-min_l[i]))>ans)
                      ans=max((max_l[i]-min_r[i+1]),(max_r[i+1]-min_l[i]));
                    /*for(int i=0;i<n;i++)cout<<min_l[i]<<' ';cout<<endl;
                    for(int i=0;i<n;i++)cout<<min_r[i]<<' ';cout<<endl;
                    for(int i=0;i<n;i++)cout<<max_l[i]<<' ';cout<<endl;
                    for(int i=0;i<n;i++)cout<<max_r[i]<<' ';cout<<endl;*/
                    printf(""%llu\n"",ans); 
                      
                
                }
    	// your code goes here
    	return 0;
    }  

",C++
7275870,"
    #include <bits/stdc++.h>
    using namespace std;
    
    typedef long long LL;
    
    const int MAXN = 1e4 + 9;
    const LL INF = 20000000000;
    
    #define _ ios_base :: sync_with_stdio(false); cin.tie(0);
    
    int tc,N;
    LL dish[MAXN];
    LL dp[4][MAXN];
    
    int main(){_
    	
    	cin >> tc;
    
    	while(tc--){
    		cin >> N;
    		
    		for(int i = 0;i <= N + 2;++i){
    		  dish[i] = 0;
    		  dp[0][i] = dp[1][i] = dp[2][i] = dp[3][i] = 0;
    		}
    		
    		for(int i = 1;i <= N;++i)
    			cin >> dish[i];
    
    		dp[0][1] = dp[1][1] = dish[1];
    		dp[2][N] = dp[3][N] = dish[N];
    
    		for(int i = 2;i <= N;++i){
    			dp[0][i] = min(dp[0][i - 1] + dish[i],dish[i]);
    			dp[1][i] = max(dp[1][i - 1] + dish[i],dish[i]);
    		}
    
    		for(int i = N - 1;i >= 1;--i){
    			dp[2][i] = min(dp[2][i + 1] + dish[i],dish[i]);
    			dp[3][i] = max(dp[3][i + 1] + dish[i],dish[i]);
    		}
    
    		LL ans = -INF;
    		for(int i = 2;i <= N;++i){
    			ans = max(ans,abs(dp[3][i] - dp[0][i - 1]));
    			ans = max(ans,abs(dp[1][i - 1] - dp[2][i]));
    		}
    
    		cout << ans << endl;
    	}
    
    	return 0;
    }
    

",C++
2598706,"
    #include<stdio.h>
    #include<stdlib.h>
    
    int cmpfunc(const void *a,const void *b)
    {
    	return(*(int *)a - *(int *)b);
    }
    
    int main()
    {
    	int T,n,i,j,res;
    	scanf(""%d"",&T);
    	while(T--)
    	{
    		scanf(""%d"",&n);
    		int D[n];
    		res = 0;
    		for(i = 0;i < n;i++)
    		{
    			scanf(""%d"",&D[i]);
    			res += D[i];
    		}
    		qsort(D,n,sizeof(int),cmpfunc);
    		
    		if(D[0] > 0)
    		{
    			res = res - 2*D[0];
    		}
    		else
    		{
    			
    			j = 0;
    			while(D[j]<=0)
    			{
    				j++;
    			}
    			for(i = 0;i < j;i++)
    			{
    				/*if(i>=j)
    				{
    					res = res+D[i];
    				}
    				else
    				{
    					res = res-D[i];
    				}*/
    				res = res - 2*D[i];
    			}
    		}
    		if(res >=0)
    		{
    			printf(""%d\n"",res);
    		}
    		else
    		{
    			printf(""%d\n"",(-res));
    		}
    				
    	}
    }

",C
2277570,"
    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
    
    /**
     *
     * @author Rohan
     */
    import java.io.*;
    import java.lang.*;
    import java.util.*;
    
    public class Main {
    
        /**
         * @param args the command line arguments
         */
        static long[] max=new long[10005];
        static long[] min=new long[10005];
        static long[] min1=new long[10005];
        static long[] max1=new long[10005];
        static long[] arr=new long[10005];
        static int n;
        static long res,tres;
        public static void main(String[] args) throws IOException {
            // TODO code application logic here
            input();
        }
        public static void input() throws IOException{
            InputReader r=new InputReader(System.in);
            OutputWriter w=new OutputWriter(System.out);
            IOUtils a=new IOUtils();
            int t=r.readInt();
            for(int i=0;i<t;i++){
                n=r.readInt();
                a.readLongArray(r,n,arr);
                res=0;
                solve();
                w.printLine(solve());
            }
            w.close();
        }
        
        public static long solve(){
            max_seq(); min_seq();
            min1[0]=arr[0]; res=Math.abs(min1[0]-max[1]);
            res=Math.max(res,Math.abs(min1[0]-min[1]));
            max1[0]=arr[0];
            for(int i=1;i<n-1;i++){
                min1[i]=Math.min(arr[i],min1[i-1]+arr[i]);
                max1[i]=Math.max(arr[i],max1[i-1]+arr[i]);
                res=Math.max(res,Math.abs(min1[i]-max[i+1]));
                res=Math.max(res,Math.abs(max1[i]-min[i+1]));
            }
            return res;
        }
        
        public static void max_seq(){
           long csum=0,tsum=Long.MIN_VALUE+1;
            for(int i=n-1;i>=0;i--){
                csum=csum+arr[i];
                if(csum>tsum){
                    max[i]=csum;
                    tsum=csum;
                }
                else max[i]=tsum;
                if(csum<0) csum=0;
            }
        }
        
        public static void min_seq(){
            long csum=0,tsum=Long.MAX_VALUE;
            for(int i=n-1;i>=0;i--){
                csum=csum+arr[i];
                if(csum<tsum){
                    min[i]=csum;
                    tsum=csum;
                }
                else min[i]=tsum;
                if(csum>0) csum=0;
            }
        }
    }
    
    class InputReader {
    
    		private InputStream stream;
    		private byte[] buf = new byte[1024];
    		private int curChar;
    		private int numChars;
    		private SpaceCharFilter filter;
    
    		public InputReader(InputStream stream) {
    			this.stream = stream;
    		}
    
    		public int read() {
    			if (numChars == -1)
    				throw new InputMismatchException();
    			if (curChar >= numChars) {
    				curChar = 0;
    				try {
    					numChars = stream.read(buf);
    				} catch (IOException e) {
    					throw new InputMismatchException();
    				}
    				if (numChars <= 0)
    					return -1;
    			}
    			return buf[curChar++];
    		}
    
    		public int readInt() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			int sgn = 1;
    			if (c == '-') {
    				sgn = -1;
    				c = read();
    			}
    			int res = 0;
    			do {
    				if (c < '0' || c > '9')
    					throw new InputMismatchException();
    				res *= 10;
    				res += c - '0';
    				c = read();
    			} while (!isSpaceChar(c));
    			return res * sgn;
    		}
                    
                    public long readLong() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			long sgn = 1;
    			if (c == '-') {
    				sgn = -1;
    				c = read();
    			}
    			long res = 0;
    			do {
    				if (c < '0' || c > '9')
    					throw new InputMismatchException();
    				res *= 10;
    				res += c - '0';
    				c = read();
    			} while (!isSpaceChar(c));
    			return res * sgn;
    		}
    
    		public String readString() {
    			int c = read();
    			while (isSpaceChar(c))
    				c = read();
    			StringBuilder res = new StringBuilder();
    			do {
    				res.appendCodePoint(c);
    				c = read();
    			} while (!isSpaceChar(c));
    			return res.toString();
    		}
    
    		public boolean isSpaceChar(int c) {
    			if (filter != null)
    				return filter.isSpaceChar(c);
    			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    		}
    
    		public String next() {
    			return readString();
    		}
    
    		public interface SpaceCharFilter {
    			public boolean isSpaceChar(int ch);
    		}
    	}
    
    class OutputWriter {
    		private final PrintWriter writer;
    
    		public OutputWriter(OutputStream outputStream) {
    			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    		}
    
    		public OutputWriter(Writer writer) {
    			this.writer = new PrintWriter(writer);
    		}
    
    		public void print(Object...objects) {
    			for (int i = 0; i < objects.length; i++) {
    				if (i != 0)
    					writer.print(' ');
    				writer.print(objects[i]);
    			}
    		}
    
    		public void printLine(Object...objects) {
    			print(objects);
    			writer.println();
    		}
    
    		public void close() {
    			writer.close();
    		}
    
    		public void flush() {
    			writer.flush();
    		}
    
    		}
    
    class IOUtils {
    
    		public static void readLongArray(InputReader in, int size,long[] array) {
    			//long[] array = new long[size];
    			for (int i = 0; i < size; i++)
    				array[i] = in.readLong();
    			
    		}
    }

",JAVA
7125913,"
    #pragma comment(linker, ""/STACK:66777216"")
    #define _CRT_SECURE_NO_WARNINGS
    #define _USE_MATH_DEFINES
    #include <cstdio>
    #include <algorithm>
    #include <cstdlib>
    #include <vector>
    #include <cstring>
    #include <string>
    #include <set>
    #include <map>
    #include <unordered_set>
    #include <unordered_map>
    #include <bitset>
    #include <utility>
    #include <functional>
    #include <iostream>
    #include <iomanip>
    #include <ctime>
    #include <cassert>
    #include <queue>
    #include <cmath>
    #pragma hdrstop
    
    using namespace std;
    
    #ifdef WIN32
    #define LLD ""%I64d""
    #define LLU ""%I64u""
    #define popcount(a) __popcnt(a)
    #else
    #define LLD ""%lld""
    #define LLD ""%llu""
    #define popcount(a) __builtin_popcount(a)
    #endif
    
    #define fill(a, x) memset(a, x, sizeof(a))
    #define sz(a) ((int)a.size())
    #define X first
    #define Y second
    #define mp make_pair
    #define all(a) a.begin(), a.end()
    
    typedef long long ll;
    typedef unsigned int uint;
    typedef pair<int, int> pii;
    typedef pair<ll, ll> pll;
    
    const int INF = 0x3f3f3f3f;
    const double EPS = 1e-9;
    const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
    const int MOD = 1000000007;
    
    #define TASK ""task""
    
    const int MAXN = 11111;
    
    int __;
    
    int x[4], y[4], n;
    
    int main() {
    #ifdef _DEBUG
        freopen(""input.txt"", ""r"", stdin);
        freopen(""output.txt"", ""w"", stdout);
    #else
        //freopen(TASK"".in"", ""r"", stdin);
        //freopen(TASK"".out"", ""w"", stdout);
    #endif
        scanf(""%d"", &__);
        for (int _ = 0; _ < __; ++_) {
            scanf(""%d"", &n);
            for (int i = 0; i < 3; ++i) {
                scanf(""%d%d"", x + i, y + i);
            }
            int ans = abs(x[1] - x[0]) + abs(y[1] - y[0]);
            if (x[1] == x[0] && x[2] == x[0] && min(y[0], y[1]) < y[2] && max(y[0], y[1]) > y[2] ||
                y[0] == y[1] && y[2] == y[0] && min(x[0], x[1]) < x[2] && max(x[0], x[1]) > x[2]) {
                    ans += 2;
            }
            printf(""%d\n"", ans);
        }
        return 0;
    }
    

",C++
6775721,"
    #include<stdio.h>
    #include<conio.h>
    #include<stdlib.h>
    int main(void)
    {
    
        double prob[2005][2005];
        int i,j;
        for(i=1;i<=2000;i++)
        {
            for(j=1;j<=i;j++)
    
            {
    
                prob[i][j]=1-0.5*(prob[i-1][j]+prob[i-1][j-1]);
    
            }
        }
    
        int t,n,num,ans=0;
        scanf(""%d"",&t);
        while(t--)
        {
            scanf(""%d"",&n);
            int k;
            for(k=1;k<=n;k++)
            {
                scanf(""%d"",&num);
                ans=ans+num*prob[n][k];
            }
            printf(""%0.6f\n"",ans);
        }
        return 0;
    }
    
    
    
    
    
    
    
    
    

",C
3596106,"
    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <map>
    #include <set>
    #include <vector>
    #include <string>
    #include <algorithm>
    
    #define MOD 1000000007
    #define SWAP(a,b) {a=(a)^(b);b = (a)^(b);a= (a)^(b);}
    
    using namespace std;
    
    inline long long minOf(long long x, long long y){return (x<y?x:y);}
    inline long long maxOf(long long x, long long y){return (x>y?x:y);}
    inline long long mabs(long long x){return (x<0?-x:x);}
    
    long double v[2003];
    long double dp[2003][2003];
    bool visit[2004][2003];
    bool turnEven;
    
    #define LD (long double)
    
    int n;
    
    long double mem(int i, int j){
    	if(visit[i][j])
    		return LD dp[i][j];
    	visit[i][j] = true;
    	if(i == j){
    		dp[i][j] = v[i];
    		return LD dp[i][j];
    	}
    
    	if((turnEven && (n-(j-i))%2 == 0) || (!turnEven && (n-(j-i))%2))
    		dp[i][j] = (LD mem(i+1,j) + LD mem(i,j-1) + LD v[i] + LD v[j]);
    	else
    		dp[i][j] = LD mem(i+1,j) + LD mem(i,j-1);
    	dp[i][j] = LD dp[i][j] * (long double)(0.5);
    	
    	return LD dp[i][j];
    }
    
    int main()
    {
    	ios_base::sync_with_stdio(false);
    	
    	int t;
    	cin >> t;
    	while(t--){
    		cin >> n;
    		memset(visit, false, sizeof(visit));
    		for(int i = 0;i<n;i++)
    			cin >> v[i];
    		if(n%2)
    			turnEven = false;
    		else 
    			turnEven = true;
    		long double ans = mem(0,n-1);
    		printf(""%.2Lf\n"", ans);
    	}
    	return 0;
    }

",C++
10871477,"
    #include <bits/stdc++.h>
    using namespace std;
    const int N = 5e5+1;
    int a[N];
    priority_queue < int, vector <int>, std::greater<int> > pq;
    
    
    int main(){
        int t;
        cin >> t;
        while(t--){
            int n,ans=0;
            map <int,int> ct;
            map <int,int> check;
            cin >> n;
            for(int i = 0; i < n; i++){
                cin >> a[i];
            }
            for(int i = 0; i < n; i++){
                ct[a[i]]++;
                check[a[i]]=0;
            }
            for(int i = 0; i < n; i++){
                if(!check[a[i]]){
                    pq.push(ct[a[i]]);
                    check[a[i]]=1;
                }
            }
            while(!pq.empty()){
                if(pq.size()==1){
                    ans+=pq.top();
                    pq.pop();
                }else{
                    while(pq.top()==0 && !pq.empty()) pq.pop();
                    if(!pq.empty()){
                        int cur = pq.top();
                        pq.pop();
                        int c2 = pq.top();
                        pq.pop();
                        c2-=cur;
                        pq.push(c2);
                        ans++;
                    }
                }
            }
            cout << ans << endl;
        }
    }
    

",C++
9272801,"
    import java.util.*;
    import java.lang.*;
    import java.io.*;
    
    class Main
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            Scanner sc = new Scanner(System.in);
            int lim = sc.nextInt(), tamaho, num ,suma, res = 0, dat1, dat2, resta, ii;
            HashMap<Integer, Integer> map ;
            int [] A;int [] aux;
            for(int  i = 0; i < lim ; i++){
                tamaho = sc.nextInt();
                map = new HashMap<Integer, Integer>();
                suma = 0;
                for(int j = 0;  j < tamaho; j++){
                    num = sc.nextInt();
                    if(map.containsKey(num)){
                        map.put(num, map.get(num) + 1);
                    } else {
                        map.put(num, 1);
                    }
                }
                ii = 0;
                A = new int [map.size()];
                Iterator it = map.entrySet().iterator();
                    while (it.hasNext()) {
                        Map.Entry e = (Map.Entry)it.next();
                        A[ii] = (Integer.parseInt(""""+e.getValue()));
                        ii++;
                    }
                Arrays.sort(A);
                while(A.length > 1){
                    if(A.length % 2 == 0){
                        aux = new int[A.length/2];
                        for(int r = A.length-1;  r>0; r-=2){
                            dat1 = A[r];
                            dat2 = A[r-1];
                            resta = dat1 - dat2;
                            if(resta < 0){
                                suma = suma + dat1;
                                resta = resta*-1;
                            } else 
                                suma = suma + dat2;
                            aux[r/2] = resta;
                        }   
                    } else {
                        aux = new int[(A.length/2) + 1];
                        
                        for(int r = A.length-1;  r > 1 ; r-=2){
                            dat1 = A[r];
                            dat2 = A[r-1];
                            resta = dat1 - dat2;
                            if(resta < 0){
                                suma = suma + dat1;
                                resta = resta*-1;
                            } else 
                                suma = suma + dat2;
                            aux[r/2] = resta;
                        }
                        aux[0] = A[0];
                    }
                    A = aux;
                }
                if(A.length == 1)
                    suma = suma + A[0];
                    System.out.println(suma);
            }
        }
    }

",JAVA
9242452,"
    /**
     * Created by Sumit on 26-01-2016.
     */
    import java.util.*;
    class cc2
    {
        public static void main(String[] args)
        {
            Scanner in= new Scanner(System.in);
            int n=in.nextInt();
            String res[]=new String[n];
            for(int i=0;i<n;i++)
            {
               int n1=in.nextInt();
                int r1[]=new int[n1];
                for(int j=0;j<n1;j++)
                {
                    r1[j]=in.nextInt();
                }
                Arrays.sort(r1);
                res[i] = """" + solve(r1);
            }
            for(int i=0;i<n;i++)
                System.out.println(res[i]);
        }
       static  int solve(int n[])
        {
            int c = 0;
            try
            {
            int l1 = 1;
            int l = n.length;
            int flag = n[0];
            for (int i = 1; i < l; i++)
            {
                if (n[i] != flag) {
                    l1++;
                    flag = n[i];
                }
            }
            int a[] = new int[l1];
            l1 = 0;
            for (int i = 0; i < l; i++)
            {
                for (int j = 0; j < l; j++)
                {
                    if (n[i] == n[j] && n[i] >= 0)
                    {
                        c++;
                       if(c>1)
                           n[j] = -1;
                    }
    
                }
                if (c > 0)
                {
                    a[l1] = c;
                    l1++;
                }
                c = 0;
            }
    
            Arrays.sort(a);
                if(l1==1)
                    return a[0];
    
            for (int i = 0; i < l1 / 2; i++)
            {
                int t = a[i];
                 a[i]=a[l1-1-i];
                a[l1-1-i] = t;
            }
                while(a[1]!=0)
                {
    
                    c=c+a[1];
                    a[0]=a[0]-a[1];a[1]=0;
                    Arrays.sort(a);
    
                    for (int i = 0; i < l1 / 2; i++)
                    {
                        int t = a[i];
                        a[i]=a[l1-1-i];
                        a[l1-1-i] = t;
                    }
                    if(a[1]==0)
                        c=c+a[0];
    
                }
    
            }
            catch(ArrayIndexOutOfBoundsException e){}
            return c;
        }
    
    }
    

",JAVA
11771860,"
    #include<stdio.h>
    int main()
    {
        int a,b,c,t;
        scanf(""%d"",&t);
        while(t--)
        {
            c=0;
            scanf(""%d %d"",&a,&b);
            while(b%a!=0)
            {
                a=a/2;
                c++;
            }
            while(a!=b)
            {
                a=a*2;
                c++;
            }
            printf(""%d\n"",c);
        }
        return 0;
    }
    

",C
10643320,"
    #include<iostream>
    #include<math.h>
    using namespace std;
    int main()
    {
    	int t,m,n,i;
    	int ans,flag;
    	int a[25];
    	for(i=0;i<24;i++)
    	a[i]=pow(2,i);
        cin>>t;
        while(t--)
        {
        	cin>>m>>n;
        	ans=0;
        	if((m%2==1)&&(m!=1))
        	{
    			m=(m-1)/2;
    			ans++;
    		}
    		if(m!=n)
    		{
    			flag=0;
    			i=23;
    			while(1)
    			{
    			  for(;i>=0;i--)
        		  {
        			if(m==a[i])
        			flag=1;
    			    else
        			if(m>a[i])
        			break;
    			  }
    			  if(flag==1)
    			  break;
    			  m/=2;
    			  ans++;
    		    }
    		    if(m>n)
    		    {
    			  while(m!=n)
    		      {
    			     m/=2;
    			     ans++;
    		      }
    		    }
    		    while(m!=n)
    		    {
    		    	m*=2;
    		    	ans++;
    			}
    		}
    		cout<<ans<<""\n"";
        }
    	return(0);
    }

",C++
9174350,"
    #include<iostream>
    using namespace std;
    int main(){
    	int t;
    	cin>>t;
    	for(int i=0;i<t;i++)
    	{
    		int a,b,steps=0;
    		cin>>a>>b;
    		
    		if(a & a-1!=0)
    		  {
    		  	while(a & a-1!=0)
    		  	 {
    		  	 	if(a%2==0)
    		  	 	 {
    		  	 	 	a=a/2;
    		  	 	 	steps++;
    					}
    				else
    				 {
    				 	a=(a-1)/2;
    				 	steps++;
    					 }	
    			   }
    			} 
    			
    		
    		  	if(a>b)
    		  	 {
    		     while(a>b)
    		       {
    		       	 a=a/2;
    		  	     steps++;
    			   }
    			 }
    			else if(b>a)
    			  {
    			  	while(b>a)
    			  	{
    			  	 a=a*2;
    			  	 steps++;
    				  }
    			  }
    		  	 
    		  	  
    		
    		cout<<steps<<endl;  	 
    		  
    	}
    }

",C++
7888915,"
    #include<iostream>
    #include<cstdio>
    #include<vector>
    #include<algorithm>
    
    using namespace std;
    
    int main() {
    
        int test,x,y,count;
        scanf(""%d"",&test);
        while(test--) {
            count =0;
            scanf(""%d %d"", &x,&y);
            while(x&(x-1)){
                x>>=1;
                count++;
            }
            if(x<y) {
                while(x<y){
                x<<=1;
                count++;
                }
            }
            else{
                while(y>x){
                x>>=1;
                count++;
            }}
            printf(""%d\n"",count);
        }
    
    
        return 0;
    
    }
    

",C++
8282159,"
    #include<iostream>
    #include<cstdio>
    #include<climits>
    using namespace std;
    int min(int b,int c)
    {
    	if(b<=c)
    	return b;
    	return c;
    }
    
    int k[501],h[501],arr[1001][1001];
    
    int main()
    {
    	int n,t,max=INT_MIN,i,j,z,x,y,sum=0;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d"",&n);
    		max=INT_MIN;
    		for(i=1;i<=n;i++)
    		{
    		scanf(""%d"",&h[i]);
    		if(h[i]>max)
    		max=h[i];
    	    }
    		for(i=1;i<=n;i++)
    		scanf(""%d"",&k[i]);
    		int temp[n+1][2*max+1];
    		/*for(i=0;i<=n;i++)
    		{
    			for(j=0;j<=2*max;j++)
    			{
    				arr[i][j]=INT_MAX;
    			}
    		}*/
    		for(j=1;j<=2*max;j++)
    		arr[0][j]=INT_MAX;
    		arr[0][0]=0;
    		for(i=1;i<=n;i++)
    		arr[i][0]=0;
    		for(i=1;i<=n;i++)
    		{
    			for(j=0;j<=2*max;j++)
    			{
    				arr[i][j]=arr[i-1][j];
    				x=k[i]-j;
    				//if(x==0)
    				//arr[i][j]=1;
    				//else
    				if(x<=0)
    				{
    				//	z=INT_MAX;
    					//y=j%k[i-1];
    					//if(y==0)
    					//z=j/k[i-1];
    					//arr[i][j]=1+arr[i][j-k[i]];
    					arr[i][j]=min(1+arr[i][j-k[i]],arr[i][j]);
    				}
    			}
    		}
    		sum=0;
    		
    			for(i=1;i<=n;i++)
    			{
    				x=2*h[i];
    				sum+=arr[n][x];
    			}
    			printf(""%d\n"",sum);
    		}
    	return 0;
    }

",C++
4380331,"
    #include <iostream>
    #include <stdio.h>
    #include <algorithm>
    
    using namespace std;
    
    int main() {
    	int t;
    	scanf(""%d"",&t);
    	int H[501],K[501];
    	int dp[501][501];
    	
    	int N,max;
    	while(t--)
    	{
    		dp[0][0]=0;
    		max=0;
    		scanf(""%d"",&N);
    		for(int i=1;i<=N;i++)
    		{
    		scanf(""%d"",&H[i]);
    		if(max<H[i])
    		max=H[i];
    		}
    		for(int j=1;j<=max*2;j++)
    		dp[0][j]=1000000000;
    		for(int i=1;i<=N;i++)
    		scanf(""%d"",&K[i]);
    		for(int i=1;i<=N;i++)
    		{
    			for(int j=0;j<=2*max;j++)
    			{
    				dp[i][j]=dp[i-1][j];
    				if(K[i]<=j)
    				dp[i][j]=min(dp[i][j],1+dp[i][j-K[i]]);
    			}
    		}
    		int sum=0;
    		for(int i=1;i<=N;i++){
    			sum=sum+dp[N][2*H[i]];
    		}
    		printf(""%d"",sum);
    	}
    	
    	// your code goes here
    	return 0;
    }

",C++
3935439,"
    #include <stdio.h>
    #include <limits.h>
     
    int fuelFill[1001];
    int fillSteps[1001];
     
     
    inline void scanint(int* x)
    {
    	register char c = getchar_unlocked();
    	*x = 0;
    	for(; (c<48)||(c>57);c = getchar_unlocked());
    	for(; (c>47)&&(c<58);c = getchar_unlocked())
    		*x = (int)((((*x)<<1) + ((*x)<<3)) + c - 48);
    }
     
    inline void printint(int n)
    {
    	if(n == 0)
    	{
    		putchar_unlocked('0');
    		putchar_unlocked('\n');
    	}
    	else if(n == -1)
    	{
    		putchar_unlocked('-');
    		putchar_unlocked('1');
    		putchar_unlocked('\n');
    	}
    	else
    	{
    		char buf[11];
    		buf[10] = '\n';
    		int i = 9;
    		while(n)
    		{
    			buf[i--] = n % 10 + '0';
    			n /= 10;
    		}
    		while(buf[i] != '\n')
    			putchar_unlocked(buf[++i]);
    	}	
    }
     
    int main()
    {	
    	int T;
    	scanint(&T);
    	
    	while(T--)
    	{
    		int N,i;
    		scanint(&N);
     
    		int dist[N], maxDist = 0;
     
    		for(i = 0; i < N; i++)
    		{
    			scanint(&dist[i]);
    			dist[i] *= 2;
    			if(dist[i] > maxDist) maxDist = dist[i];
    		}
     
    		for(i = 0; i < 1001; i++)
    			fuelFill[i] = 0;
    		for(i = 0; i < N; i++)
    		{
    			int x;
    			scanint(&x);
    			fuelFill[x] = 1;
    		}
     
    		for(i = 0; i < 1001; i++) 
    			fillSteps[i] = 0;
     
    		if(fuelFill[1] == 1) fillSteps[1] = 1;
    		else fillSteps[1] = -1;
     
     
    		for(i = 2; i <= maxDist; i++)
    		{
    			int fillCount = INT_MAX, count = 0,j;
     
    			for(j = 0; j <= (i/2); j++)
    			{
    				if(fuelFill[i-j] == 1)
    				{
    					if(fillSteps[j] == -1) continue;
     
    					count = 1 + fillSteps[j];
    					if(fillCount > count) fillCount = count;
     
    					if(fillCount == 1 || fillCount == 2) break;
    				}
    				else
    				{
    					if(j==0 || fillSteps[i-j] == -1 || fillSteps[j] == -1) continue;
     
    					count = fillSteps[i-j] + fillSteps[j];
    					if(count < fillCount) fillCount = count;
     
    					if(fillCount == 2) break;
    				}			
    			}
     
    			if(fillCount == INT_MAX) fillSteps[i] = -1;
    			else fillSteps[i] = fillCount;
    		}
     
    		int ans = 0;
    		for(i = 0; i < N; i++)
    			ans += fillSteps[dist[i]];
     
    		printint(ans);
    	}
     
    	return 0;
    } 

",C
2181826,"
    #include<iostream>
    #include<cmath>
    #include<cstdio>
    using namespace std;
    using namespace std;
    namespace IO
    {
    const int SIZE = 1 << 19;
    char buff[SIZE], *p = buff + SIZE;
     
    char read_char()
    {
        if( p == buff + SIZE )
        {
            fread( buff, 1, SIZE, stdin );
            p = buff;
        }
        return *(p++);
    }
     
    inline int read_int()
    {
        char c;
     
        while( !isdigit( c = read_char() ) );
     
        int r = c-'0';
        while( isdigit( c = read_char() ) ) r = (r<<3)+(r<<1) + c - '0';
     
        return r;
    }
    }
    using namespace IO;
    int main()
    {
        int t,n,i,j,h[505],k[505],max,dp[1005];
        //scanf(""%d"",&t);
        t=read_int();
        while(t--)
        {
            n=read_int();
            max=0;
            for(i=1;i<=n;i++)
            {
                h[i]=read_int();
                if(h[i]>max)
                    max=h[i];
            }
            for(i=1;i<=n;i++)
            {
                k[i]=read_int();
            }
            for(i=1;i<=2*max;i++)
            {
                dp[i]=10000;
            }
            dp[0]=0;
            for(i=1;i<=n;i++)
                for(j=k[i];j<=2*max;j++)
                {
                    dp[j]=min(dp[j],1+dp[j-k[i]]);
                }
            int ans=0;
            for(i=1;i<=n;i++)
            {
                ans+=dp[2*h[i]];
            }
            printf(""%d\n"",ans);
        }
     
    }

",C++
9776616,"
    #include <bits/stdc++.h>
    using namespace std;
     
    const int N=50000+5;
     
    struct Ans
    {
    	int ft,lst,g;
    	Ans(int _ft=0,int _lst=0,int _g=0):ft(_ft),lst(_lst),g(_g){}
    };
    struct Edge{int to,nxt;}e[N<<1];
    struct Tree{int ft,lst,g,tag;}tr[N*17];
    int n,m,tope,hd[N],a[N],b[N];
    int q[N],dep[N],fa[N],top[N],dfn[N],sz[N];
     
    inline void rd(int& x)
    {
    	char ch;
    	for (;!isdigit(ch=getchar()););
    	for (x=ch-48;isdigit(ch=getchar());x=x*10+ch-48);
    }
     
    inline char rd(void)
    {
    	char ch;
    	while (isspace(ch=getchar()));
    	return ch;
    }
     
    inline void add(int x,int y)
    {
    	e[++tope].to=y;e[tope].nxt=hd[x];hd[x]=tope;
    	e[++tope].to=x;e[tope].nxt=hd[y];hd[y]=tope;
    }
     
    inline Ans merge(Ans a,Ans b)
    {
    	return Ans(a.ft,b.lst,__gcd(__gcd(a.g,b.g),abs(b.ft-a.lst)));
    }
     
    inline void pushdown(int x,int l,int r)
    {
    	if (tr[x].tag)
    	{
    		int ch=x<<1;
    		tr[ch].ft+=tr[x].tag;
    		tr[ch].lst+=tr[x].tag;
    		tr[ch].tag+=tr[x].tag;
    		++ch;
    		tr[ch].ft+=tr[x].tag;
    		tr[ch].lst+=tr[x].tag;
    		tr[ch].tag+=tr[x].tag;
    		tr[x].tag=0;
    	}
    }
     
    inline void build(int x,int l,int r)
    {
    	if (l==r)
    	{
    		tr[x].ft=tr[x].lst=b[l];
    		return;
    	}
    	int m=(l+r)>>1,ch=x<<1;
    	build(ch,l,m);build(ch+1,m+1,r);
    	tr[x].ft=tr[ch].ft;
    	tr[x].lst=tr[ch+1].lst;
    	tr[x].g=__gcd(__gcd(tr[ch].g,tr[ch+1].g),abs(tr[ch+1].ft-tr[ch].lst));
    }
     
    inline void build(void)
    {
    	int l,r,now,p,ch;
    	for (dep[q[l=r=1]=1]=1;l<=r;++l)
    		for (p=hd[now=q[l]];p;p=e[p].nxt)
    			if (!dep[ch=e[p].to]) dep[q[++r]=ch]=dep[now]+1,fa[ch]=now;
    	for (int i=n;i;--i)
    	{
    		sz[now=q[i]]=1;
    		for (p=hd[now];p;p=e[p].nxt)
    			if (dep[ch=e[p].to]>dep[now]) sz[now]+=sz[ch];
    	}
    	dfn[1]=top[1]=1;
    	for (int i=1,mx,t;i<=n;++i)
    	{
    		now=q[i];mx=0;
    		b[dfn[now]]=a[now];
    		for (p=hd[now];p;p=e[p].nxt)
    			if (dep[ch=e[p].to]>dep[now] && sz[ch]>sz[mx]) mx=ch;
    		if (!mx) continue;
    		dfn[mx]=dfn[now]+1;top[mx]=top[now];
    		t=dfn[now]+sz[mx];
    		for (p=hd[now];p;p=e[p].nxt)
    			if (dep[ch=e[p].to]>dep[now] && ch!=mx)
    				dfn[ch]=t+1,t+=sz[ch],top[ch]=ch;
    	}
    	build(1,1,n);
    }
     
    inline int query(int x,int l,int r,int le,int ri)
    {
    	if (l==le && ri==r) return __gcd(tr[x].ft,tr[x].g);
    	int m=(l+r)>>1,ch=x<<1;
    	pushdown(x,l,r);
    	if (ri<=m) return query(ch,l,m,le,ri);
    	if (le>m) return query(ch+1,m+1,r,le,ri);
    	return __gcd(query(ch,l,m,le,m),query(ch+1,m+1,r,m+1,ri));
    }
     
    inline int query(int x,int y)
    {
    	int rt=0;
    	int t;
    	while (1)
    	{
    		if (top[x]==top[y])
    		{
    			if (dep[x]<dep[y]) t=query(1,1,n,dfn[x],dfn[y]);
    			else t=query(1,1,n,dfn[y],dfn[x]);
    			rt=__gcd(rt,t);
    			break;
    		}
    		if (dep[top[x]]>dep[top[y]])
    		{
    			t=query(1,1,n,dfn[top[x]],dfn[x]);
    			rt=__gcd(rt,t);
    			x=fa[top[x]];
    		}else{
    			t=query(1,1,n,dfn[top[y]],dfn[y]);
    			rt=__gcd(rt,t);
    			y=fa[top[y]];
    		}
    	}
    	return abs(rt);
    }
     
    inline void modify(int x,int l,int r,int le,int ri,int w)
    {
    	if (l==le && ri==r)
    	{
    		tr[x].ft+=w;
    		tr[x].lst+=w;
    		tr[x].tag+=w;
    		return;
    	}
    	int m=(l+r)>>1,ch=x<<1;
    	pushdown(x,l,r);
    	if (ri<=m) modify(ch,l,m,le,ri,w);else
    	if (le>m) modify(ch+1,m+1,r,le,ri,w);else
    	modify(ch,l,m,le,m,w),modify(ch+1,m+1,r,m+1,ri,w);
    	tr[x].ft=tr[ch].ft;
    	tr[x].lst=tr[ch+1].lst;
    	tr[x].g=__gcd(__gcd(tr[ch].g,tr[ch+1].g),abs(tr[ch+1].ft-tr[ch].lst));
    }
     
    inline void modify(int x,int y,int w)
    {
    	while (1)
    	{
    		if (top[x]==top[y])
    		{
    			if (dep[x]<dep[y]) modify(1,1,n,dfn[x],dfn[y],w);
    			else modify(1,1,n,dfn[y],dfn[x],w);
    			break;
    		}
    		if (dep[top[x]]>dep[top[y]])
    		{
    			modify(1,1,n,dfn[top[x]],dfn[x],w);
    			x=fa[top[x]];
    		}else{
    			modify(1,1,n,dfn[top[y]],dfn[y],w);
    			y=fa[top[y]];
    		}
    	}
    }
     
    int main()
    {
    	rd(n);
    	for (int i=1,x,y;i<n;++i)
    		rd(x),rd(y),add(x+1,y+1);
    	for (int i=1;i<=n;++i) rd(a[i]);
    	build();
    	rd(m);
    	for (int i=1,x,y,w;i<=m;++i)
    		if (rd()=='F')
    		{
    			rd(x);rd(y);
    			printf(""%d\n"",query(x+1,y+1));
    		}else{
    			rd(x);rd(y);rd(w);
    			if (w) modify(x+1,y+1,w);
    		}
    	return 0;
    } 

",C++
4206210,"
    #include<stdio.h>
    
    
    
    int isPresent(char s[],char name[][5],int *end,int s_pos)
    {
        int i=0,j,k;
        
           while(i < (*end) )
           {
                   j=s_pos;
                   k=0;
                     while(1)
                     {
                             if((s[j] == ' ' || s[j] == '\0') && name[i][k] == '\0')
                             return i;
                             if(s[j] != name[i][k])
                             {
                             i++;
                             break;
                             }
                             else
                             {
                                 j++;
                                 k++;
                             }
                     }
           }
           return -1;
    }
    
    int secnd_space(char s[])
    {
        int i=0;
        int flag=0;
        while(s[i] != '\0')
        {
                   if(s[i] == ' ')
                   {
                   flag++;
                   if(flag==2)
                   return (i+1);
                   }    
                   i++;
        }
    }
    
    int lastSpace(char s[])
    {
        int i=0;
        int flag=0;
        while(s[i] != '\0')
        {
                   if(s[i] == ' ')
                   flag=i;
                   i++;
        }
        return (flag+1);
    }
    
    int check_secnd_name(char s[],char name[][5],int *end)
    {
        int k=lastSpace(s);
        int flag;
        if(*end==1)
        {
                   int i=k;
                   flag=0;
                   while(s[i] != '\0')
                   {
                              name[*end][flag]=s[i];
                              i++;
                              flag++;
                   }
                   name[*end][flag]='\0';
                  *end+=1;
                  return 1;
        }
        int pos=isPresent(s,name,end,k);
        if(pos != -1)
        return pos;
         int j=k;
         flag=0;
                   while(s[j] != '\0')
                   {
                              name[*end][flag]=s[j];
                              j++;
                              flag++;
                   }
                   name[*end][flag]='\0';
                  *end+=1;
        return (*end-1);
        
    }
    
    
    
    int check_first_name(char s[],char name[][5],int *end)
    {
        if(*end==0)
        {
                   int i=0;
                   while(s[i] != ' ')
                   {
                              name[*end][i]=s[i];
                              i++;
                   }
                   name[*end][i]='\0';
                  *end+=1;
                  return 0;
        }
          int pos=isPresent(s,name,end,0);
          if(pos != -1)
          return pos;
         int j=0;
                   while(s[j] != ' ')
                   {
                              name[*end][j]=s[j];
                              j++;
                   }
                   name[*end][j]='\0';
                  *end+=1;
        return (*end-1);
    }
    
    
    int min_index(int dist[],int visited[],int p)
    {
        int flag=0;
        int min=99;
        int i;
        for(i=0;i<p;i++)
        {
                        if(dist[i] < min && visited[i] ==0)
                        {
                                   min=dist[i];
                                   flag=i;
                        }
        }
        return flag;
    }
    int djikstras(int edge[][256],int u,int v,int p)
    {
        int dist[256];
        int i;
        int visited[256];
        for(i=0;i<p;i++)
        {
           dist[i]=99;
           visited[i]=0;
        }
        int flag=0;    
          dist[u]=0;
          while(visited[v] == 0)
            {
                           visited[u]=1;
                           if(flag==p)
                           return -1;
                           for(i=0;i<p;i++)
                           {
                                           if(edge[u][i]==1)
                                           {
                                                            if(dist[i]> dist[u]+1)
                                                               dist[i]=dist[u]+1;
                           }}
                           u=min_index(dist,visited,p);
                           flag++;
            }
            return dist[v];
    }    
        
    void conclude_realtions(char relation[][256],int p)     
    {
         int i,j,k;
         while(1)
         {
          int flag=0;
         for(k=0;k<p;k++)
         {
                         for(i=0;i<p-1;i++)
                         {
                                         for(j=i+1;j<p;j++)
                                         {
                                                           
                                                           if(relation[i][k] == relation [j][k] && relation[i][k] == 's')
                                                              {
                                                                            if( relation[i][j] == ' ')
                                                                            {
                                                                                relation[i][j]='s';
                                                                                relation[j][i]='s';
                                                                                flag++;
                                                                            }
                                                              }
                                                               if(relation[i][k] == relation [j][k] && relation[i][k] == 'c')
                                                              {
                                                                            if( relation[i][j] == ' ')
                                                                            {
                                                                                relation[i][j]='s';
                                                                                relation[j][i]='s';
                                                                                flag++;
                                                                            }
                                                              }
                                         }
                         }
                         
         }
         if(flag==0)
                         break;
         }
         for(k=0;k<p;k++)
         {
                         for(i=0;i<p;i++)
                         {
                                         if(relation[i][k]=='p')
                                         {
                                                                int j;
                                                                for(j=0;j<p;j++)
                                                                {
                                                                                if(relation[k][j]=='s')
                                                                                {
                                                                                                     relation[i][j]='p';
                                                                                                     relation[j][i]='c';
                                                                                }
                                                                }
                                         }
                         }
         }  
                                         
                                         
                                         
         
         
         
         
    }
    
    int main()
    {
        int p,r;
      //  printf(""Enter the no. of people an relation \n"");
        scanf(""%d %d"",&p,&r);
        if(r>p)
        return;
        char name[256][5];
        int end=0;
        int edge[256][256];
        char relation[256][256];
        int i,j;
         char s[30];
        for(i=0;i<p;i++)
        {
                    for(j=0;j<p;j++)
                    {
                                    edge[i][j]=0;
                                    relation[i][j]=' ';
                    }
       }
        
        for(i=0;i<r;i++)
        {
                       
                        //printf(""enter a relation : "");
                        scanf("" %[^\n]"",&s);
                        int u=check_first_name(s,name,&end);
                        int v=check_secnd_name(s,name,&end);
                        int rel=secnd_space(s);
                        if(s[rel] == 'f' || s[rel] == 'm')
                        {
                                  relation[u][v]='p';
                                  relation[v][u]='c';
                        }
                        else if(s[rel] == 'd' || (s[rel] == 's' && s[rel+1]== 'o'))
                        {
                                  relation[u][v]='c';
                                  relation[v][u]='p';
                        }
                        else
                        {
                                  relation[u][v]='s';
                                  relation[v][u]='s';
                        }
      }
      /* int q;
       scanf(""%d"",&q);
       for(i=0;i<q;i++)
       {
              char rel[10];
              scanf("" %[^\n]"",&rel);
              int u=isPresent(rel,name,&end,0);
              int v=isPresent(rel,name,&end,lastSpace(rel));        
              int dis= djikstras(edge,u,v,p);
              printf(""%d \n"",dis);
       }
    */
    //printf(""\n"");
    conclude_realtions(relation,p);
    for(i=0;i<p;i++)
    {
                    for(j=0;j<p;j++)
                    {
                                    if(relation[i][j] !=' ')
                                    edge[i][j]=1;
                    //                printf(""%c "",relation[i][j]);
                    }
                  //  printf(""\n"");
    }
    
    int q;
       scanf(""%d"",&q);
       for(i=0;i<q;i++)
       {
              char rel[10];
              scanf("" %[^\n]"",&rel);
              int u=isPresent(rel,name,&end,0);
              int v=isPresent(rel,name,&end,lastSpace(rel));        
              int dis= djikstras(edge,u,v,p);
              printf(""%d\n"",dis);
    }
    
    
    
    //getch();
    return 0;
    }          
        
        
        
        
        
        
        
        
        
        
        
    

",C
8653235,"
    /*
        Author: Zhouxing Shi
        Created on Oct28, 2015
    */
    #include <cstdio>
    #include <cstring>
    #include <ctime>
    #include <algorithm>
    #include <vector>
    #include <queue>
    #include <map>
    #include <set>
    #define rep(i, a, b) for (int i = (a); i <= (b); ++i)
    #define drep(i, a, b) for (int i = (a); i >= (b); --i)
    #define REP(i, a, b) for (int i = (a); i < (b); ++i)
    #define pb(x) push_back(x)
    #define mp(x, y) (make_pair(x, y))
    #define clr(x) memset(x, 0, sizeof(x))
    #define xx first
    #define yy second
    
    using namespace std;
    
    typedef long long ll;
    typedef unsigned long long ull;
    typedef pair<int, int> pii;
    const int inf = ~0U >> 1;
    const ll INF = ~0ULL >> 1;
    template <class T> inline void read(T &n)
    {
        char c; int flag = 1;
        for (c = getchar(); !(c >= '0' && c <= '9' || c == '-'); c = getchar()); if (c == '-') flag = -1, n = 0; else n = c - '0';
        for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0'; n *= flag;
    }
    //***************************
    
    const int maxn = 220000;
    const int mo = 1000000007;
    
    int cnt, N, Q, M;
    int h[maxn], A[maxn], ty[maxn], x[maxn], y[maxn], id[maxn], pos[maxn], z[maxn];
    int pre[maxn], w[maxn], a[maxn];
    set<int> E[maxn];
    deque<int> Cur;
    
    namespace Splay
    {
    	int n, Index, a[maxn], pos[maxn];
    	
    	struct node
    	{
    		int f, c[2], d, rev, sz, allsz, active;
    		void reset() { f = c[0] = c[1] = rev = sz = allsz = active = 0; }
    	} t[maxn];
    	
    	int rt, N, M;
    	int sta[maxn];
    	
    	void upd(int x) 
    	{ 
    		if (x)
    		{
    			t[x].sz = t[x].active + t[t[x].c[0]].sz + t[t[x].c[1]].sz;
    			t[x].allsz = 1 + t[t[x].c[0]].allsz + t[t[x].c[1]].allsz;
    		}
    	}
    	
    	inline void setc(int x, int f, int s) { t[x].c[f] = s; if (s) t[s].f = x; upd(x); }
    	
    	int newnode(){ return ++Index;}
    	
    	void reverse(int p)
    	{
    		t[p].rev ^= 1;
    		swap(t[p].c[0], t[p].c[1]);
    	}
    	
    	void rot(int x, int f)
    	{
    	    int y = t[x].f, z = t[y].f;
    	    if (z) setc(z, t[z].c[1] == y, x); else t[x].f = z;
    	    setc(y, f, t[x].c[!f]); setc(x, !f, y);
    	    upd(y);
    	}
    	
    	void pushdown(int p)
    	{
    		if (t[p].rev) rep(k, 0, 1) if (t[p].c[k]) reverse(t[p].c[k]);
    		t[p].rev = 0;
    	}
    	
    	void splay(int p, int goal = 0)	
    	{
    		int top = 0;
    		for (int x = p; t[x].f != goal; x = t[x].f) sta[++top] = x;
    		sta[++top] = goal;
    		while (top) pushdown(sta[top--]);
    	    while (t[p].f != goal) 
    	    {
    	        int y = t[p].f, f1 = t[y].c[1] == p, f2 = t[t[y].f].c[1] == y;
    	        if (t[y].f == goal) rot(p, f1);
    	        else
    	        {
    	            if (f1 == f2) rot(y, f2);
    	            else rot(p, f1);
    	            rot(p, f2);
    	        }
    	    }
    	    upd(p);
    	    if (!goal) rt = p;
    	}    
    	
    	int build(int l, int r)
    	{
    		if (l > r) return 0;
    		int p = newnode();
    		t[p].active = 1;
    		int m = l + r >> 1;
    		t[p].d = m;
    		setc(p, 0, build(l, m - 1));
    		setc(p, 1, build(m + 1, r));
    		return p;
    	}
    	
    	void push(int p)
    	{
    		splay(1, 0);
    		int x = t[1].c[1];
    		while (pushdown(x), t[x].c[0]) x = t[x].c[0];
    		setc(x, 0, p);
    		while (x) upd(x), x = t[x].f;
    	}
    	
    	int select(int k)
    	{
    		int p = rt;
    		while (pushdown(p), !t[p].active || t[t[p].c[0]].sz + 1 != k)
    		{
    			if (t[t[p].c[0]].sz >= k) p = t[p].c[0];
    			else k -= t[t[p].c[0]].sz + t[p].active, p = t[p].c[1];
    		}
    		return p;
    	}
    	
    	void build()
    	{
    		Index = 2; rt = 1;
    		t[1].active = t[2].active = 1;
    		setc(1, 1, 2); 
    		setc(2, 0, build(1, n));
    		upd(1);
    	}
    	
    	void markdel(int x)
    	{
    		x = select(x + 1);
    		splay(x);
    		t[x].active = 0;
    		upd(x);
    	}
    	
    	void travel()
    	{
    		rep(i, 3, Index) splay(i), pos[t[i].d] = t[t[i].c[0]].allsz;
    	}
    	
    	void insert(int x)
    	{
    		x = select(x + 1);
    		splay(x);
    		x = t[x].c[1];
    		while(t[x].c[0]) x = t[x].c[0];
    		int p = newnode();
    		t[p].active = 1;
    		t[p].d = ++n;
    		setc(x, 0, p); upd(p); upd(x);
    		splay(p);
    	}
    }
    
    struct info
    {
    	int d[4];
    	inline info(){}
    	inline info(int d0, int d1, int d2, int d3){ d[0] = d0; d[1] = d1; d[2] = d2; d[3] = d3; }
    } ;
    
    struct node
    {
    	int ls, rs;
    	info d;
    	node(){ d = info(0, 0, 0 ,0); ls = rs = 0; }
    } t[40000000];
    
    int root[maxn * 4], Iseg, d0, d1, d2, d3;
    
    inline info operator+(const info &A, const info &B)
    {
    	info ret = info(A.d[0] + B.d[0], (A.d[1] + B.d[1]), (A.d[2] + B.d[2]), (A.d[3] + B.d[3]));
    	rep(k, 1, 3) if (ret.d[k] >= mo) ret.d[k] -= mo;
    	return ret;
    }
    
    void modify(int p, int L, int R, int x)
    {
    	t[p].d.d[0] += d0;
    	t[p].d.d[1] += d1;
    	t[p].d.d[2] += d2;
    	t[p].d.d[3] += d3;
    	rep(k, 1, 3) 
    		if (t[p].d.d[k] >= mo) t[p].d.d[k] -= mo;
    		else if (t[p].d.d[k] < 0) t[p].d.d[k] += mo;
    	if(L == R)	return;
    	int m = L + R >> 1;
    	if (x <= m)
    	{
    		if (!t[p].ls) t[p].ls = ++Iseg;
    		modify(t[p].ls, L, m, x);
    	}
    	else
    	{
    		if (!t[p].rs) t[p].rs = ++Iseg;
    		modify(t[p].rs, m + 1, R, x);
    	}
    }
    
    void Modify(int x, int y)
    {
    	if (y == 0) { modify(root[0], 1, M, x); return; }
    	while (y <= M) modify(root[y], 1, M, x), y += y & (-y);
    }
    
    info query(int p, int L, int R, int l, int r)
    {
    	if (!p) return info(0, 0, 0, 0);
    	if (L == l && R == r) return t[p].d;
    	int m = L + R >> 1;
    	if (r <= m) return query(t[p].ls, L, m, l, r);
    	else if (l > m) return query(t[p].rs, m + 1, R, l, r);
    	else return query(t[p].ls, L, m, l, m) + query(t[p].rs, m + 1, R, m + 1, r);
    }
    
    info Query(int l0, int r0, int r1)
    {
    	info ret = info(0, 0, 0, 0);
    	while (r1) ret = ret + query(root[r1], 1, M, l0, r0), r1 -= r1 & (-r1);
    	ret = ret + query(root[0], 1, M, l0, r0);
    	return ret;
    }
    
    void del(int x)
    {
    	d0 = -1; d1 = mo - w[x];  d2 = (ll) d1 * w[x] % mo; d3 = (ll) d2 * w[x] % mo;
    	Modify(x, pre[x]);
    }
    
    void insert(int x)
    {
    	set<int>::iterator itr = E[a[x]].find(x);
    	if (itr != E[a[x]].begin()) pre[x] = *(--itr); else pre[x] = 0;
    	d0 = 1; d1 = w[x];  d2 = (ll) d1 * w[x] % mo; d3 = (ll) d2 * w[x] % mo;	
    	Modify(x, pre[x]);
    }
    
    void update(int x)
    {
    	del(x); insert(x);
    }
    
    int main()
    {
    	#ifdef DEBUG
    		freopen(""in"", ""r"", stdin);
    	#endif
    	
    	read(N); read(Q);
    	rep(i, 1, N) read(A[i]), h[++cnt] = A[i];
    	int Index = N;
    	rep(i, 1, Q) 
    	{
    		read(ty[i]);
    		if (ty[i] == 1) read(x[i]), read(y[i]);
    		else if (ty[i] == 2) read(x[i]), read(y[i]), h[++cnt] = y[i];
    		else if (ty[i] == 3) read(x[i]);
    		else if (ty[i] == 4) read(x[i]), read(y[i]), id[i] = ++Index, h[++cnt] = y[i];
    		else read(x[i]), read(y[i]);
    	}
    	sort(h + 1, h + cnt + 1);
    	cnt = unique(h + 1, h + cnt + 1) - h - 1;
    	
    	Splay::n = N;
    	rep(i, 1, N) Splay::a[i] = i;
    	Splay::build();
    	
    	rep(i, 1, Q) 
    		if (ty[i] == 3) Splay::markdel(x[i]);
    		else if (ty[i] == 4) Splay::insert(x[i]);
    		
    	Splay::travel();
    	M = Index;
    	rep(i, 0, M) root[i] = ++Iseg;
    	rep(i, 1, M) pos[i] = Splay::pos[i];
    	rep(i, 1, N) 
    	{
    		int x = pos[i];
    		Cur.pb(x);
    		a[x] = lower_bound(h + 1, h + cnt + 1, A[i]) - h;;
    		w[x] = A[i];
    		E[a[x]].insert(x);
    		insert(x);
    	}
    	
    	rep(i, 1, Q) 
    	{
    		if (ty[i] == 1) 
    		{
    			int l = *(Cur.begin() + x[i] - 1), r = *(Cur.begin() + y[i] - 1);
    			info ret = Query(l, r, l - 1);
    			ll ans = (ll) ret.d[1] * ret.d[1] % mo * ret.d[1] - 3ll * ret.d[2] * ret.d[1] % mo + 2ll * ret.d[3];
    			ans %= mo; ans = (ans + mo) % mo; ans = ans * 166666668 % mo;
    			printf(""%d\n"", int(ans));
    		}
    		else if (ty[i] == 2) 
    		{
    			int p = *(Cur.begin() + x[i] - 1);
    			del(p); 
    			E[a[p]].erase(p);
    			set<int>::iterator itr = E[a[p]].lower_bound(p);
    			if (itr != E[a[p]].end()) update(*itr);
    			a[p] = lower_bound(h + 1, h + cnt + 1, y[i]) - h;
    			w[p] = y[i];
    			E[a[p]].insert(p);
    			insert(p);
    			itr = E[a[p]].upper_bound(p);
    			if (itr != E[a[p]].end()) update(*itr);
    		}
    		else if (ty[i] == 3) 
    		{
    			int p = *(Cur.begin() + x[i] - 1);
    			del(p);
    			E[a[p]].erase(p);
    			Cur.erase(Cur.begin() + x[i] - 1);
    			set<int>::iterator itr = E[a[p]].lower_bound(p);
    			if (itr != E[a[p]].end()) update(*itr);
    		}
    		else if (ty[i] == 4) 
    		{
    			Cur.insert(Cur.begin() + x[i], pos[id[i]]);
    			int p = pos[id[i]];
    			a[p] = lower_bound(h + 1, h + cnt + 1, y[i]) - h;
    			w[p] = y[i];
    			E[a[p]].insert(p);
    			insert(p);
    			set<int>::iterator itr = E[a[p]].upper_bound(p);
    			if (itr != E[a[p]].end()) update(*itr);
    		}
    		else
    		{
    			int l = *(Cur.begin() + x[i] - 1), r = *(Cur.begin() + y[i] - 1);
    			info ret = Query(l, r, l - 1);
    			printf(""%d\n"", (ret.d[0] + mo) % mo);
    		}
    	}
    	#ifdef LOCAL
    		fprintf(stderr, ""%d\n"", clock());
    	#endif
    	return 0;
    }
    

",C++
11641139,"
    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
    
        int T;
        cin >> T;
        for (int i=0;i<T;i++)
        {
        string S;
        cin >> S;
    
        int X = S.length();
    
        int visited[26][26] ;
    
         for (int j = 0;j<26;j++)
        {
          for (int k=0;k<26;k++)
        {
            visited[j][k] = 0;
        }
        }
    
    
        for (int j=0; j<X-1; j++)
        {
            int P = S[j] - 'A';
            int Q = S[j+1] - 'A';
    
            visited[P][Q] = 1;
        }
    
        int count = 0;
    
        for (int j = 0; j<26; j++)
        {
          for (int k = 0; k<26; k++)
        {
            if (visited[j][k] == 1)
                count = count + 1;
        }
        }
    
        cout << count << ""\n"";
    
    
        }
    
    
    	return 0;
    }
    

",C++
9046196,"
    /* package whatever; // don't place package name! */
    
    import java.util.*;
    import java.lang.*;
    import java.io.*;
    
    /* Name of the class has to be ""Main"" only if the class is public. */
    class Ideone
    {
    	public static void main (String[] args) throws java.lang.Exception
    	{
    		Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    
    for(int i=0;i<t;i++)
    {
    String ss=s.next();
    HashSet<String> hs=new HashSet<String>();
    int l=ss.length();
    int count=0;
    for(int j=0;j<(l-1);j++)
    {
    char ch=ss.charAt(j);
    char ch1=ss.charAt(j+1);
    if(ch>='A'&&ch<='Z'&&ch1>='A'&&ch<='Z')
    {
    String s1=""""+ch+ch1;
    if(hs.contains(s1)){}
    else {
    hs.add(s1);count++;
    }
    
    
    }
    
    
    }
    
    System.out.println(count);
    
    
    }
    	}
    }

",JAVA
720838,"
    #include <cstdio>
    #include <cassert>
    #include <cstring>
    #include <algorithm>
    
    using namespace std;
    
    #define dbg(...) fprintf(stderr, __VA_ARGS__)
    
    const int mod = int(1e9+7);
    int x[105], y[105], sum, n;
    int dp[105][105];
    
    int main ()
    {
    // 	freopen (""input.txt"", ""r"", stdin);
     //	freopen (""output.txt"", ""w"", stdout);
    
    	int nt; scanf (""%d"", &nt);
    
    	while (nt--)
    	{
    	    scanf (""%d %d"", &sum, &n);
    	    for (int i = 1; i <= n; ++i) 
    	     	scanf (""%d %d"", &x[i], &y[i]);
    
    	    memset (dp, 0, sizeof (dp));
    		for (int i = x[1]; i <= y[1]; ++i)
    			dp[i][1] = 1;
    
    		for (int j = 2; j <= n; ++j)
    			for (int i = 0; i <= sum; ++i) 
    			{
    			 	for (int k = x[j]; k <= y[j]; ++k)
    			 		if (i >= k)
    			 		 	dp[i][j] = (dp[i-k][j-1]+dp[i][j]) % mod;
    			}
    				
    		printf(""%d\n"", dp[sum][n]);
    	}
    	 	
    	return 0;            
    }

",C++
11231993,"
    #include<iostream>
    #include<vector>
    #include<limits.h>
    using namespace std;
    int main()
    {
    	int n,q;
    	cin>>n>>q;
    	vector<int> res;
    	int min=INT_MAX,max=INT_MIN;
    	for(int i=0;i<n;i++)
    	{
    	int k;
    	cin>>k;
    	res.push_back(k);
    	if(k>max)
    	max=k;
    	if(k<min)
    	min=k;
    	}
    	for(int j=0;j<q;j++)
    	{
    	int a;
    	cin>>a;
    	if(a>=min&&a<=max)
    	cout<<""YES\n"";
    	else
    	cout<<""NO\n"";
    	
    	}
    	
     
    return 0;
     
     
    } 

",C++
11197653,"
    #include<iostream>
    #include<math.h>
    using namespace std;
    #define ll long long int
    
    int main()
    {
        ll n,q;
        cin>>n;
        cin>>q;
        ll a[n+1],i,p,max1=0,min1=0,x;
        for(i=0;i<n;i++){
            cin>>a[i];
            p=a[0];
            if(a[i]>a[0])
                max1=a[i];
            if(a[i]<a[0])
                min1=a[i];
        }
        for(i=0;i<q;i++)
        {
        	cin>>x;
            if(x>=min1||x<=max1)
               cout<<""Yes\n"";
            else
                cout<<""No\n"";
        }
            
        return 0;
    }
    

",C++
9865551,"
    #include <bits/stdc++.h>
    using namespace std;
    static int dp[100000001];
    int solve(long long int x)
    {
        if(x==1)
            return 0;
        if(dp[x]!=-1)
            return dp[x];
        int flag=0;
        for(long long int i=2;i*i<=x;i++){
            if(x%i==0){
                flag|=(1^solve(i));
                if(flag){
                    dp[x]=1;
                    return 1;
                }
                flag|=(1^solve(x/i));
                if(flag){
                    dp[x]=1;
                    return 1;
                }
            }
        }
        flag|=solve(x-1)^1;
        dp[x]=flag;
        return dp[x];
    }
    int main(){
        memset(dp,-1,sizeof(dp));
        int t;
        scanf(""%d"",&t);
        while(t--){
            int n;
            scanf(""%d"",&n);
            if(!solve(n)){
                puts(""Tom"");
            }
            else
                puts(""Mike"");
        }
    } 

",C++
11838265,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        long long i,t,c;
        char s[100000];
        scanf(""%lld"",&t);
        while(t--)
        {
            scanf(""%s"",s);
            c=0;
            for(i=0;s[i]!='\0';i++)
            {
                if(s[i]=='1')
                c++;
    
            }
            c= c*(c+1)/2;
            printf(""%lld\n"",c);
        }
        return 0;
    }
    

",C
9569545,"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    long long int t, i, j, n, k, flag;
    string a;
    cin>>t;
    long long int ans[t];
    for(i=0;i<t;i++)
    {
        cin>>n;
        flag=0;
    
        cin>>a;
        for(j=0;j<n;j++)
        {
            if(a[j]=='1') flag++;
        }
        ans[i]=flag+(flag*(flag-1))/2;
    }
    for(i=0;i<t;i++)
    {
        cout<<ans[i]<<endl;
    }
    
    return 0;
    }
    

",C++
9256324,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int a;
    	cin>>a;
    	while(a--)
    	{
    		int b;
    		cin>>b;
    		char arr[b+1];
    		cin>>arr;
    		int i;
    		int k=0;
    		for(i=0;i<b;i++)
    		if(arr[i]=='1')
    		k++;
    		long long int d=0;
    		d=(k*(k+1))/2;
    		cout<<d<<endl;
    	}
    }

",C++
7345126,"
    import java .io.*;
    class Csub
    {
    	public static void main(String argss[])throws IOException
    	{
    		BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 	
    		int t=Integer.parseInt(br.readLine());	
    		for(int l=0;l<t;l++)
    		{
    			int count=0;
    			int n=Integer.parseInt(br.readLine());
    			String s=br.readLine();
    			char c[]=s.toCharArray();	
    			
    			for(int i=0;i<n;i++)
    			{
    				if(c[i]=='1')
    				{
    					count++;
    				}
    			}
    			System.out.println((count*(count+1))/2);
    		}
    	}
    }

",JAVA
7233836,"
    #include <iostream>
    #include <string>
     
    using namespace std;
     
    int main()
    {
    	long long int t;
    	cin >> t;
    	while(t--)
    	{
    		long long int n;
    		cin >> n;
    		string s;
    		cin >> s;
    		long long int count=0;
    		for(int i=0;i<n;i++)
    		{
    			if(s[i] == '1')	
    				count++;		
    		}
    		cout << count*(count+1)/2 << endl;
    	}
     
    } 
    

",C++
6177413,"
    #include<stdio.h>
    
    
        int main()
        {
        long long int t,c,n;
        char s;
    
        scanf(""%Ld"",&t);
        getchar();
    
        while(t--)
        {
            c = 0;
            scanf(""%Ld"",&n);
            getchar();
            while (n--)
            {
                s = getchar();
                if (s== '1')
                c++;
            }
            getchar();
            printf(""%Ld\n"",c*(c+1)/2);
        }
        return 0;
        }
    

",C
4523922,"
    #include <iostream>
    using namespace std;
    
    int main() {
    	int a;
    	cin>>a;
    	while(a--)
    	{
    		int n,b;
    		cin>>n;
    		cin>>b;
    		int x=0,count=0,a[n];
    		for(int i=0;i<n;i++)
    			{
    				a[i]=(b%10);
    				b=(b/10);
    			}
    		for(int i=0;i<n;i++)
    		{
    			if(a[i]==1)
    				{
    					x+=1;
    					count+=x;
    				}
    		}
    		cout<<count<<endl;
    	}
    	return 0;
    }

",C++
4331572,"
    def genTable(num):
        table = []
        curSum = 0
        for i in range(0, num + 1):
            table.append(curSum)
            curSum += i + 1
            #print curSum
        return table
    
    def findSub(aStr, strLen, table):
        numOnes = 0
    #    for i in range(0, len(aStr)):
      #      if aStr[i] == '1':
     #           numOnes += 1
        numOnes = aStr.count('1')
        if (numOnes > 10000):
            numOnes = 10000
        return table[numOnes]
        
    
    num = int(input())
    table = genTable(20000)
    
    while num > 0:
        strLen = int(input())
        toFind = raw_input()
        #print toFind
        # if (strLen > 10000) :
        #    strLen = 10000
        toFind = toFind.strip()
        #toFind = toFind.strip("" "")
        subs = findSub(toFind, strLen, table)
        print subs
        num -= 1
    
    
    

",PYTH
4331191,"
    #include <stdio.h>
    #define scan(x) \
    {\
    register int c =gc();\
    *x = 0;\
    for(;(c<48 || c>57);c = gc());\
    for(;c>47 && c<58;c = gc()) {*x = (*x)*10 + c - 48;}\
    }
    
    
    int main()
    {
            int test;
            scan(&test);
            while(test--)
            {
                int i,j,k,len,num;
                long long int a[10],sum=0;
                a[0]=0,a[1]=0;
                scan(&len);
                for ( i = 0; i < len ; ++i)
                {
                    scanf(""%1d"",&num);
                    a[num]++;
                }
                //printf(""%lld\n"",a[1]);
                sum=(a[1]*(a[1]+1))/2;
                printf(""%lld\n"",sum);
            }
            return 0;
    }

",C
7356964,"
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    using namespace std;
    int main()
    {
        int t;
        scanf(""%d"",&t);
        while(t--)
        {
            long int len,i,ans=0;
            long int b[26];
            memset(b,0,sizeof(b));
            char s[100001];
            scanf(""%s"",&s);
            len=strlen(s);
            for(i=0;i<len;i++)
            {
                if(b[s[i]-97]==0) ans++;
                b[s[i]-97]++;
            }
            printf(""%ld\n"",ans);
        }
        return 0;
    }
    

",C++
5443966,"
    #include<stdio.h>
    #include<string.h>
    #define pf printf
    #define sf scanf
    
    int main() {
    
    	char a[100010];
    	int len;
    	char ch;
    
    	int t;
    	sf(""%d"",&t);
    	getchar();
    
    	while(t--) {
    
    		int ans = 0;
    
    		// creating buffers
    		char buff[256];
    		
    		// taking input
    		len=0;
    		ch=getchar();
    		while(ch!='\n' && ch!=EOF) {
    			a[len++]=ch;
    			ch=getchar();
    		}
    		a[len]='\0';
    
    		// solving
    		for(int i=0;i<len;i++) {
    			memset(buff,0,sizeof(buff));
    			int j;
    			for(j=i;buff[a[j]] != 1 & j<len ; j++) {
    				buff[a[j]]++;
    			}
    			//pf("" len is %d "",(j-i+1));
    			if ( (j-i) > ans ) ans = j-i;
    		}
    
    		pf(""%d\n"",ans);
    	}
    
    
    	return 0;
    }

",C++
5442111,"
    #include<bits/stdc++.h>
    using namespace std;
    
    int main()
    {
    	int t;
    	cin>>t;
    
    	while(t--)
    	{
    		string s;
    		cin>>s;
    		
    		string ans;
    
    		int a[26]={0};
    		for(int i = 0 ; i<s.length(); i++)
    		{
    			if(a[  s[i] - 97 ] == 0 )
    			{
    				ans.push_back(s[i]);
    				a[ s[i] - 97 ] = 1;
    			}
    		}
    		
    		cout<<ans.length()<<endl;
    
    	}
    
    
    	return 0;
    }

",C++
7588614,"
    #include <bits/stdc++.h>
    using namespace std;
     
    long long int N,M,T;
     
    int main (){
    	/*freopen(""in.txt"",""r"",stdin);
    	freopen(""out.txt"",""w"",stdout);
    	*/
    	
    	
    	cin>>T;
    	
    	long long int m1, m2 ,ans = 0, up, up_e, down_e , start_up; 
    	
    	while(T--){
    		scanf(""%lld %lld"",&N,&M);
    		m1 = N/M;
    		m2 = (2*N)/M;
    		
    		up_e = down_e = 0 ;
    		up = m2- m1; 
    		start_up = m1 + M;
    		
    		if(M<=N){
    			if(M%2){
    				down_e = m1/2;
    			}else
    				down_e = m1;
    		}
    		
    		if(M%2 == 0){
    			up_e = up;
    		}else{
    			if(start_up%2 == 0 && up %2 == 0)
    				up_e = up/2 +1;
    			else
    				up_e = up/2;
    		}
    		
    		ans = M*(m1*(m1+1)/2)/2;
    		ans += (m2-m1)*N - M*(m2*(m2+1)/2 - m1*(m1+1)/2)/2 - down_e - (m1-down_e)/2 - (up-up_e)/2;
    			
    		printf(""%lld\n"",ans);
    	}
    	
    	return 0;	
    }

",C++
11222239,"
    #include <iostream>
    #include <algorithm>
    #include <stdio.h>
    using namespace std;
    typedef long long int ll;
    int main() {
    	// your code goes here
    	ll t;
    	scanf(""%lld"", &t);
    	while(t--) {
    		ll n;
    		scanf(""%lld"", &n);
    		ll a[n];
    		ll b[n];
    		ll i;
    		string s;
    		cin >> s;
    		for(i = 0; i < n; i++) {
    			a[i] = (ll)(s[i]);
    			b[i] = a[i];
    		}
    		string str = """";
    		sort(a, a + n);
    		ll f = 0;
    		ll val1, val2;
    		for(i = 0; i < n; i++) {
    			if(f) {
    				if(b[i] == val1) {
    					str = str + (char)(val2);
    				}
    				else {
    					str = str + (char)(b[i]);
    				}
    			}
    			else {
    				if(a[i] == b[i]) {
    					str = str + (char)(b[i]);
    				}
    				else {
    					f = 1;
    					str = str + (char)(a[i]);
    					val1 = a[i];
    					val2 = b[i];
    				}
    			}
    		}
    		cout << str << endl;
    	}
    	return 0;
    }

",C++
11190560,"
    #include<bits/stdc++.h>
    using namespace std;
    long long a[105];
    int main()
    {
        int n,k,t,i,j,mx;
    
        string str;
    
        scanf(""%d"",&t);
    
        j = t;
    
        while(t--)
        {
            cin >> n;
    
            cin >> str;
    
    
            for(i=0; i<n; i++)
            {
                a[i] = str[i]-'0';
    
               // mx = max(mx, j);
            }
    
            sort(a, a+n);
    
            for(i=0; i<n; i++) printf(""%c"", a[i]+'0');
    
                if(t>=1) printf(""\n"");
        }
    
        return 0;
    }

",C++
6619028,"
    #include<cstdio>
    #include<cstring>
    int main()
    {
    int n,t,i,j,k;
    char s[53],s1[53],ans[53],tmp,tmp1;
    scanf(""%d"",&t);
    while(t--)
    	{
    	scanf(""%d"",&n);
    	scanf(""%s"",s1);
    	for(i=0;i<n;i++)
    		for(j=0;j<n;j++)
    			{
    			strcpy(s,s1);
    			if(i<j)
    				{
    				tmp=s[i];
    				for(k=i;k<j;k++)
    					s[k]=s[k+1];
    				s[j]=tmp;
    				}
    			else if(j<i)
    				{
    				tmp=s[i];
    				for(k=i;k>j;k--)
    					s[k]=s[k-1];
    				s[j]=tmp;
    				}
    			if(i==0 && j==0)
    				strcpy(ans,s);
    			else
    				{
    				k=0;
    				while(k<n && s[k]==ans[k])
    					k++;
    				if(k!=n && s[k]<ans[k])
    					{
    					strcpy(ans,s);
    					//printf(""%d %d*--------**\n"",i,j);
    					}	
    				}	
    				//printf(""%d %d*****\n"",i,j);
    			}
    	printf(""%s\n"",ans);
    	}
    return 0;
    }

",C++
3944881,"
    #include<iostream>
    #include<cstdio>
    using namespace std;
    //int compare (const void *a,const void *b)
    //{
    //	return (*(int *)a - *(int *)b);
    //}
    int main()
    {
    	int T,n,dash;
    	cin  >> T;
    	while(T--)
    	{
    		dash=0;
    		cin >> n;
    		int a[n+1],b[n+1],flag,i,j;
    		b[0]=0;
    		flag=1;
    		for(int i=1;i<=n;i++)
    		{
    			cin >> a[i] ;
    			b[i]= b[i-1]+a[i];
    			if(a[i]%n==0 && dash ==0)
    			{
    				printf(""1\n%d\n"",i);
    				dash=1;
    			}
    		}
    		if(dash==0)
    		{
    		for(i=0;i<n;i++)
    		{
    			for(j=i+1;j<=n;j++)
    			{
    				if(b[i]%n == b[j]%n)
    				{
    					flag=0;
    					break;
    				}
    			}
    			if(flag ==0 )
    				break;		
    		}
    		printf(""%d\n"",j-i);
    		//cout << j-i << endl;
    		for(int k=i+1;k<=j;k++)
    			//cout << k  << "" "";
    			printf(""%d "",k);
    		//cout << j << endl;
    		printf(""\n"");
    		}
    	}
    	return 0;
    }
    
    

",C++
3944359,"
    /*
     * hello.cpp
     *
     *  Created on: May 25, 2014
     *      Author: byte
     */
    
    #include<iostream>
    #include<cstdio>
    #include<algorithm>
    #include<vector>
    #include<string.h>
    
    int T, n;
    using namespace std;
    vector<pair<int, int> > sel;
    int a[100005];
    long long int dp[100005];
    struct comp {
    	bool operator()(const pair<int, int> &left, const pair<int, int> &right) {
    		return left.first > right.first;
    	}
    };
    int main() {
    
    	cin >> T;
    	for (int l = 0; l < T; l++) {
    		cin >> n;
    		//cout << a[4] << endl;
    		a[0] = 0;
    		dp[0] = 0;
    		bool found = false;
    		bool index = -1;
    		for (int i = 1; i <= n; i++) {
    			cin >> a[i];
    			dp[i] = (dp[i - 1] + a[i])%n;
    			if(dp[i]%n==0) {
    				found = true;
    				index = i;
    			}
    			sel.push_back(make_pair(dp[i],i));
    		}
    		if(found) {
    			cout<<index<<endl;
    			for(int i=1;i<=index;i++) {
    				cout<<i<<"" "";
    			}
    			cout<<endl;
    		}
    		else {
    			/*for(int j=0;j<sel.size();j++) {
    				cout<<sel[j].first<<"" ""<<sel[j].second<<endl;
    			}*/
    			sort(sel.begin(),sel.end(),comp());
    			for(int i=0;i<sel.size()-1;i++) {
    				if(sel[i].first==sel[i+1].first) {
    					int p,q;
    					p = sel[i].second;
    					q = sel[i+1].second;
    					//cout<<""found : ""<<p<<"" ""<<q<<endl;
    					if(p<q)swap(p,q);
    					cout<<p-q<<endl;
    					for(int j=q+1;j<=p;j++){
    						cout<<j<<"" "";
    					}
    					cout<<endl;
    				}
    			}
    
    		}
    
    
    	}
    }
    
    

",C++
10579405,"
    import java.util.*;
    import java.io.*;
    import java.math.*;
    class Divisibility{
    	public static void main(String args[]){
    		Scanner sc=new Scanner(System.in);
    		StringBuilder sb=new StringBuilder();
    		int n=sc.nextInt();
    		int q=sc.nextInt();
    		int[] a=new int[n];
    		for(int i=0;i<n;i++){
    			a[i]=sc.nextInt();
    		}
    		for(int i=0;i<q;i++){
    			int l=sc.nextInt();
    			int r=sc.nextInt();
    			int k=sc.nextInt();
    			int c=0;
    			for(int j=l-1;j<r;j++){
    				if(a[j]%k==0){
    					c++;
    				}
    			}
    			sb.append(c).append(""\n"");
    		}
    	
           	
    			
    	System.out.println(sb);	
    		
    				
    	}
    }

",JAVA
2687255,"
    #include <iostream>
    #include <cstdio>
    #include <vector>
    #include <cstring>
    using namespace std;
    #define MAX 100001
    vector <int> factors[MAX];
    vector <int> bucket[MAX];
    struct query 
    {
    	int id, L, R;
    };
    vector <query> v1[MAX];
    int tree[MAX];
    int a[MAX];
    void update (int idx, int val)
    {
    	while (idx < MAX)
    	{
    		tree[idx] += val;
    		idx += idx & (-idx);
    	}
    }
    int read (int idx)
    {
    	int val = 0;
    	while (idx > 0)
    	{
    		val += tree[idx];
    		idx -= idx & (-idx);
    	}
    	return val;
    }
    void storeFactors ()
    {
    	for (int i = 1; i < MAX; i++)
    	{
    		for (int j = i; j < MAX; j += i)
    		{
    			factors[j].push_back (i);
    		}
    	}
    }
    int main()
    {
    	int N, Q;
    	scanf (""%d%d"",&N,&Q);
    	storeFactors();
    	for (int i = 1; i <= N; i++)
    	{
    		scanf (""%d"",&a[i]);
    		for (int j = 0; j < factors[a[i]].size(); j++)
    		{
    			int b = factors[a[i]][j];
    			bucket[b].push_back (i);
    		}
    	}
    	int a, b, k;
    	for (int i = 1; i <= Q; i++)
    	{
    		scanf (""%d%d%d"",&a,&b,&k);
    		query q;
    		q.id = i;
    		q.L = a;
    		q.R = b;
    		v1[k].push_back (q);
    	}
    	int ans[Q+1];
    	memset (ans, 0, sizeof (ans));
    	for (int i = 1; i < MAX; i++)
    	{
    		//cout << bucket[i].size() << "" \n ""; 
    		for (int j = 0; j < bucket[i].size(); j++)
    		{
    			//cout << ""jii\n"";
    			update (bucket[i][j], +1);
    		}
    		for (int j = 0; j < v1[i].size(); j++)
    		{
    			//cout << ""hiii\n"";
    			query q = v1[i][j];
    			int ID = q.id;
    			int A = q.L;
    			int B = q.R;
    			//cout << ID << "" "" << A << "" "" << B << ""\n"";
    			ans[ID] = read (B) - read (A-1);
    		}
    		//cout << ""hii\n"";
    		for (int j = 0; j < bucket[i].size(); j++)
    		{
    			update (bucket[i][j], -1);
    		}
    
    	}
    	for (int i = 1; i <= Q; i++)
    	{
    		printf(""%d\n"",ans[i]);
    	}
    	return 0;
    }
    
    
    

",C++
7038676,"
    #include<stdio.h>
    int main()
    {
    	int t;
    	int n,j,idx,i;
    	char str[40][51];
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d"",&n);
    		getchar();
    		for(i=0;i<n;i++)
    		{
    			gets(str[i]);
    		}
    		printf(""\n"");
    		if(str[n-1][0]=='L')
    		  idx=5;
    		else if(str[n-1][0]=='R')
               idx=6;
    		 printf(""Begin "");
    		 for(j=idx;str[n-1][j]!='\0';j++)
    		 printf(""%c"",str[n-1][j]); 
    		 printf(""\n"");
    		 for(i=n-2;i>=0;i--)
    		 {
    		 	if(str[i+1][0]=='L')
    		 	idx=5;
    		 	else
    		 	idx=6;
    		 	if(idx==5)
    		 	{
    		 		printf(""Right"");
    		 		
    			 }
    			 else
    			 {
    			 	printf(""Left "");
    			 }
    			 for(j=idx;str[i][j]!='\0';j++)
    			 printf(""%c"",str[i][j]);
    			 printf(""\n"");
    		
    		 }
    		 printf(""\n"");
    		 
    		  		
    	}
    	return 0;
    }

",C
4849909,"
    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    
    using namespace std;
    int main(){
    int T,N;
    scanf(""%d"",&T);
    while(T--){
    
    	scanf(""%d"",&N);
    	getchar_unlocked();
    	char directions[N][1000];
    	char c;
    	fflush(stdin);
    	for(int i=0;i<N;i++) gets(directions[i]);
    		int i=(N-1);
    		if(directions[i][0]=='R' || directions[i][0]=='r' ){
    			printf(""Begin %s\n"",&directions[i][6]);
    			}else if(directions[i][0]=='L' || directions[i][0]=='l'){
    			printf(""Begin %s\n"",&directions[i][5]);
    			}
    	
    		for( i=(N-2);i>=0;i--){
    			//puts(directions[i]);
    			
    		if(directions[i+1][0]=='R'){
    			printf(""Left %s\n"",&directions[i][6]);
    			}else if(directions[i+1][0]=='L'){
    			printf(""Right %s\n"",&directions[i][5]);
    			}
    
    		}
    		printf(""\n"");	
    		}
    return 0;		//delete directions;
    }
    	
    

",C++
11601688,"
    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <cmath>
    #include <algorithm>
    #include <cstring>
    #include <string>
    using namespace std;
    int t, n, m, niz[10000007], type, l, r, segTree[10000007];
    int sito[1000005];
    const int MAX = -1;
    void constructTree(int input[], int segTree[], int low, int high, int pos){
        if(low==high){
            segTree[pos]= input[low];
            return;
        }
        int mid= (low+high)/2;
        constructTree(input, segTree, low, mid, 2*pos);
        constructTree(input, segTree, mid+1, high, 2*pos+1);
        segTree[pos]=max(sito[segTree[2*pos]], sito[segTree[2*pos+1]]);
    }
    
    void update(int lg, int dg, int l, int r, int pos){
        if(segTree[pos]==1) return;
        if(l==r) {segTree[pos]/=sito[segTree[pos]]; return;}
        if(l > dg || r < lg) return;
        int mid= (l+r)/2;
        update(lg, dg, l, mid, pos*2);
        update(lg, dg, mid+1, r, pos*2+1);
        segTree[pos]=max(sito[segTree[pos*2]], sito[segTree[pos*2+1]]);
    }
    int RMQ(int lg, int dg, int l, int r, int pos){
        if(segTree[pos]==1) return 1;
        if(l==r) return sito[segTree[pos]];
    
        if(l>=lg && r<=dg) return segTree[pos];    /// U POTPUNOSTI SE PREKLAPA
    
        if(l > dg || r < lg) return MAX;           /// NE PREKLAPA SE
    
        int mid= (l+r)/2;                          /// DELIMICNO SE PREKLAPA
        return max(RMQ(lg, dg, l, mid, pos*2),
                   RMQ(lg, dg, mid+1, r, pos*2+1));
    }
    
    int main(){
        for(int i = 1; i <= 1000000; i+=2) sito[i]=i;
        for(int i = 2; i <= 1000000; i+=2) sito[i]=2;
        for(int i = 3; i <= 1000; i+=2){
            if(sito[i]==i)
                for(int j = i*i; j <= 1000000; j+=2*i){
                    if(sito[j]>i) sito[j]=i;
                }
        }
        scanf(""%d"", &t);
        while(t--){
            scanf(""%d %d"", &n, &m);
            for(int i = 1; i <= n; i++){
                scanf(""%d"", &niz[i]);
            }
            constructTree(niz, segTree, 1, n, 1);
    //        for(int i = 0 ; i < 18; i++) cout << segTree[i] << "" "";
            for(int i = 1; i <= m; i++){
                scanf(""%d %d %d"", &type, &l, &r);
                if(type){
                    printf(""%d "", RMQ(l, r, 1, n, 1));
                }
                else{
                    update(l, r, 1, n, 1);
                }
            }
            printf(""\n"");
            memset(segTree, 0, sizeof(segTree));
        }
        return 0;
    }
    

",C++
7788109,"
    import java.util.*;
    import java.io.*;
    
    
    public class Main implements Runnable {
    		
            class Pair implements Comparable<Pair>{
                int v, id;
                Pair(int v, int id){
                    this.v = v;
                    this.id = id;
                }
                public int compareTo(Pair b){
                    if(v != b.v)
                        return v - b.v;
                    return id - b.id;
                }
            }
            
    	public void solve() throws IOException {
    		int n = nextInt();
                    int k = nextInt();
                    
                    Pair[] p = new Pair[n];
                    for(int i = 0; i < n; i++){
                        p[i] = new Pair(nextInt(), i);
                    }
                    
                    Arrays.sort(p);
                    int i = 0;
                    int answer = 0;
                    while(i < n){
                        int j = i+1;
                        while(j < n && p[i].v == p[j].v && p[j].id - p[i].id < k) j++;
                        i = j;
                        answer++;
                    }
                    
                    out.println(answer);
            }
    
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	//-----------------------------------------------------------
    	public static void main(String[] args) {
    		new Main().run();
    	}
    
            public void debug(Object... arr){
                System.out.println(Arrays.deepToString(arr));
            }
    
            public void print1Int(int[] a){
                    for(int i = 0; i < a.length; i++)
                            System.out.print(a[i] + "" "");
                    System.out.println();
            }
            
            public void print2Int(int[][] a){
                    for(int i = 0; i < a.length; i++){
                            for(int j = 0; j < a[0].length; j++){
                                    System.out.print(a[i][j] + "" "");
                            }
                            System.out.println();
                    }
            }
            
    	public void run() {
    		try {
    			in = new BufferedReader(new InputStreamReader(System.in));
                            out = new PrintWriter(System.out);
    			tok = null;
    			solve();
    			in.close();
                            out.close();
    		} catch (IOException e) {
    			System.exit(0);
    		}
    	}
    
    	public String nextToken() throws IOException {
    		while (tok == null || !tok.hasMoreTokens()) {
    			tok = new StringTokenizer(in.readLine());
    		}
    		return tok.nextToken();
    	}
    
    	public int nextInt() throws IOException {
    		return Integer.parseInt(nextToken());
    	}
    
    	public long nextLong() throws IOException {
    		return Long.parseLong(nextToken());
    	}
    
    	public double nextDouble() throws IOException {
    		return Double.parseDouble(nextToken());
    	}
            PrintWriter out;
    	BufferedReader in;
    	StringTokenizer tok;
    }

",JAVA
11541642,"
    // kdolls
    
    #include <bits/stdc++.h>
    using namespace std;
    
    #define REP(i,a,b) for(int i = a; i<=b; i++)
    #define ll long long int
    
    ll gcd(ll a, ll b)
    {
    	return b==0?a:gcd(b,a%b);
    }
    
    ll lcm(ll g1, ll g2)
    {
    	ll temp = g1/gcd(g1,g2);
    	temp*=g2;
    	return temp;
    }
    
    int main()
    {
    
    	ios_base::sync_with_stdio(false);
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		ll a,b,c,d,k,g1,g2,l;
    		cin>>a>>b>>c>>d>>k;
             
            g1 = gcd(a,b);
            g2 = gcd(c,d);
            l = lcm(g1,g2);
            cout<<(2*(k/l)+1)<<endl; 
    	}
    	return 0;
    }

",C++
7492408,"
    #include <bits/stdc++.h>
    #define LLMAX 1000000000000000000
    #define LL long long int
    #define mod 1000000007
    #define maxn 500010
    
    using namespace std;
    
    vector <vector <int> > g; // (edge vertex,edge weight)
    int n,m; // The number of vertices
    int connected_comp = 0;
    vector<int> conn_val(100000,0);
    int value = 1;
    int ans2 = 0;
    vector <bool> used;
    
    void dfs (int v) {
       // cout << v << "" "";
    	used [v] = true;
    	for (auto i=g[v].begin (); i!=g [v].end (); ++ i)
    		if (! used [*i])
            {
                value++;
    			dfs (*i);
    
            }
    
          //  cout<<""\n for v = ""<<v <<"" value = ""<<value<<endl;
    
    }
    
    int main () {
        //freopen(""input1.txt"",""r"",stdin);
        cin >> n >> m;
        used.resize(n+1);used.assign(used.size(),false);
        g.resize(n+1);
    
        vector<int> window(n+2,0);
    
        for(int i = 1; i <= n; i++)
        {
            int temp;
            cin>>temp;
            window[i] = temp;
        }
    
        for(int i=0,v1,v2;i<m;i++){
            cin >> v1 >> v2;
            if(window[v1] == 1 && window[v2] == 1)
            {
                //cout<<""here for v1 = ""<<v1<<"" v2 = ""<<v2<<endl;
                g[v1].push_back(v2);
                g[v2].push_back(v1); // (if undirected graph)
            }
    
        }
         long long ans = 0;
        //int source;
        //cin >> source;
        for(int i = 1; i <= n; i++)
        {
            if(used[i] == false){
                dfs(i);
                connected_comp++;
                //conn_val.push_back(value);
                ans = ans + (value * (value-1))/2;
                if(value > 1)
                    ans2 += value;
                value = 1;
            }
        }
    
    
        cout<<ans<<"" "" <<ans2<<endl;
    
        return 0;
    }
    

",C++
7228665,"
    #include<iostream>
    #include<vector>
    using namespace std;
    vector<vector<int> >a;
    vector<bool> visited;
    int arr[50001],note,count;
    int dfs(int u)
    {
        int i,v,r=0;
        visited[u]=1;
        for(i=0;i<a[u].size();i++)
        {
            v=a[u][i];
            if(!visited[v])
            {
                r+=dfs(v);
            }
        }
        if(arr[u]==1)
            count++;
        if(((r==0)&&(arr[u]==1)&&(u!=note))||(r))
            return r+1;
        else
            return r;
    }
    int main()
    {
        int n,m,i,x,y,ans2;
        long long int ans1;
        cin>>n>>m;
        count=ans2=ans1=0;
        visited=vector<bool> (n+1,0);
        a=vector<vector<int> > (n+1);
        for(i=1;i<=n;i++)
            cin>>arr[i];
        for(i=1;i<=m;i++)
        {
            cin>>x>>y;
            a[x].push_back(y);
            a[y].push_back(x);
        }
        for(i=1;i<=n;i++)
        {
            if(arr[i]==1)
            {
                note=i;
                count=0;
                ans2+=dfs(i);
                ans1+=(count*(count-1))/2;
            }
        }
        cout<<ans1<<' '<<ans2;
        return 0;
    }
    

",C++
4613310,"
    #include<stdio.h>
    
    int main()
    {
    	int n, m, c, t, l, i;
    	
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		int cnt = 0, si[101] = {0}, sf[101] = {0};
    		
    		scanf(""%d %d"",&n,&m);
    		while(n--)
    		{
    			scanf(""%d %d"",&c,&l);
    			si[l] += c;
    		}
    		while(m--)
    		{
    			scanf(""%d %d"",&c,&l);
    			sf[l] += c;
    		}
    		for(i = 1;i < 101;i++)
    		{
    			if(si[i] != 0 && sf[i] != 0)
    			{
    				if(si[i] >= sf[i])
    					si[i] -= sf[i];
    				else
    					cnt += sf[i] - si[i];
    			}
    		}
    		printf(""%d\n"",cnt);
    	}
    
    	return 0;
    }

",C
10090928,"
    #include <iostream>
    #include <vector>
    #include <map>
    #include <set>
    #include <stack>
    
    using namespace std;
    
    unsigned long long limit = 10;
    unsigned long long modulo = 1000000007;
    std::vector<std::pair<unsigned long long, unsigned long long> > streetValueProduct; 
    
    unsigned long long getMinProduct(unsigned long long a, unsigned long long b)
    {
        std::set<unsigned long long> sortedValues;
        
        for(unsigned long long i = a; i <= b; i++)
        {
            sortedValues.insert(streetValueProduct[i].second);
        }
        
        return *sortedValues.begin();
    }
    
    int main() {
        unsigned long long n,k;
        cin>>n>>k;
        
        streetValueProduct.reserve(n);
        
        for(unsigned long long i = 0; i < n; i++)
        {
            unsigned long long a;
            cin>>a;
            streetValueProduct.push_back(std::pair<unsigned long long, unsigned long long>(a, a));
        }
        
        unsigned long long i = n - 1;
        while(i > 0)
        {
            i--;
            
            int start = i + 1;
            int end = i + k;
            
            if(end > n - 1)
            {
                end = n - 1;
            }
            
            //product of i = v * smallest v( from i to i + k)
            streetValueProduct[i] = std::pair<unsigned long long, unsigned long long>(streetValueProduct[i].first, (streetValueProduct[i].first * getMinProduct(start, end)%modulo));
        
            if(i == 0)
            {
                break;
            }
        }
        
        cout<<streetValueProduct[0].second % modulo;
        
    	return 0;
    }
    

",C++
8980161,"
    #include<iostream>
    #include<vector>
    #include<stdio.h>
    #define mod 1000000007
    using namespace std;
    
    
    int fast_read()
    {
        char hld;
        int value=0;
        fread(&hld,1,1,stdin);
        while(!(hld>='0' && hld<='9')){fread(&hld,1,1,stdin);}
        while(hld>='0' && hld<='9'){value=(value<<3)+(value<<1)+(hld-'0');fread(&hld,1,1,stdin);}
        return value;
    }
    
    
    int main()
    {
    long long t,k,n,cnt1,cnt2,min_value;
    vector<long long> min_dist,street_value;
    
    n=fast_read();
    k=fast_read();
    for(t=0;t<n;t++)
    {
        street_value.push_back(fast_read());
    }
    
    min_dist.push_back(street_value[0]);
    for(cnt1=1;cnt1<n;cnt1++)
    {
    
        min_value=(street_value[cnt1]*min_dist[cnt1-1]);
        for(cnt2=cnt1-1;cnt2>=(cnt1-k)&&(cnt2>=0);cnt2--)
        {
            if(min_dist[cnt2]*street_value[cnt1]<=min_value){min_value=min_dist[cnt2]*street_value[cnt1];}
        }
    
        min_dist.push_back(min_value);
    
    }
    
    printf(""%lld\n"",(min_dist[n-1]%mod));
    return 0;
    }
    

",C++
8824164,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ChefTheWay {
    
    	private static final int MOD = 1000000007;
    	private int n; // total number of street
    	private int k; // K constraint value
    	private int home; // I live here
    	private Integer[] roads; // array of all the streets
    	private ArrayList<Integer> productList = new ArrayList<Integer>(); // selected minimum number street
    	
    	private Comparator<Integer> intComparator = new Comparator<Integer>() {	// for sorting array in desc
    		@Override
    		public int compare(Integer i1, Integer i2) {
    			return i2.compareTo(i1);
    		}
    	};
    	
    	private void getInput() { // getting input from console and setting the instance values
    		try {
    			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    			String tmp[] = br.readLine().split("" "");
    			this.n = Integer.parseInt(tmp[0]);
    			this.k = Integer.parseInt(tmp[1]);
    			tmp = br.readLine().split("" "");
    			roads = new Integer[n];
    			for(int i=0; i<n; i++) {
    				roads[i] = Integer.parseInt(tmp[i]);
    			}
    			this.home = roads[this.n-1];
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public int getHome() {
    		int product = 1;
    		getInput();
    		Arrays.sort(roads, intComparator); // sort in desc, may be not required, done anyway
    		productList.add(this.home); 
    		int pivot = this.home;
    		for(int i=roads.length-1; i>=0; i--) {
    			if(this.roads[i]<pivot && pivot-this.roads[i]==this.k) {
    				productList.add(this.roads[i]);
    				pivot = this.roads[i];
    			}
    		}
    		if(!productList.contains(this.roads[0])) {
    			productList.add(this.roads[0]);
    		}
    		for(int i : productList) {
    			product *= i; 
    		}
    		return product % MOD;
    	}
    	
    	public static void main(String[] args) {
    		System.out.println(""Minimum product : "" + new ChefTheWay().getHome());
    	}
    }
    

",JAVA
8252647,"
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Scanner;
    
     class ChefAndWay {
    
    	
    	static int pathValue=0;
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		int modulo=1000000007;
    Scanner scn =new Scanner(System.in);
    
    int noOfStreets=scn.nextInt();
    int specialValue=scn.nextInt();
    
    
    
    ArrayList<Integer> list=new ArrayList<Integer>();
    for(int i=0;i<noOfStreets;i++){
    	list.add(scn.nextInt());
    }
    
    if(noOfStreets==1){
    	System.out.println(list.get(0)%modulo);
    	System.exit(0);
    	
    }
    int startNode=list.get(0);
    
    int endNode=list.get(list.size()-1);
    
    
    Collections.sort(list);
    
    int startNodeIndex=list.indexOf(startNode);
    
    
    
    int endNodeIndex=list.indexOf(endNode);
    
    
    ArrayList<Integer> pathList=new ArrayList<Integer>();
    pathList.add(endNode);
    
    
    
    int lastIndex=pathList.size()-1;
    int i=endNodeIndex-1;
    
    
    for(;i>=startNodeIndex;i--){
    	
    	
    	if((pathList.get(pathList.size()-1)-list.get(i)<=specialValue)&&(pathList.get(pathList.size()-1)-list.get(i)>=1)){
    		continue;
    	}
    	
    	else{
    	
    		pathList.add(list.get(i+1));
    		
    		
    	}
    }
    
    pathList.add(startNode);
    int value=1;
    for(int j=0;j<pathList.size();j++)
    	value=value*pathList.get(j);
    System.out.println(value%modulo);
    
    
    	}
    
    }

",JAVA
8199301,"
    #include <stdio.h>
     #include<bits/stdc++.h>
     using namespace std;
    int main()
    {
      int n,k,a[100000],i,j;map<long long int,map<long long int,long long int> >s;
      scanf(""%d%d"",&n,&k);
      for(i=0;i<n;i++)
       for(j=0;j<n;j++)
         s[i][j]=0;
      for(i=0;i<n;i++)
        {scanf(""%d"",&a[i]);}
        
            for(i=0;i<n-1;i++)
             {  //printf("" sssd"");
                 for(j=i+1;j<=k+i;j++)
                   { 
                       if(j<n)
                       {   if(i!=0&&s[i-1][j]!=0)
                            s[i][j]=(((s[i-1][i]*a[j])% 1000000007)<s[i-1][j]?((s[i-1][i]*a[j])% 1000000007):s[i-1][j]);
                            else if(i!=0)
                              s[i][j]=((s[i-1][i]*a[j])% 1000000007);
                           else
                             s[i][j]=((a[i]*a[j])% 1000000007);
                       }
                   }
             }
             long long int min=1000000007;
            
              printf(""%lld"",s[n-2][n-1]);
      return 0;
    } 

",C++
8187545,"
    #include<stdio.h>
    int main(){
      int i=0,n,prod,k,d,a[100];
      scanf(""%d\t%d\n"",&n,&k);
      for(i=0;i<n;i++){
      scanf(""%d\t"",&a[i]);
      }
      d=a[0]*a[n-1];
      while(k>(a[i+2]-a[i+1])){
          if(a[i+1]<a[i+2])
          prod=d*a[i+1];
          else
          prod=d*a[i+2];
      }
      printf(prod);
    return 0;
    }
    

",C
7975730,"
    #include <iostream>
    #include <cassert>
    #include <cstdio>
    #include <algorithm>
    #include <cmath>
    #include <queue>
    using namespace std;
     
    #define mod (long int)1E9+7
    #define maxi (int)1E5
    #define lpfwd(i,l,r) for(i=l;i<r;i++)
    #define lbbkwd(i,l,r) for(i=r;i>=l;i--)
    int n, k, arr[maxi], i, helper[maxi];
    double dp[maxi];
    priority_queue<pair<double, int> > priorq;
     
    int main () {
      scanf(""%d%d"", &n, &k);  
      lpfwd(i,0,n)
       {
        scanf(""%d"", &arr[i]); 
      }
      dp[0]=log(arr[0]);
      helper[0]=arr[0];
      priorq.push(make_pair(-dp[0],0));
      lpfwd(i,1,n)
      {
        while(i-priorq.top().second>k)priorq.pop();
        dp[i]=log(arr[i])+(-priorq.top().first);
        helper[i]=(helper[priorq.top().second]*1LL*arr[i])%mod;
        priorq.push(make_pair(-dp[i],i));
      }
      printf(""%d\n"", helper[n - 1]); 
        return 0;
    }

",C++
7948353,"
    import java.util.*;
    class i
    {
    	static int f;
    	public static void main(String args[])
    	{
    		Scanner sc=new Scanner(System.in);
    		int count=0;
    		
    		int n=sc.nextInt();
    		
    		if(n>80)
    		{
    			System.out.println(""invalid input"");
    		}
    		else
    		{
    		int k=sc.nextInt();
    		Queue<Integer> a1=new LinkedList();
    		ArrayList<Integer> a2=new ArrayList();
    		ArrayList<Integer> a=new ArrayList();
    		
    		for(int i=0;i<n;i++)
    		{
    			int h=sc.nextInt();
    			a.add(h);
    			
    		}
    		
    		
    		for(int i=1;i<n;i++)
    		{
    		    int x1=a.get(0);
    			int x2=a.get(i);
    		if(x2-x1<=k && x2-x1>=1)
    			{
    				a1.add(x2);
    			}
    			
    		}
    
    		
    		do
    		{
    			int x=a1.poll();
    			for(int i=0;i<n;i++)
    			{
    		int x1=a.get(i);	
    	   if(x1-x<=k && x1-x>=1)
    		{
    			a1.add(x1); 
    		
    			int mul=x*x1;
    			if(a2.contains(mul))
    			{
    				
    				
    				count++;
    			
    				if(count==1){
    				f=a2.remove(0);
    				a2.add(f*x1);
    				}
    				
    		
    				if(count==2)
    				{
    					a2.add(0, f);
    					f=a2.remove(0);
    					a2.add(f*x1);
    					
    				}
    				
    			}
    			
    			else
    			{
    				a2.add(mul);
    			}
    		
    	
    		}
    	
    				
    	}	
    				
    			   count=0;		
    		}while(!a1.isEmpty());
    		
    		
    		
    		
    		
    		Collections.sort(a2);
    
    		System.out.println(a2.get(0));
    		
    
    		
    		}
    		
    		
    		
    	}
    }
    

",JAVA
7868819,"
    N, K = input().split()
    N = int(N)
    K = int(K)
    A = input().split()
    for i in range(0, N):
    	A[i] = int(A[i])
    
    for y in range(1, N):
    	x = y - K
    	if x < 0:
    		x = 0
    	A[y] *= min(A[x:y])
    
    print(A[N-1] % 1000000007)

",PYTH
7849683,"
    import java.io.*;
    import java.util.*;
    
    class ChefWay {
    	private static int minimumMultipleStreet(int n, int k) {
    		int count = n;
    		int currentPos = n;
    		while(currentPos > k) {
    			currentPos = currentPos-k;
    			count = count * currentPos;
    		}
    		return count;
    	}
    	
    	public static void main (String [] args) throws IOException {
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	    String[] values = br.readLine().split("" "");
    		int n = Integer.parseInt(values[0]);
    		int k = Integer.parseInt(values[1]);
    		
    		String[] streets = br.readLine().split("" "");
    		if(n==1) {
    			System.out.println(1);
    		} else {
    			System.out.println(minimumMultipleStreet(n,k));
    		}
    	}
    }
    
    

",JAVA
7626320,"
    import java.io.*;
    class ata
    {
        public static void main(String args[])  throws IOException
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            
            
                System.out.println(""enter no of streets k and special no.s"");
                int n=Integer.parseInt(br.readLine());
                 int k=Integer.parseInt(br.readLine());
                 int d=1,i,j,p;
                 int c;
                  int a[]=new int[n];
                  for(i=0;i<n;i++)
                  {
                     a[i]=Integer.parseInt(br.readLine());
                
        } 
        for(i=0;i<n;i++)
                  {
                     d=d*a[i];
                    }
                
        c=a[n-1];
        for(i=0;i<n-1;i++)
        {
            c=c*a[i];
            for(j=1;j<n-1;j++)
            {
                if(j-i<=k&&j-i>=1&&n-(j+1)<=k&&n-(j+1)>=1)
                {
                    p=c*a[j];
                    if(p<d)
                    {
                        d=p;
                    }
                }
            }
            
        }
        System.out.println(d);
    }
    }
        

",JS
7608249,"
    #include <iostream>
    using namespace std;
    
    int main() {
    	
    	long long int N=0,K=0,i=0,j=0,x=0,y=0,p=0,Sum=1,BestSum=1,Special[100000];
    	cin>>N;
    	cin>>K;
    	for(i=0;i<N;i++)
    	{
    	    cin>>Special[i];
    	}
    	for(i=0;i<N;i++)
    	{
    	    BestSum*=Special[i];
    	}
    	for(j=1;j<K;j++)
    	{
    	    for(x=0;x<K;x++)
    	    {
    	        for(p=1;p<=N;p++)
    	        {
    	            Sum=1;
    	            for(i=0;i<N-1;) 
    	            {
    	                Sum*=Special[i];
    	                if(int((i+1)/p)==1)
    	                {
    	                    y=x;
    	                }
    	                else
    	                {
    	                    y=0;
    	                }
    	                
    	                i=i+j+y;
    	 	        }
    	            Sum*=Special[N-1];
    	            if(Sum<BestSum)
    	            {
    	                BestSum=Sum;
    	            }    
    	            
    	        }
    	    }
    	}
    	cout<<BestSum%1000000007;
    	return 0;
    }
    

",C++
7544312,"
    #include <string.h>
    #include <stdio.h>
    #include <stdbool.h>
    
    #define MAX 100000
    #define MOD 1000000007
    
    long long int minProduct(long long int index,long long int K,long long int N,long long int *a){
    	long long int num = a[index];
    	if(index+K>=N-1){
    		return ((a[N-1]%MOD)*(num%MOD))%MOD;
    	}
    
    	long long int i;
    	long long int min = 0;
    	bool first = true;
    	for( i=index+1;i<N-1 && i - index<=K;i++ ){
    		int temp = minProduct(i,K,N,a);
    		if (first){
    			min = ((temp%MOD)*(num%MOD))%MOD;
    			first = false;
    		}else{
    			if(temp*num<min){
    				min = ((temp%MOD)*(num%MOD))%MOD;
    			}
    		}
    	}
    	return min%MOD;
    }
    
    
    int main(){
    	long long int N, K;
    	scanf(""%lli %lli\n"",&N,&K);
    
    	long long int a[N];
    	long long int i;
    	for(i=0;i<N;i++){
    		scanf(""%lli"",&a[i]);
    	}
    
    	long long int min = minProduct(0,K,N,a);
    	printf(""%lli"",min);
    	return 0;
    }
    

",C++
9642888,"
    import java.io.*;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] ar) throws IOException
        {
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	int t = Integer.parseInt(br.readLine());
    
    	for(int count=0; count<t; count++)
    	{
    	    String[] nm = br.readLine().split("" "");
    	    int m = Integer.parseInt(nm[1]);
    
    	    String[] strchains = br.readLine().split("" "");
    	    int[] chains = new int[m];
    
    	    for(int i=0; i<m; i++)
    		chains[i] = Integer.parseInt(strchains[i]);
    
    	    Arrays.sort(chains);
    
    	    int cuts = 0;
    	    int chainstart = 0;
    	    int chainend = chains.length-1;
    	    while(chainend - chainstart >= 2)
    	    {
    		cuts++;
    		chainend--;
    		chains[chainend] = chains[chainend+1] + chains[chainend] + 1;
    		if(chains[chainstart] == 1)
    		{
    		    chainstart++;
    		    // System.out.print(""First element 1: "");
    		    /* int[] newchains = new int[chains.length-2];
    		    newchains[newchains.length-1] = chains[chains.length-1] + chains[chains.length-2] + 1;
    		    System.arraycopy(chains, 1, newchains, 0, chains.length-3);
    		    chains = newchains; */
    		}
    		else
    		{
    		    chains[chainstart]--;
    		    // System.out.print(""First element not 1: "");
    		    /* int[] newchains = new int[chains.length-1];
    		    newchains[newchains.length-1] = chains[chains.length-1] + chains[chains.length-2] + 1;
    		    System.arraycopy(chains, 1, newchains, 1, chains.length-3);
    		    newchains[0] = chains[0]-1;
    		    chains = newchains; */
    		}
    		// System.out.println(Arrays.toString(chains));
    	    }
    
    	    if(chainend-chainstart == 1)
    		cuts++;
    
    	    System.out.println(cuts);
    	}
        }
    }
    

",JAVA
4163297,"
    #include<iostream>
    using namespace std;
    int main()
    {
    long int n,q,i,temp,j,count=0,x,y;
    cin>>n>>q;
    long int *a=new long int[n];
    for(i=1;i<=n;i++)
    {
    cin>>a[i];
    }
    while(q--)
    {
    cin>>x>>y;
    temp=a[x];
    a[x]=a[y];
    a[y]=temp;
    for(i=1;i<n;i++)
    {
    for(j=i+1;j<=n;j++)
    if(a[i]>a[j])
    {
    count++;
    }
    }
    cout<<(count%2)<<endl;
    }
    return 0;
    }

",C++
2072821,"
    #include<iostream>
    #include<stdio.h>
    #include<assert.h>
    #include<string.h>
    #include<time.h>
    #include<stdlib.h>
    #include<math.h>
    #include<string>
    #include<sstream>
    #include<map>
    #include<set>
    #include<queue>
    #include<stack>
    #include<vector>
    #include<algorithm>
    #pragma comment(linker, ""/STACK:16777216"")
    #define pb push_back
    #define ppb pop_back
    #define mp make_pair
    #define all(x) (x).begin(),(x).end()
    #define sz(x) (int)(x).size()
    #define LL long long
    #define bit __builtin_popcountll
    #define sqr(x) (x) * (x)
    using namespace std;
    typedef pair<int, int> pii;
    const double eps = 1e-9;
    const double pi = acos(-1.0);
    const int maxn = (int)1e6 + 10;
    LL A,B,G,pw[13];
    int n,m,c[13];
    map<LL, vector<int> > d;
    LL mul(LL a, LL b) {
    	LL res = 0;
    	while(b > 0) {
    		if (b & 1) {
    			res += a;
    			res %= B;
    		}
    		a += a;
    		a %= B;
    		b >>= 1;
    	}
    	return res;
    }
    LL binpow(LL a, LL b) {
    	LL res = 1;
    	while(b > 0) {
    		if (b & 1) {
    			res = mul(res,a);
    		}
    		a = mul(a,a);
    		b >>= 1;
    	}
    	return res;
    }
    void dfs(int p, LL mod) {
    	if (p == n) {
    		if (mod == G) {
    			for (int i = 0; i < n; i++) {
    				cout << c[i];
    			}
    			cout << endl;
    			exit(0);
    		}
    		return;
    	}
    	for (int i = 0; i < 10; i++) {
    		c[p] = i;
    		dfs(p + 1,(mul(mod,A) + i) % B);
    	}
    }
    void go(int p, LL mod) {
    	if (p == m) {
    		if (d.count(mod) == 0) {
    			vector<int> cur(m);
    			for (int i = 0; i < m; i++) {
    				cur[i] = c[i];
    			}
    			d[mod] = cur;
    		}
    		return;
    	}
    	for (int i = 0; i < 10; i++) {
    		c[p] = i;
    		go(p + 1,(mul(mod,A) + i) % B);
    	}
    }
    void doit(int p, LL mod) {
    	if (p == n) {
    		mod = mul(mod,pw[m]);
    		mod = G - mod + B;
    		mod %= B;
    		if (d.count(mod) != 0) {
    			for (int i = 0; i < n; i++) {
    				cout << c[i];
    			}
    			for (int i = 0; i < m; i++) {
    				cout << d[mod][i];
    			}
    			cout << endl;
    			exit(0);
    		}
    		return;
    	}
    	for (int i = 0; i < 10; i++) {
    		c[p] = i;
    		doit(p + 1,(mul(mod,A) + i) % B);
    	}
    }
    int main()
    {
    	//#ifndef ONLINE_JUDGE
    	//freopen(""input.txt"",""r"",stdin);
    	//freopen(""output.txt"",""w"",stdout);
    	//#endif	
         cin >> n;
         cin >> A >> B >> G;
         pw[0] = 1;
    	for (int i = 1; i <= 12; i++) {
    		pw[i] = mul(pw[i - 1],A);
    	}
         if (n <= 6) {
         	dfs(0,0);
         } else {
         	m = n - 6;
         	go(0,0);
         	doit(0,0);
         }
    	return 0;
    }
    

",C++
8663852,"
    #include <bits/stdc++.h>
    using namespace std;
    
    main(){
        int t;
        t = 0;
        cin>> t;
        while(t--){
            int ab[100001] = {0};
            string a;
            cin>>a;
            for(int i=0; i<=a.length()-1; i++){
                if(a[i] == 'L'){
                    ab[0]++;
                }
                if(a[i] == 'T'){
                    ab[1]++;
                }
                if(a[i] == 'I'){
                    ab[2]++;
                }
                if(a[i] == 'M'){
                    ab[3]++;
                }
                if(a[i] == 'E'){
                    ab[4]++;
                }
            }
            int flag = 0;
            for(int i=0; i<=4; i++){
                if(ab[i] < 2){
                    cout<<""NO""<<endl;
                    flag = 1;
                    break;
                }
            }
            if(flag == 0){
                cout<<""YES""<<endl;
            }
        }
    }
    

",C++
10248281,"
    #include<iostream>
    #include<queue>
    #include<string.h>
    #include<limits.h>
    using namespace std;
    
    int v[100100];
    int main()
    {
        string s;
        cin>>s;
        vector<int>adj1[10];
        int i;
        for(i=0;s[i]!='\0';i++)
        {
            adj1[s[i]-'0'].push_back(i);
        }
        queue<pair<int,int> >q;
        q.push(make_pair(0,0));
        int j=0;
        int ans=0;
        v[0]=1;
        while(!q.empty())
        {
            int t=q.front().first;
            j=q.front().second;
            q.pop();
            if(j>19)
            {
                q.pop();
                continue;
            }
            if(t==i-1)
            {
                ans=j;
                break;
            }
            if(s[t]==s[i-1])
            {
                ans=j+1;
                break;
            }
            int f=0;
            v[t]=1;
            if(t!=0)
               if(!v[t-1]) {q.push(make_pair(t-1,j+1));v[t-1]=1;}
            if(!v[t+1]) {q.push(make_pair(t+1,j+1));v[t+1]=1;}
            int k=0;
            for(k=0;k<adj1[s[t]-'0'].size();k++)
            {
                if(!v[adj1[s[t]-'0'][k]]) {q.push(make_pair(adj1[s[t]-'0'][k],j+1));v[adj1[s[t]-'0'][k]]=1;}
            }
        }
        cout<<ans<<endl;
        return 0;
    }
    

",C++
9178989,"
    #include <cstdio>
    #include <queue>
    #include <vector>
    #include <cstring>
    #include <string>
    #include <iostream>
    
    std::vector<int> node[10];
    std::queue<int> q;
    int distance[100006];
    bool visited[100006];
    
    int main() {
    //    char str[100006];
    //    scanf(""%s"", str);
        std::string str;
        std::cin>>str;
        int j;
        int length = str.size();
        for (j = 1; j<length; j++) {
            node[str[j] - '0'].push_back(j);
        }
    
        for (int i = 0; i < length; i++) {
            distance[i] = 0;
            visited[i] = false;
        }
        distance[0] = 0;
        visited[0] = true;
        q.push(0);
        while (!q.empty()) {
            int index = q.front();
    
            if (index == length - 1) {
                break;
            }
            q.pop();
            int value = str[index] - '0';
            int x = node[value].size();
            for (int i = 0; i < x; i++) {
                int next_index = node[value][i];
                if (!visited[next_index]) {
                    visited[next_index] = true;
                    q.push(next_index);
                    distance[next_index] = distance[index] + 1;
                }
            }
            if (index - 1 >= 0 && !visited[index - 1]) {
                visited[index - 1] = true;
                q.push(index - 1);
                distance[index - 1] = distance[index] + 1;
            }
            if (index + 1 < length && !visited[index + 1]) {
                visited[index + 1] = true;
                q.push(index + 1);
                distance[index + 1] = distance[index] + 1;
            }
        }
        printf(""%d\n"", distance[length - 1]);
        return 0;
    }
    

",C++
7974998,"
    #include <iostream>
    #include<vector>
    #include<queue>
    #include<algorithm>
    #include<stdio.h>
    #include<string.h>
    
    using namespace std;
    vector<int> adj[100001];
    vector<int> a[101];
    
    int dist[100001]={0};
    bool *visited;
    int BFS(int s,int x)
    {
    
    
        queue<int> Q;
    
    
        visited[s] = true;
        Q.push(s);
    
    
        vector<int>::iterator i;
    
        while(!Q.empty())
        {
    
            s = Q.front();
    
            Q.pop();
    
    
            for(i = adj[s].begin(); i != adj[s].end(); ++i)
            {
                if(!visited[*i])
                {
                    dist[*i]=dist[s]+1;
                    if((*i)==x) return dist[*i];
                    visited[*i] = true;
                    Q.push(*i);
    
                }
            }
    
    
        }
    
    }
    int main()
    {
        int i;
        dist[0]=0;
        char s[100001];
        cin>>s;
        int l=strlen(s);
    
    	visited = new bool[l+1];
        for(i = 1; i <=l; i++) visited[i] = false;
    	//printf(""%d"",l);
        for(i=0; i<l-1; i++)
        {
        	//printf(""%c "",s[i]);
    
            a[s[i]].push_back(i);
            adj[i].push_back(i+1);
            adj[i+1].push_back(i);
        }
        a[s[i]].push_back(i);
        /*vector<int>::iterator j;
        for(j = a[s[1]].begin(); j != a[s[1]].end(); ++j)
        {
        	cout<<*j<<"" "";
        }*/
    
        for(i=48; i<=57; i++)
        {
            if(a[i].size()>1)
            {
    
            for(int k=a[i].size()-1; k>=0; k--)
            {
                for(int q=k-1; q>=0; q--)
                {
                    //cout<<*j<<"" "";
                    if(a[i][q]!=a[i][k])
                    {
                        adj[a[i][k]].push_back(a[i][q]);
                        adj[a[i][q]].push_back(a[i][k]);
                    }
                }
               // adj[v[i][k]].erase(remove(adj[v[i][k]].begin(),adj[v[i][k]].end(),v[i][k
               // if()
                //w[*j].push_back(1);
            }
            }
        }
        /*vector<int>::iterator k;
        for(k = adj[1].begin(); k != adj[1].end(); ++k)
        {
        	cout<<*k<<"" "";
        }*/
       printf(""%d"",BFS(0,l-1));
    
        return 0;
    }
    

",C++
6353844,"
    #include<cstdio>
    #include<vector>
    #include<queue>
    #include<iostream>
    #include<cstring>
    
    using namespace std;
    
    int bfs(vector<vector<int> > B,string str,int n){
    	queue<int> q;
    	queue<int> len;
    	bool visited[n+1];
    	
    	for(int i=1;i<=n; i++)
    		visited[i] = false;
    	
    	q.push(1);
    	len.push(0);
    	visited[1] = true;
    	int cur;
    	
    	while(!q.empty()) {
    		int thisLen = len.front();
    		int i = q.front();
    		cur = i;
    		
    		if(cur == n) return thisLen;
    		else {
    			int temp = str[i-1] - '0';
    			for(int j=0; j<B[temp].size(); j++) {
    				if(visited[B[temp][j]] == false) {
    					if(B[temp][j] == n) return thisLen+1;
    					
    					visited[B[temp][j]] = true;
    					q.push(B[temp][j]);
    					len.push(thisLen+1);
    					
    				}
    			}
    			
    			B[temp].clear();
    			if(cur != 1) {
    				if(visited[i-1] == false) {
    					visited[i-1] = true;
    					q.push(i-1);
    					len.push(thisLen+1);
    				}
    			}
    			
    			if(visited[i+1] == false) {
    				visited[i+1] = true;
    				q.push(i+1);
    				len.push(thisLen+1);
    			}
    			
    			q.pop();
    			len.pop(); 
    		}
    	}
    	
    	return -1;
    }
    
    int main()
    {
    	vector<vector<int> > B(10);
    	char *str;
    	
    	scanf(""%s"",str);
    	int n = strlen(str);
    	
    	for(int i=0; i<n; i++) {
    		int y = str[i] - '0';
    		B[y].push_back(i+1);
    	}
    	
    	int res = bfs(B,str,n);
    	printf(""%d\n"",res);
    	
    	return 0;
    }
    

",C++
6066354,"
    #include <iostream>
    #include <queue>
    #include <string>
    using namespace std;
    #define MAX 100001
    int pos[10][MAX];
    int posIndex[10]={0};
    int adj[MAX];
    string s;
    int getAdjacentList(int n, int len){
    	int i,temp,k=-1;
    	if(n>0)
    		adj[++k]=n-1;
    	if(n<len-1)
    		adj[++k]=n+1;	
    	temp=(int)s[n]-48;
    	for(i=0;i<posIndex[temp];++i)
    		adj[++k]=pos[temp][i];
    	return ++k;
    }
    int BFS(int V){
    	bool visited[V], flag=false;
    	int jumps=0,n=0,i,j,prev[V];
    	int adjLen;
    	for(i=0;i<V;++i)
    		visited[i]=false;
    	
    	visited[n]=true;
    	queue<int> q1,q2;
    	q1.push(n);
    	while(!q1.empty() || !q2.empty()){
    		while(!q1.empty()){
    			n=q1.front();
    			q1.pop();
    			if(n==(V-1)){
    				flag=true;
    				break;
    			}
    			adjLen=getAdjacentList(n, V);
    			for(j=0;j<adjLen;++j){
    				if(adj[j]==(V-1)){
    					++jumps;
    					flag=true;
    					break;
    				}
    				if(!visited[adj[j]]){
    					visited[adj[j]]=true;
    					q2.push(adj[j]);
    				}
    			}
    			if(flag)
    				break;
    		}
    		if(flag)
    			break;
    		++jumps;
    		while(!q2.empty()){
    			n=q2.front();
    			q2.pop();
    			if(n==(V-1)){
    				flag=true;
    				break;
    			}
    			adjLen=getAdjacentList(n, V);
    			for(j=0;j<adjLen;++j){
    				if(adj[j]==(V-1)){
    					++jumps;
    					flag=true;
    					break;
    				}
    				if(!visited[adj[j]]){
    					visited[adj[j]]=true;
    					q1.push(adj[j]);
    				}
    			}
    			if(flag)
    				break;
    		}
    		if(flag)
    			break;
    		++jumps;
    	}
    	return jumps;
    }
    
    int main(){
    	int i,len,minJump=0,temp;
    	cin>>s;
    	len=s.length();
    	for(i=0;i<len;i++){
    		temp=(int)(s[i]-'0');
    		pos[temp][posIndex[temp]++]=i;
    	}
    	minJump=BFS(len);
    	cout<<minJump<<""\n"";
    	return 0;
    }
    

",C++
5888376,"
        #include<iostream>
        #include<string>
        #include<cstring>
        #include<queue>
        using namespace std;
        queue<int> q;
        bool vis[100004];
        int d[1000004];
        vector<int> V[10];
        int main()
        {
        string s;
        cin>>s;
        memset(vis, false, sizeof vis);
         
        int sz = s.size();
         
        for(int i=1;i<sz;i++)
        {
        int val = s[i]-'0';
        V[val].push_back(i);
        }
         
        d[0] = 0;
        vis[0] = true;
        q.push(0);
         
        while(!q.empty())
        {
        int idx = q.front();
        if(idx == sz-1)
        break;
        q.pop();
         
        int val = s[idx]-'0';
        int vsz = V[val].size();
        for(int j=0; j<vsz; j++)
        {
        int nidx = V[val][j];
        if(!vis[nidx])
        {
        vis[nidx] = true;
        q.push(nidx);
        d[nidx] = d[idx]+1;
        }
        }
        V[val].clear();
         
        if(idx-1 >=0 && !vis[idx-1])
        {
        vis[idx-1] = true;
        q.push(idx-1);
        d[idx-1] = d[idx] + 1;
        }
         
        if(idx+1<sz && !vis[idx+1])
        {
        vis[idx+1] = true;
        q.push(idx+1);
        d[idx+1] = d[idx] + 1;
        }
        }
         
        cout<<d[sz-1]<<endl;
        return 0;
        } 
    

",C++
4698120,"
    #include<iostream>
    #include<cstring>
    #include<vector>
    #include<queue>
    using namespace std;
    bool visited[100005];
    int dist[100005];
    queue<int> Q;
    vector<int> vec[10];
    char str[100005];
    int main()
    {
    	memset(visited,0,sizeof(visited));
    	scanf(""%s"",str);
    	int len = strlen(str);
    	for(int i=0;i<len;i++)
    	{
    		int val = str[i]-'0';
    		vec[val].push_back(i);
    	}
    	Q.push(0);
    	visited[0]=true;
    	dist[0]=0;
    	while(!Q.empty())
    	{
    		int id = Q.front();
    		if(id == len-1) break;
    		Q.pop();
    		int val = str[id]-'0';
    		int size = vec[val].size();
    		for(int j=0;j<size;j++)
    		{
    			int ni = vec[val][j];
    			if(!visited[ni])
    			{
    				visited[ni]=1;
    				Q.push(ni);
    				dist[ni] = dist[id]+1;
    			}
    		}
    		vector[val].clear();
    		if(id-1>=0 && !visited[id-1])
    		{
    			visited[id-1]=true;
    			Q.push(id-1);
    			dist[id-1] = dist[id]+1;
    		}
    		if(id+1<len && !visited[id+1])
    		{
    			visited[id+1]=true;
    			Q.push(id+1);
    			dist[id+1] = dist[id]+1;
    		}
    	}
    	printf(""%d"",dist[len-1]);
    }

",C++
11986265,"
    import java.io.*;
    import java.util.StringTokenizer;
    class COMM3
    {
    	public static void main(String args[])throws IOException
    	{
    		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    		int t=Integer.parseInt(br.readLine());
    		double[][] d=new double[3][2];
    		double d1=0, d2=0, d3=0, r=0;
    		StringTokenizer st;
    		for(int j=1;j<=t;j++)
    		{
    			r=Double.parseDouble(br.readLine());
    			for(int i=0;i<3;i++)
    			{
    				st=new StringTokenizer(br.readLine());
    				d[i][0]=Double.parseDouble(st.nextToken());
    				d[i][1]=Double.parseDouble(st.nextToken());
    			}
    			d1=getDistance(d[0][0], d[0][1], d[1][0], d[1][1]);
    			d2=getDistance(d[1][0], d[1][1], d[2][0], d[2][1]);
    			d3=getDistance(d[2][0], d[2][1], d[0][0], d[0][1]);
    
    			if(check(d1, d2, d3, r)) System.out.println(""yes"");
    			else System.out.println(""no"");
    		}
    
    
    	}
    
    	static boolean check(double d1, double d2, double d3, double r)
    	{
    		int f=0;
    		if(d1<=r) f++;
    		if(d2<=r) f++;
    		if(d3<=r) f++;
    		return f>=2;
    	}
    
    	static double getDistance(double x1, double y1, double x2, double y2)
    	{
    		double k=Math.pow(x1-x2, 2);
    		double l=Math.pow(y1-y2, 2);
    		return Math.sqrt(k+l);
    	}
    }

",JAVA
11536179,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Main {
    
    	public static void main(String[] args) throws NumberFormatException, IOException{
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		int t = Integer.parseInt( br.readLine());
    		while(t-->0){
    		int r = Integer.parseInt(br.readLine());
    		int R = r*r;   int[] x = new int[3]; int[] y = new int[3];
    		for (int i = 0; i <3; i++) {
    			x[i] = Integer.parseInt(br.readLine());
    			y[i] = Integer.parseInt(br.readLine());            
    		}
    		int d12 = (x[0]-x[1])*(x[0]-x[1])+(y[0]-y[1])*(y[0]-y[1]);
    		int d23 = (x[1]-x[2])*(x[1]-x[2])+(y[1]-y[2])*(y[1]-y[2]);
    		int d13 = (x[0]-x[2])*(x[0]-x[2])+(y[0]-y[2])*(y[0]-y[2]);	
    			if (d12<=R || d23<=R) {
    				if(d13<=R || d12<=R){
    					if(d13<=R || d23<=R){System.out.println(""yes"");}
    					else{System.out.println(""no"");}
    				}
    				else{
    					System.out.println(""no"");
    				}
    			}else{System.out.println(""no"");}
    		}
    	}
    }
    

",JAVA
11173365,"
    #include<iostream>
    #include<math.h>
    using namespace std;
    
    int main()
    {
    
            int t,m,n,o;
            int a[2],b[2],c[2],r;
            cin>>t;
            while(t--)
            { int i=0;
              cin>>r;
               while(i<2)
               {
                   cin>>a[i]>>a[i+1];
                   cin>>b[i]>>b[i+1];
                   cin>>c[i]>>c[i+1];
                   i=i+2;
               }
               m=pow(((pow((a[0]-b[0]),2))+pow((a[1]-b[1]),2)),0.5);
               n=pow(((pow((a[0]-c[0]),2))+pow((a[1]-c[1]),2)),0.5);
               o=pow(((pow((b[0]-c[0]),2))+pow((b[1]-c[1]),2)),0.5);
               if(m==n==o<=r)
                cout<<""yes\n"";
               else
                cout<<""no\n"";
            }
    return 0;
    }
    

",C++
7268123,"
    #include<conio.h>
    #include<iostream.h>
    #include<math.h>
    int main(){
    	clrscr();
    	int n,i,j,t,x[3],y[3],flag[100];
    	float d[3];
    	cin>>n;
    	for(i=0;i<n;i++){
    	       cin>>t;
    	       for(j=0;j<3;j++){
    			cin>>x[j];
    			cin>>y[j];
    	       }
    	       d[0]=sqrt(pow((x[0]-x[1]),2)+pow((y[0]-y[1]),2));
    	       d[1]=sqrt(pow((x[0]-x[2]),2)+pow((y[0]-y[2]),2));
    	       d[2]=sqrt(pow((x[2]-x[1]),2)+pow((y[2]-y[1]),2));
    	       cout<<d[0]<<"" ""<<d[1]<<"" ""<<d[2];
    	       flag[i]=0;
    	       if(d[0]>t){
    			if(d[1]>t || d[2]>t){
    				flag[i]=1;
    			}
    	       }
    	       if(d[1]>t){
    			if(d[2]>t || d[0]>t){
    				flag[i]=1;
    			}
    	       }
    	       if(d[2]>t){
    			if(d[1]>t || d[0]>t){
    				flag[i]=1;
    			}
    	       }
    	}
    	for(i=0;i<n;i++){
    		if(flag[i]==1){
    			cout<<""\nno"";
    		}
    		else{
    			cout<<""\nyes"";
    		}
    	}
    	getch();
    	return 0;
    }

",C++
5478974,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		int xa,ya,xb,yb,xc,yc;
    		int r;
    		cin>>r;
    		cin>>xa>>ya>>xb>>yb>>xc>>yc;
    		double t1=(xa-xb)*(xa-xb)+(ya-yb)*(ya-yb);
    		double t2=(xb-xc)*(xb-xc)+(yc-yb)*(yc-yb);
    		double t3=(xa-xc)*(xa-xc)+(xa-xc)*(xa-xc);
    		if((t1<=r*r && (t2<=r*r||t3<=r*r)) ||(t2<=r*r && (t3<=r*r||t1<=r*r))||(t3<=r*r && (t2<=r*r||t1<=r*r)))
    		{
    			cout<<""yes""<<endl;
    		}
    		else
    		cout<<""no""<<endl;
    	}
    }

",C++
4966912,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    
    public class Main 
    {
    
        public static void main(String[] args) throws IOException 
        {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            
            PrintWriter out = new PrintWriter(System.out);
            
            int T = Integer.parseInt(reader.readLine());
            
            while(T>0)
            {
                int R = Integer.parseInt(reader.readLine());
                
                int c_xy[] = new int[2];
                
                int hs_xy[] = new int[2];
                
                int sc_xy[] = new int[2];
                
                String a[] = reader.readLine().split("" "");
                
                for(int i=0 ;i<2;i++)
                {
                    c_xy[i] = Integer.parseInt(a[i]);
                }
                
                String b[] = reader.readLine().split("" "");
                
                for(int i=0 ;i<2;i++)
                {
                    hs_xy[i] = Integer.parseInt(b[i]);
                }
                
                String c[] = reader.readLine().split("" "");
                
                for(int i=0 ;i<2;i++)
                {
                    sc_xy[i] = Integer.parseInt(c[i]);
                }
                
                if(Math.sqrt(Math.pow(c_xy[0]-hs_xy[0],2))+Math.pow(c_xy[1]-hs_xy[1],2)<=R && Math.sqrt(Math.pow(hs_xy[0]-sc_xy[0],2))+Math.pow(hs_xy[1]-sc_xy[1],2)<=R )
                {
                    out.println(""yes"");
                }
                
                else if(Math.sqrt(Math.pow(c_xy[0]-sc_xy[0],2))+Math.pow(c_xy[1]-sc_xy[1],2)<=R && Math.sqrt(Math.pow(sc_xy[0]-hs_xy[0],2))+Math.pow(sc_xy[1]-hs_xy[1],2)<=R)
                {
                    out.println(""yes"");
                }
                
                else
                    out.println(""no"");
                T--;
            }
            
            out.close();
        }
    }
    

",JAVA
4379455,"
    #include<stdio.h>
    #include<math.h>
    int main()
    { int tstcse;
      int x1,x2,x3;
      int y1,y2,y3;
      int r,i;
      scanf(""%d"",&tstcse);
      for(i=0;i<tstcse;i++)
      {scanf(""%d"",&r);
       scanf(""%d"",&x1);
       scanf(""%d"",&y1);
       scanf(""%d"",&x2);
       scanf(""%d"",&y2);
       scanf(""%d"",&x3);
       scanf(""%d"",&y3);
      if(sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))<=r)
       { if(sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3))<=r)
          printf(""yes\n"");
          else
          printf(""no\n"");
       }
      }
    }

",C
767739,"
    #include<stdio.h>
    #include<math.h>
    int main()
    {
    int R;
    int X[3],Y[3],i,T;
    scanf(""%d"",&T);
    while(T--)
    {
    	scanf(""%d"",&R);
    	for(i=0;i<3;i++)
    		scanf(""%d%d"",&X[i],&Y[i]);
    //	printf(""%lf "",sqrt(pow((X[0]-X[1]),2)+pow((Y[0]-Y[1]),2)));
    	if(((sqrt(pow((X[1]-X[2]),2)+pow((Y[1]-Y[2]),2))<=R)||(sqrt(pow((X[0]-X[2]),2)+pow((Y[0]-Y[2]),2))<=R)))
    	{
    		if((sqrt(pow((X[0]-X[1]),2)+pow((Y[0]-Y[1]),2))<=R)||(sqrt(pow((X[0]-X[2]),2)+pow((Y[0]-Y[2]),2))<=R))
    		{
    			printf(""yes\n"");
    		}
    		else
    		printf(""no\n"");
    	}
    	else
    		printf(""no\n"");
    }
    return 0;
    }

",C
575840,"
    #include <stdio.h>
    #include <math.h> 
    
    typedef unsigned int UINT;
    
    int main ()
    {
        //freopen(""in.txt"", ""r"", stdin);
    	//freopen(""out.txt"", ""w"", stdout);   
    	UINT t;
    	int x1,y1,x2,y2,x3,y3,i,j;
    	float d,a,b,c,r;
    	scanf (""%u"", &t);
    	while (t--) {
    		scanf (""%f"", &r);
    		scanf (""%d %d"", &x1, &y1);
    		scanf (""%d %d"", &x2, &y2);
    		scanf (""%d %d"", &x3, &y3);
    		a =  sqrt ( ( (x2-x1)*(x2-x1) ) + ( (y2-y1)*(y2-y1) ));
    		b =  sqrt ( ( (x3-x1)*(x3-x1) ) + ( (y3-y1)*(y3-y1) ));
    		c =  sqrt ( ( (x2-x3)*(x2-x3) ) + ( (y2-y3)*(y2-y3) ));
    		if ( (a<=r && b<=r) || (a <=r && c <=r) || (b<=r && c<=r) ) {
    			printf (""yes\n"");
    		}
    		else {
    			printf (""no\n"");
    		}
    	}
        return 0;
    }
    

",C
3912301,"
    #include <iostream>
    #include <string>
    #include <stdlib.h>
    #include <limits.h>
    #include <algorithm>
    using namespace std;
    
    
    typedef struct MODIFICATION {
      int pos;
      int change;
      
      bool operator<(MODIFICATION x) const
      {
        return pos<x.pos;
      }
    } MODIFICATION;
    
    MODIFICATION ms[20001];
    
    int compare (const void * a, const void * b)
    {
      return ( (*(MODIFICATION*)a).pos - (*(MODIFICATION*)b).pos );
    }
    
    int main()
    {
      int t, n, s;
      cin>>t;
    
      while(t--)
      {
          int w, x, y, z;
        int s;
        cin>>s>>n;
        int mn = 1;
        int mx = s;    
        for(int i=0;i<n;i++)
        {
          cin>>w;
          cin>>x;
          cin>>y;
          cin>>z;
          
          if(w==2)
    	z = -z;
          
          ms[2*i].pos = x;
          ms[2*i].change = z;
          
          ms[2*i+1].pos = y+1;
          ms[2*i+1].change = -z;
        }
       
       
       
          sort(ms, ms+(2*n));
          
          int val=0;
          int cur=1;
          for(int i=0;i<2*n;i++)
          {
    	if(ms[i].pos > cur){
    	mn = min(mn, cur+val);
    	mx = max(mx , ms[i].pos-1+val);
    	cur = ms[i].pos;
    	}
    	val+=ms[i].change;
    	
          }
          
          cout<<(mx-mn)<<endl;
      }
      
      
      return 0;
    }
    

",C++
1257594,"
    #include<iostream>
    #include<memory.h>
    #include<assert.h>
    using namespace std;
    long long d[1000001],temp;
    int main()
    {
    	long long t,n,m,w,x,y,z,i;
    	long long low,high;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d%d"",&n,&m);
    		while(m--)
    		{
    			scanf(""%d%d%d%d"",&w,&x,&y,&z);
    			if(w==1)
    			{
    				d[x-1]+=z;
    				d[y]-=z;
    			}
    			else
    			{
    				d[x-1]-=z;
    				d[y]+=z;
    			}
    		}
    		low=d[0];high=d[0];temp=0;
    		for(i=1;i<=n;i++)
    		{
    			temp=d[i-1]+1+temp;
    			d[i-1]=0;
    			low=min(low,temp),high=max(high,temp);
    		}
    		printf(""%lld\n"",high-low);
    	}
    }

",C++
10818699,"
    #include<bits/stdc++.h>
    using namespace std;
    long long int min(long long int a,long long int b){
        return a<b?a:b;}
    long long int diff(long long int a,long long int b){
        return abs(a-b);
    }
    int main(){
    	long long int k,temp,a,b,t,n;
    	cin>>t;
    	while(t--){
    		cin>>n>>k;
    		long long int sum=0;
    		for(int i=0;i<n;i++){
    			cin>>temp;
    			sum+=min(diff(temp,k*(temp/k)),diff(temp,k*((temp/k)+1)));//  cout<<sum<< ""  <>  "";
    		}                                                               // cout<<endl;
    		cout<<sum<<endl;
    	}
    	return 0;
    }

",C++
10491945,"
    #include<stdio.h>
    main()
    {
    	long long int t,n,k,x,i,s,j,y;
    	scanf(""%lld"",&t);
    	for(i=0;i<t;i++)
    	{
    		s=0;
    		scanf(""%lld %lld"",&n,&k);
    		for(j=0;j<n;j++)
    		{
    			scanf(""%lld"",&x);
    			if(x<k)
    			s=s+(k-x);
    			else
    			{
    				y=x%k;
    				if(y!=0)
    				{
    					if(y > (k-y))
    					s=s+(k-y);
    					else
    					s=s+y;
    				}
    			}
    		}
    		printf(""%lld\n"",s);
    	}
    	return 0;
    }

",C
8379860,"
    #include<iostream>
    #include<stdio.h>
    #include<limits.h>
     
    #define fi(i, a, b) for(i = a; i < b; i++)
    #define fd(i, a, b) for(i = a; i > b; i--)
     
    using namespace std;
     
    int main()
    {
    	int t, i, n, min, a;
    	scanf(""%d"", &t);
    	while(t--)
    	{
    		min = INT_MAX;
    		scanf(""%d"", &n);
    		fi(i, 0, n)
    		{
    			scanf(""%d"", &a);
    			if(a < min)
    				min = a;
    		}
    		printf(""%lld\n"", min * (n - 1));
    	}
    	return 0;
    }

",C++
521377,"
    /*
     * Author: hanshuai
     * Created Time:  2011-4-14 14:06:07
     * File Name: evenpoly.cpp
     */
    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <algorithm>
    #include <vector>
    #include <cctype>
    #include <cassert>
    using namespace std;
    const int maxn = 55;
    typedef int MT;
    //transport the top digit.
    const MT mask = 0x20000035;
    int n;
    char buf[105];
    string s[maxn][maxn];
    MT m[maxn][maxn];
    MT X[26];
    MT mul(MT t1, MT t2){
        MT ret = 0;
        while(t1){
            if(t1&1) ret ^= t2;
            t1 >>= 1;
            t2 <<= 1;
            if((t2^mask) < t2) t2 ^= mask;
        }
        return ret;
    }
    MT myRand(){
        MT ret = 0;
        while((ret^mask) > ret) ret = (ret<<1)|(rand()%2);
        return ret^mask;
    }
    void output(){
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                printf(""% 9d"", m[i][j]);
            }
            printf(""\n"");
        }
    }
    bool isDetZero(){
        for(int i = 0; i < n; i ++){
            int id = -1;
            for(int j = i; j < n; j ++){
                if(m[j][i] != 0){
                    id = j; break;
                }
            }
            //output();
            if(id == -1) return true;
            for(int k = 0; k < n; k ++) swap(m[i][k], m[id][k]);
            for(int j = i + 1; j < n; j ++){
                MT t1 = m[i][i], t2 = m[j][i];
                for(int k = 0; k < n; k ++){
                    m[j][k] = mul(m[j][k], t1) ^ mul(m[i][k], t2);
                }
            }
        }
        //printf(""isF\n"");
        return false;
    }
    bool ok(){
        for(int i = 0; i < 26; i ++){
            X[i] = myRand();
            //printf(""%d "", X[i]);
        }
        //printf(""\n"");
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                m[i][j] = 0;
                int p = 1;
                for(int k = 0; k < (int)s[i][j].size(); k ++){
                    char c = s[i][j][k];
                    if(c == '+'){
                        m[i][j] ^= p;
                        p = 1;
                    }else if(c == '0') p = 0;
                    else if(c == '1') p = 1;
                    else{
                        assert(islower(c));
                        p = mul(p, X[c-'a']);
                    }
                }
            }
        }
        return isDetZero();
    }
    int main() {
        srand(234);
        int test;
        scanf(""%d"", &test);
        while(test --){
            scanf(""%d"", &n);
            for(int i = 0; i < n; i ++){
                for(int j = 0; j < n; j ++){
                    scanf(""%s"", buf);
                    s[i][j] = string(buf) + ""+"";
                }
            }
            bool over = false;
            for(int i = 0; i < 1; i ++){
                if(!ok()){
                    over = true; break;
                }
            }
            printf(""%s\n"", over ? ""Some Odd"" : ""All Even"");
        }
        return 0;
    }
    
    

",C++
11704717,"
    #include<bits/stdc++.h>
    using namespace std;
    int countF;
    int dis(char ch[][1000],int n,int i,int j,int count)
    {
    	if(i==n-1)
    	{
    		if(count>countF)
    		countF=count;
    	}
    	if(i<n)
    	{
    		if(ch[i][j]=='P')
    		count++;
    		dis(ch,n,i+2,j+1,count);
    		dis(ch,n,i+1,j+2,count);
    	}
    	
    }
    int main()
    {
    	char ch[1000][1000];
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		int n;
    		cin>>n;
    		for(int i=0;i<n;i++)
    		{
    			for(int j=0;j<n;j++)
    			{
    				cin>>ch[i][j];
    			}
    		}
    		countF=INT_MIN;
    		dis(ch,n,0,0,0);
    		cout<<countF+1<<endl;
    	}
    }

",C++
4105185,"
    //#include<conio.h>
    #include<stdio.h>
    #include<cstring>
    #include<iostream>
    #include<cstdlib>
    #include<algorithm>
    #include<vector>
    #include<sstream>
    #include<climits>
    #include<math.h>
    #include<utility>
    #include<cstdlib>
    #include<queue>
    #include<functional>
    using namespace std;
    int n;
    /*struct name
    {
           int x;
           int y;
    };*/
    bool isvalid(int a, int b)
    {
         if(a<n&&b<n&&a>=0&&b>=0)
         return true;
         return false;
    }
    char str[1007][1007];                    
    int main ()
    {
        int t,i,j,out=0;
       int vstd[1007][1007],max1;
        scanf(""%d"",&t);
        while(t--)
        {
                  out=0;
                 //memset(vstd,-1,sizeof(pawn));
                  scanf(""%d"",&n);
                  for(i=0;i<n;i++)
                  {
                                  for(j=0;j<n;j++)
                                  {
                                                  cin>>str[i][j];
                                                  if(j==n-1)
                                                  vstd[i][j]=0;
                                                  else
                                                  vstd[i][j]=-1;
                                  }
                  }
                  for(i=n-1;i>=0;i--)
                  {
                                  for(j=0;j<n;j++)
                                  {
                                                  max1=0;
                                                  if(str[j][i]=='P')
                                                  max1=1;
                                                  if(isvalid(j+2,i-1))
                                                  {                   //cout<<j+2<<i-1<<"" ""<<vstd[j+2][i-1]<<endl;
                                                                      vstd[j+2][i-1]=max(max1+vstd[j][i],vstd[j+2][i-1]);
                                                                      //cout<<max1<<endl;
                                                  }
                                                  if(isvalid(j-2,i-1))
                                                  vstd[j-2][i-1]=max(max1+vstd[j][i],vstd[j-2][i-1]);
                                                  if(isvalid(j+1,i-2))
                                                  vstd[j+1][i-2]=max(max1+vstd[j][i],vstd[j+1][i-1]);
                                                  if(isvalid(j-1,i-2))
                                                  vstd[j-1][i-2]=max(max1+vstd[j][i],vstd[j-1][i-2]);
                                                  if(str[j][i]=='K')
                                                  {
                                                                    cout<<vstd[j][i]<<""\n"";
                                                                    out=1;
                                                                    break;
                                                  }
                                  }
                                   if(out==1)
                                   break;
                  }
                  //cout<<temp1<<temp2;
                  //cout<<<<endl;
        }
        //getch();
        return 0;
    }
                           
                                  
                  
    

",C++
3932421,"
    #include<iostream>
    using namespace std;
    char chess[1003][1003];
    int mov[1003][1003];
    int main()
    {
        int t,N,i,j,bs,maxi,ii,jj;
        cin>>t;
        while(t--)
        {
               cin>>N;
               for(i=0;i<N;i++)
               {
                   for(j=0;j<N;j++)
                   {
                       cin>>chess[i][j];
                       if(chess[i][j]=='K')
                       { ii=i;jj=j; }
                       mov[i][j]=0;
                   }
               }
               maxi=0;
               for(j=jj;j<N;j++)
               {
                  for(i=ii;i<N;i++)
                  {
                      bs=0;
                      if(chess[i][j]=='P')     mov[i][j]=1;
                      if(j-2>=0 && i-1>=0)
                      {
                           if(chess[i-1][j-2]=='K')
                           {
                               bs=max(bs,mov[i-1][j-2]);
                               chess[i][j]='K';
                           }
                      }
                      
                      if(j-2>=0&&i+1<N)
                      {
                           if(chess[i+1][j-2]=='K')
                           {
                               bs=max(bs,mov[i+1][j-2]);
                               chess[i][j]='K';
                           }
                      }
                      
                      if(j-1>=0&&i-2>=0)
                      {
                           if(chess[i-2][j-1]=='K')
                           {
                               bs=max(bs,mov[i-2][j-1]);
                               chess[i][j]='K';
                           } 
                      }
                      
                      if(j-1>=0&&i+2<N)
                      {
                           if(chess[i+2][j-1]=='K')
                           {
                               bs=max(bs,mov[i+2][j-1]);
                               chess[i][j]='K';
                           }
                      }
                      mov[i][j]+=bs;
                      maxi=max(maxi,mov[i][j]);
                  }
               }
               cout<<maxi<<endl;
        }
        return 0;
    }
    

",C++
3802934,"
    #include<stdio.h>
    int max(int a,int b)
    {
    	if(a>b)
    	return a;
    	else
    	return b;
    }
    int main()
    {
    	int t,a[1010][1010],maximum,i,j,n,pox,poy,k;
    	char str[1010][1010];
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d"",&n);
    		getchar();
    		for(i=1;i<=n;i++)
    		{
    		for(j=1;j<=n;j++)
    		{
    			scanf(""%c"",&str[i][j]);
    			if(str[i][j]=='K')
    			{
    				pox=i;
    				poy=j;
    			}
    		}
    		getchar();
    		}
    		//getchar();
    		for(i=1;i<=n;i++)
    		{
    		for(j=1;j<=n;j++)
    		{
    		a[i][j]=0;
    		}
    		}
    		a[pox][poy]=1;
    		for(j=1;j<=n;j++)
    		{
    			for(i=1;i<=n;i++)
    			{
    				if(a[i][j])
    				{
    					if(((i+2)<=n)&&((j+1)<=n))
    					{
    						if(str[i+2][j+1]=='P')
    						{//a[i+2][j+1]=a[i][j]+1;
    						k=a[i+2][j+1];
    						a[i+2][j+1]=max(a[i][j]+1,k);
    						}
    						else
    						a[i+2][j+1]=a[i][j];
    					}
    					if(((i-2)>=1)&&((j+1)<=n))
    					{
    						if(str[i-2][j+1]=='P')
    						{
    						//a[i-2][j+1]=a[i][j]+1;
    						k=a[i-2][j+1];
    						a[i-2][j+1]=max(a[i][j]+1,k);
    						}
    						else
    						a[i-2][j+1]=a[i][j];
    					}
    					if(((i+1)<=n)&&((j+2)<=n))
    					{
    						if(str[i+1][j+2]=='P')
    						{//a[i+1][j+2]=a[i][j]+1;
    						k=a[i+1][j+2];
    						a[i+1][j+2]=max(a[i][j]+1,k);
    						}
    						else
    						a[i+1][j+2]=a[i][j];
    					}
    					if(((i-1)>=1)&&((j+2)>=n))
    					{
    						if(str[i-1][j+2]=='P')
    						{
    						//a[i-1][j+2]=a[i][j]+1;
    						k=a[i-1][j+2];
    						a[i-1][j+2]=max(a[i][j]+1,k);
    						}
    						else
    						a[i-1][j+2]=a[i][j];
    					}
    				}
    			}
    		}
    		/*for(i=1;i<=n;i++)
    		{
    			for(j=1;j<=n;j++)
    			{
    				printf(""%d%c   "",a[i][j],str[i][j]);
    			}
    			printf(""\n"");
    		}*/
    		maximum=0;
    		for(j=1;j<=n;j++)
    		{
    			for(i=1;i<=n;i++)
    			{
    				if(a[i][j]>maximum)
    				maximum=a[i][j];
    			}
    		}
    		printf(""%d\n"",maximum-1);
    	}
    	return 0;
    } 

",C
584965,"
    #include<stdio.h>
    char s[1010][1010];
    int a[1010][1010];
    main()
    {
        int t,n;
        scanf(""%d"",&t);
        for(int l=0;l<t;l++)
        {
            
            scanf(""%d"",&n);
            for(int i=2;i<n+2;i++) scanf(""%s"",s[i]);
            for(int i=2;i<n+2;i++)
            {
                if(s[i][n-1]=='P') a[i][n-1]=1;
                else a[i][n-1]=0;
                //printf(""%d\n"",a[i][n-1]);
            }
            for(int i=n-2;i>=0;i--)
            {
                for(int j=2;j<n+2;j++)
                {
                    a[j][i]=a[j+2][i+1];
                    if(a[j][i]<a[j-2][i+1]) a[j][i]=a[j-2][i+1];
                    if(a[j][i]<a[j-1][i+2]) a[j][i]=a[j-1][i+2];
                    if(a[j][i]<a[j+1][i+2]) a[j][i]=a[j+1][i+2];
                    if(s[j][i]=='P') a[j][i]++;
                }
                //for(int k=2;k<n+2;k++) b[k]=a[k];
            }
            /*for(int i=2;i<n+2;i++)
            {
                for(int j=0;j<n;j++)
                {
                    printf(""%d "",a[i][j]);
                }
                printf(""\n"");
            }
            //printf(""===%d\n\n"",a[2][2]);
            for(int j=2;j<n+2;j++)
            {
                a[j][0]=a[j+2][1];
                if(a[j][0]<a[j-2][1]) a[j][0]=a[j-2][1];
                if(s[j][0]=='P') a[j][0]++;
            }*/
            for(int i=2;i<n+2;i++) if(s[i][0]=='K')
            {
                printf(""%d\n"",a[i][0]);
                break;
            }
        }
        scanf("" "");
    }
    

",C++
11256407,"
    #include <iostream>
    #include <cstdio>
    #include <algorithm>
    #include <cmath>
    using namespace std;
    
    bool isOkay(int *arr, int n);
    
    int main()
    {
        int t;
        cin>>t;
    
        int n;
        long long int total;
        long long int cost;
        int difference, realDiff;
        bool trueFalse;
        int counter;
    
        for(int l=0;l<t;l++)
        {
            cin>>n;
    
            int arr[n];
            total = 0;
    
            for(int i=0;i<n;i++)
            {
                cin>>arr[i];
                total+=arr[i];
            }
    
            if(total%n!=0)
            {
                cout<<""-1""<<endl;
            }
            else
            {
                sort(arr,arr+n);
                cost = 0;
                counter = n-1;
                for(int i=0;i<n;i++)
                {
                    difference = (double)arr[counter] - (double)arr[i];
                    difference = difference/2;
                    realDiff = ceil(difference);
    
                    if(arr[i]!=arr[counter]&&i!=counter)
                    {
                        cost++;
                        arr[counter]-=realDiff;
                        arr[i]+=realDiff;
                    }
    
                    counter--;
    
                    if(i==counter)
                    {
                        break;
                    }
                }
    
                if(isOkay(arr,n))
                {
                    trueFalse = true;
                }
    
                if(trueFalse)
                {
                    cout<<cost<<endl;
                }
                else
                {
                    cout<<""-1""<<endl;
                }
            }
        }
    }
    
    
    
    bool isOkay(int *arr, int n)
    {
        int result = arr[0];
    
        for(int i=1;i<n;i++)
        {
            if(arr[i]!=result)
            {
                return false;
            }
        }
    
        return true;
    }
    

",C++
3645590,"
    #include<stdio.h>
    #include<math.h>
    int cmp(const void* e1,const void* e2){
    return *(int*)e1-*(int*)e2;
    }
    int idli[3001];
    int main(){
    int no,i,N,min,max,max_index,min_index,xfer,flag,count;
    scanf(""%d"",&no);
    while(no--){
    scanf(""%d"",&N);
    for(i=0;i<N;i++){
    scanf(""%d"",&idli[i]);
    }
    count=0;
    flag=0;
    qsort(idli,N,sizeof(int),cmp);
    min_index=0;
    max_index=N-1;
    
    while(1){
    if(min_index==max_index){
    break;
    }
    if(idli[min_index]==idli[max_index]){
    break;
    }
    xfer=ceil((idli[max_index]-idli[min_index])/2);
    idli[max_index]-=xfer;
    idli[min_index]+=xfer;
    count++;
    if(idli[min_index]>idli[max_index]){
    flag=1;
    printf(""-1\n"");
    break;
    }
    min_index++;
    max_index--;
    }
    
    if(flag==0){
    printf(""%d\n"",count);
    }
    
    }
    return 0;
    }
    

",C
577016,"
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <queue>
    #include <algorithm>
    #include <sstream>
    #include <iostream>
    #include <cstdio>
    #include <cmath>
    #include <cstdlib>
    #include <cstring>
    
    using namespace std;
    
    #define f(i, a, b) for(int i = a; i < b; i++)
    #define rep(i, n) f(i, 0, n)
    
    typedef long long ll;
    typedef pair<int, int> pii;
    
    int ct[3001];
    
    int main() {
    
        int T; scanf(""%d"", &T); while(T--) {
    
            memset(ct, 0, sizeof(ct));
    
            int n; scanf(""%d"", &n);
    
            int it1 = n;
            int it2 = 0;
            int sum = 0;
    
            rep(i, n) {
                int x; scanf(""%d"", &x);
                ct[x]++;
                it1 = min(it1, x);
                it2 = max(it2, x);
                sum += x;
            }
    
            int res = 0;
            if(sum % 2) res = -1;
            else {
    
                while(it1 < it2) {
    
                    int v = (it2 - it1 + 1) / 2;
                    int k = min(ct[it1], ct[it2]);
    
                    ct[it1] -= k;
                    ct[it2] -= k;
    
                    ct[it1 + v] += k;
                    ct[it2 - v] += k;
    
                    res += k;
    
    
                    if(ct[it1] != 0 && ct[it2] != 0) {
                        res = -1;
                        break;
                    }
    
                    if(ct[it1] == 0) it1++;
                    if(ct[it2] == 0) it2--;
    
                }
    
            }
    
            printf(""%d\n"", res);
    
        }
    }
    

",C++
11635678,"
    #include <algorithm>
    #include <iostream>
    using namespace std;
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            int g,n,i,q,k=0,a,b;
            cin>>g;
            while(g--)
            {
                cin>>i>>n>>q;
                int mat[n];
                if(n%2==0)
                {
                    k=1;
                }
                else
                {
                    k=2;
                   a=((n-1)/2);
                   b=((n+1)/2);
                }
                if(k==1)
                {
                    cout<<n/2<<endl;
                }
                if(k==2)
                {
                    if((i==1 && q==1)||(i==2 && q==2))
                    {
                        cout<<a<<endl;
                    }
                    else
                    cout<<b<<endl;
                }
            }
        }
        return 0;
    }
    

",C++
11599081,"
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        int t,i,j,n,n1,q;
        long int l,k,c=0;
        scanf(""%d"",&t);
        for(i=0;i<t;i++)
        {
            scanf(""%d"",&n);
            for(j=0;j<n;j++)
            {
                c=0;
                scanf(""%d%ld%d"",&n1,&l,&q);
                int arr[l];
                for(k=0;k<l;k++)
                {
                    arr[k]=n1;
                }
                if(n1==1)
                {
                    if(l%2!=0)
                    {
                        for(k=0;k<l;k+=2)
                        {
                            arr[k]=2;
                        }
                    }
                    else
                    {
                        for(k=1;k<l;k+=2)
                        {
                            arr[k]=2;
                        }
                    }
                }
                else
                    if(n1==2)
                {
                {
                    if(l%2!=0)
                    {
                        for(k=0;k<l;k+=2)
                        {
                            arr[k]=1;
                        }
    
                    }
                    else
                    {
                        for(k=1;k<l;k+=2)
                        {
                            arr[k]=1;
                        }
                    }
                }
                }
                    for(k=0;k<l;k++)
                    {
                        if(arr[k]==q)
                        {
                            c++;
                        }
                    }
                    printf(""%ld"",c);
                    printf(""\n"");
            }
        }
        return 0;
    }
    

",C
10162831,"
    #include<stdio.h>
    int main()
    {
        int test;
        scanf(""%d"",&test);
        int i,q,g,k,j,l,zero,one,ans,z,w;
    
        long long int n;
    
        for(k=1;k<=test;k++)
        {
            scanf(""%d"",&g);
            for(j=1;j<=g;j++)
            {
                scanf(""%d%lld%d"",&i,&n,&q);
                int arr[n];
                for(l=0;l<n;l++)
                    arr[l]=1;
    
                for(l=0;l<n;l++)
                {
    
                    for(z=0;z<=l;z++)
                    {
                        if(arr[z]==1)
                            arr[z]=2;
                        else
                            arr[z]=1;
                    }
                }
    
                    zero=0;one=0;
                    for(l=0;l<n;l++)
                    {
                        if(arr[l]==1)
                            one++;
                        else
                            zero++;
                    }
    
                if(q==1 && i==1)
                    ans=zero;
                if(q==2 && i==1)
                    ans=one;
                if(q==1 && i==2)
                    ans=one;
                if(q==2 && i==2)
                    ans=zero;
    
    
                printf(""%d"",ans);
                if(j<g)
                    printf(""\n"");
    
            }
        }
    
        return 0;
    }
    

",C
9493062,"
    #include<iostream>
    #include<new>
    using namespace std;
    int main()
    {
      int t,g,l,k,q;
      long int n,c,i,j,*a;
      cin>>t;
      for(k=0;k<t;k++)
      {
         cin>>g;
         while(g--)
         {   c=0;
            cin>>l>>n>>q;
            a=new(nothrow) long int[n];
            for(i=0;i<n;i++)
            a[i]=l;
            for(i=0;i<n;i++)
            {
               for(j=0;j<=i;j++)
               {
                  if(a[i]==1)
                  a[i]=2;
                  else if(a[i]==2)
                  a[i]=1;
               }
            }
            for(i=0;i<n;i++)
            {
               if(a[i]==q)
               c++;
            }
            cout<<c<<endl;
            
         }
         delete[] a;
      }
      return 0;
    }

",C++
8573444,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	short t,f,g,q;
    	double n,sum;
    	cin>>t;
    	for(int i=0;i<t;i++)
    	 {cin>>g;
    	 for(int l=0;l<g;l++)
    	 {cin>>f>>n>>q;
    	 if(q==f)
    	 sum=int(n/2);
    	 else
    	 sum=int(n/2+1);
    	 cout<<sum<<endl; }
     }
    }

",C++
7896905,"
    #include <iostream>
    using namespace std;
    int main(){
    	int T,G,L,Q;
    	cin>>T;
    	long int N;
    	
    	for(int p=0;p<T;p++){
    		cin>>G;
    	for(int v=0;v<G;v++){
    		cin>>L>>N>>Q;
    		if(N%2==0){
    			cout<<N/2;
    		}
    		else{
    			if(L==Q)
    				cout<<N/2;
    			else
    				cout<<(N/2+1);
    
    		}
    		cout<<endl;		
    		
    	}		
     }	
    	return 0;
    }

",C++
7874373,"
    #include<stdio.h>
    int main()
    {
        int t,g,i,q;
        long int n,print;
        scanf(""%d"",&t);
        while(t--)
        {
            scanf(""%d"",&g);
            while(g--)
            {
                scanf(""%d %ld %d"",&i,&n,&q);
                if(n%2==0 || i==q)
                    printf(""%d"",n/2);
                else
                    printf(""%d"",n/2+1);
    
                printf(""\n"");
            }
        }
        return 0;
    }
    

",C
7034266,"
    #include<stdio.h>
    #include<string.h>
    #define pc putchar_unlocked
    #define gc getchar_unlocked
    using namespace std;
    inline int readInt()
    {
        int cc = gc();
        for (;cc < '0' || cc > '9';)
                cc = gc();
        int ret = 0;
        for (;cc >= '0' && cc <= '9';)
        {
                ret = ret * 10 + cc - '0';
                cc = gc();
        }
        return ret;
    }
        inline void writeInt (int n)
        {
            int N = n, rev, count = 0;
            rev = N;
            if (N == 0) { pc('0'); pc('\n'); return ;}
            while ((rev % 10) == 0) { count++; rev /= 10;} //obtain the count of the number of 0s
            rev = 0;
            while (N != 0) { rev = (rev<<3) + (rev<<1) + N % 10; N /= 10;}  //store reverse of N in rev
            while (rev != 0) { pc(rev % 10 + '0'); rev /= 10;}
            while (count--) pc('0');
            pc('\n');
        }
    int main()
    {
        int t,g,i,n,q,count1;
        t=readInt();
        while(t--)
        {
            g=readInt();
            while(g--)
            {
                count1=0;
                i=readInt();
                n=readInt();
                q=readInt();
                while(n--)
                {
                    int temp=(n+1)%2;
                    if((temp+i)==q)
                        count1++;
                    if((temp+i)>2)
                        if(q==1)
                        count1++;
                }
                writeInt(count1);
            }
        }
    }
    

",C++
7027631,"
    #include <stdio.h>
    
    int main()
    {
    	int t, g, i, n, q;
    	scanf(""%d"", &t);
    	while (t--)
    	{
    		scanf(""%d"", &g);
    		while(g--)
    		{
    			scanf(""%d %d %d"", &i, &n, &q);
    			if (n % 2 == 0)
    				printf(""%d\n"", n/2);
    			else
    			{
    				if (i == q)
    					printf(""%d\n"", n/2);
    				else
    					printf(""%d\n"", n/2 + 1);
    			}
    		}
    	}
    	return 0;
    }

",C
7010019,"
    #include <stdio.h>
    int main(void)
    {
        int test;
        scanf(""%d"",&test);
        while(test--){
            int g,i,n,q;
            scanf(""%d"",&g);
            while(g--){
            scanf(""%d %d %d"",&i,&n,&q) ;
            if(((i==q)&&(n%2!=0))||((i!=q)&&(n%2==0)))
                printf(""%d\n"",n/2);
            else if(((i!=q)&&(n%2!=0))||((i==q)&&(n%2==0)))
                printf(""%d\n"",n-n/2);
        }}
        return 0;
    }
    

",C
5961257,"
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    	int g,t,q,i;
    	long long n;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d"",&g);
    		while(g--)
    		{
    			scanf(""%d %d %d"",&i,&n,&q);
    			int j,k,a[n];
    		
    			
    			if(i==1)
    			{
    				for(j=0;j<n;j++)
    				a[j]=1;
    			}
    			else
    			{
    				for(j=0;j<n;j++)
    				a[j]=0;
    			}
    			
    			for(k=1;k<=n;k++)
    			{
    				for(j=0;j<k;j++)
    				{
    					a[j]=a[j]^1;
    				}
    			}
    		
    			long long count=0;
    			if(q==1)
    			{
    				
    				for(j=0;j<n;j++)
    				{
    					if(a[j]==1)
    					{
    						count++;
    					}
    				}
    				printf(""%d\n"",count);
    			}
    			else
    			{
    				for(j=0;j<n;j++)
    				{
    					if(a[j]==0)
    					count++;
    				}
    				printf(""%d\n"",count);
    			}
    			
    		}
    	}
    	return 0;
    }
    

",C
5197654,"
    #include<iostream>
    #include<algorithm>
    #define ll long long
    using namespace std;
    int main()
    {
    	ll t;
    scanf(""%lld"",&t);
    	while(t--)
    	{
    		ll g;
    		scanf(""%lld"",&g);
    		while(g--)
    		{
    			ll i,n,q;
    			scanf(""%lld"",&i);scanf(""%lld"",&n);scanf(""%lld"",&q);
    			if(i==1)
    			{
    				if(q==1)
    				cout<<n-((n+1)/2)<<endl;
    				else
    				cout<<(n+1)/2<<endl;
    			}
    			else
    			{
    				if(q==1)
    				cout<<(n+1)/2<<endl;
    				else
    				cout<<n-((n+1)/2)<<endl;
    			}
    			
    		}
    	}
    	return 0;
    }

",C++
4508721,"
    #include<stdio.h>
    int main(){
    int t,g,i,q;
    long long int n;
    scanf(""%d"",&t);
    while(t--){
    scanf(""%d"",&g);
    while(g--){
    scanf(""%d %lld %d"",&i,&n,&q);
    if(i==q)
    printf(""%lld\n"",n/2);
    else
    printf(""%lld\n"",n-n/2);}
    }
    return 0;}

",C
4423637,"
    //============================================================================
    // Name        : tp.cpp
    // Author      : Chinmay
    // Version     :
    // Copyright   : Your copyright notice
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    #include <math.h>
    #include <cmath>
    #include <stdlib.h>
    using namespace std;
    
    long long int calc(long long int i,long long int n,long long int q)
    {
    	long long int ans;
    	if(i==1 && q==1)
    	{
    		ans=(n-1)/2;
    	}
    	else if(i==1 && q==2)
    	{
    		ans=(n+1)/2;
    	}
    	else if(i==2 && q==1)
    	{
    		ans=(n+1)/2;
    	}
    	else
    	{
    		ans=(n-1)/2;
    	}
    	return ans;
    }
    int main() {
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		int G,I,Q;
    		long long int N,ans;
    		cin>>G;
    		while(G--)
    		{
    			cin>>I>>N>>Q;
    			if(N%2==0)
    			{
    				ans=N/2;
    			}
    			else
    			{
    				ans=calc(I,N,Q);
    			}
    			cout<<ans<<""\n"";
    		}
    	}
    	return 0;
    }
    

",C++
2986110,"
    #include<iostream>
    using namespace std;
    int coinFlapCount(int len,int l,int q)
    {
        int count=0;
        if(len%2==0)
        count=len/2;
        else
        {
            if(l==q)
            count=len/2;
            else
            count=len/2+1;
        }
        return count;
    }
     
    int main()
    {
        int n,q,l,t,g;
        cin>>t;
        while(t--)
        {
         cin>>g;
         while(g--)
         {
        cin>>l>>n>>q;
        cout<<coinFlapCount(n,l,q)<<endl;
         }
        }
        return 0;
    }
     

",C++
1585095,"
    T = int(input()) # No. of test cases
    result = []
    
    
    for i in range(int(T)):
        
        G = int(input()) # No. of Games
        
        for i in range(int(G)):
    
            x = input() # string input
    
            y = x.split("" "") # each no as string
    
            g = int(y[0]) # Initial state 1 is Head and 2 is Tail
            I = int(g)
            f = int(y[1]) # No. of coins
            N = int(f)
            Q = int(y[2]) # Face value to know 1 for Head and 2 for tail
    
    ## Main logic goes here
            if I == 1:
                h = N // 2
                t = N - h
            else:
                t == N // 2
                h = N -t
            
    ## Ends
            
            if int(Q) == 1:
                result.append(h)
            elif int(Q) == 2:
                result.append(t)
    
    for i in range(len(result)):
        print(result[i])
    

",PYTH
9737974,"
    #include <bits/stdc++.h>
    #define ll long long
    #define MOD 1000000007
    #define INF 0x3f3f3f3f
    
    using namespace std;
    
    int dp[100005],p[10];
    int grundy(int pos)
    {
        //cout<<pos<<endl;
        if(dp[pos]!=-1)
            return dp[pos];
        set<int> s;
        int i=1;
        while(pos-p[i]>=0)
        {
            s.insert(grundy(pos-p[i]));
            i++;
        }
        int ret=0;
        while(s.find(ret)!=s.end())
            ret++;
        return dp[pos]=ret;
    }
    
    void pre()
    {
        for(int i=1;i<=7;i++)
        {
            p[i]=1;
            for(int j=1;j<=i;j++)
                p[i]*=i;
            //cout<<p[i]<<"" "";
        }
        //cout<<endl;
    }
    int main()
    {
        int t;
        scanf(""%d"",&t);
        pre();
        //cout<<""1\n"";
        memset(dp,-1,sizeof(dp));
        for(int i=0;i<=100000;i++)
            grundy(i);
        while(t--)
        {
            int n;
            scanf(""%d"",&n);
            int ans=0;
            for(int i=0;i<n;i++){
                int x;
                scanf(""%d"",&x);
                ans^=dp[x];
            }
            if(ans==0)
                printf(""Head Chef\n"");
            else
                printf(""Little Chef\n"");
    
        }
        return 0;
    }
    

",C++
3147837,"
    #include <stdio.h>
    #include<math.h>
    
    inline int fastread()
    {
        int i=0;
        char c=0;
        while (c<33)
            c=getchar();
        while (c>33)
        {
    		i = i*10+c-'0';
    		c=getchar();
        }
        return i;
    }
    
    int min(a, b)
    {
    	if(a < b)
    		return a;
    	else
    		return b;
    }
    
    int main()
    {
    	unsigned int t, n, a, b, n1,k;
    	long unsigned int Ans;
    
    	t=fastread();
    
    	while (t--)
    	{
    		n=fastread();
    		a=fastread();
    		b=fastread();
    		unsigned int a0=0,a1=0,b0=0,b1=0,out=0;
    		k=n;
    		while (k--)
    		{
    			if (a%2==1)
    				a1++;
    			else
    				a0++;
    
    			if (b%2==1)
    				b1++;
    			else
    				b0++;
                a/=2;
                b/=2;
    		}
    		n1 = min(a1, b0) + min(b1, a0);
    
    		while (n1)
    		{
    			out += pow(2,n-n1);
    			n1--;
    		}
    
    		printf(""%lu\n"", out);
    	}
    
    	return 0;
    }
    

",C
1844821,"
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <deque>
    #include <queue>
    #include <stack>
    #include <bitset>
    #include <algorithm>
    #include <functional>
    #include <numeric>
    #include <utility>
    #include <sstream>
    #include <iostream>
    #include <iomanip>
    #include <cstdio>
    #include <cmath>
    #include <cstdlib>
    #include <cctype>
    #include <string>
    #include <cstring>
    #include <ctime>
    #include <string.h>
    
    using namespace std;
    
    typedef unsigned long long ULL;
    typedef long long LL;
    typedef long double LD;
    typedef pair<int, int> PII;
    typedef map<int, int> MI;
    typedef vector<int> VI;
    typedef vector<vector<int> > VVI;
    const double pi=acos(-1.0);
    const double eps=1e-11;
    const int mod = 1e9 + 7;
    
    #define two(X) (1<<(X))
    #define twoL(X) ((1LL)<<(X))
    #define contain(S,X) (((S)&two(X))!=0)
    #define containL(S,X) (((S)&twoL(X))!=0)
    
    #define rep(i, n) rb(i, 0, n)
    #define rb(i, b, n) rbc(i, b, n, <)
    #define rbe(i, b, n) rbc(i, b, n, <=)
    #define rbc(i, b, n, c) for(int i = ((int)(b)); i c ((int)(n)); i++)
    
    #define p(x) cout << x;
    #define ps(x) cout << x << "" ""
    #define pl cout << endl
    #define pn(x) cout << x << endl
    
    #define s(v) ((int) v.size())
    #define all(v) v.begin(), v.end()
    #define MP make_pair
    #define PB push_back
    #define X first
    #define Y second
    #define getcx getchar
    //_unlocked
    
    template<class T>
    inline void readInt( T &n )//fast input function
    {
       n=0;
       T ch=getcx();int sign=1;
       while( ch < '0' || ch > '9' ){if(ch=='-')sign=-1; ch=getcx();}
    
       while(  ch >= '0' && ch <= '9' )
               n = (n<<3)+(n<<1) + ch-'0', ch=getcx();
       n=n*sign;
    }
    /**************************************************/
    
    int dist(PII p1, PII p2) {
        int dx = p1.X - p2.X;
        int dy = p1.Y - p2.Y;
        return dx * dx + dy * dy;
    }
    
    
    int main() {
        int T, n, a, b, s, res;
        int pow2[31];
    
        pow2[0] = 1;
        rb(i, 1, 31) pow2[i] = 2 * pow2[i - 1];
    
        readInt(T);
        while(T--) {
            readInt(n);
            readInt(a);
            readInt(b);
    
            s = abs(n - __builtin_popcount(a) - __builtin_popcount(b));
            res = pow2[s] * (pow2[n - s] - 1);
    
            printf(""%d\n"", res);
        }
    
        return 0;
    }
    
    
    
    
    
    
    

",C++
11602922,"
    #include<bits/stdc++.h>
    using namespace std;
    int main(){
        long long int n;
        cin>>n;
        long long int s=(n*(n+1))/2;
        int sum=0;
        while(n--)
        {
            long long int val;
            cin>>val;
            sum+=val;
        }
        if(sum==s)
        cout<<""YES\n"";
        else
        cout<<""NO\n"";
        return 0;
    }
    

",C++
7596180,"
    #include<stdio.h>
    
    int main()
    {
    
    long long int a,b,c,k,t,sum;
    	sum=0;
    	scanf(""%lld"",&a);
    	t=a;
    	while(a--)
    	{
    		scanf(""%lld"",&b);
    		sum=sum+b;
    		
    	}
    	
    	t=t*(t+1)/2;
    	
    	if(sum>=t)
    	{
    		printf(""YES\n"");
    	}
    	else
    	{
    		printf(""NO\n"");
    	}
    	
    	return 0;
    }

",C
6465519,"
    #include<stdio.h>
    int main()
    {
    	int i,j,N,sum=0;
    	scanf(""%d"",&N);
    	for(i=1;i<=N;i++)
    	{
    		scanf(""%d"",&j);
    		sum+=j;
    	}
    	if(sum==(N*(N+1))/2)
    	printf(""YES"");
    	else
    	printf(""NO"");
    	return 0;
    }

",C
3642271,"
    #include <stdio.h>
    
    int main(void) {
    	
    	long long int n,s,a[100008],i,p;
    	// your code goes here
    	scanf(""%lld"",&n);s=0;
    for(i=0;i<n;i++)
    {scanf(""%lld"",&a[i]);s=s+a[i];}
    if(n%2==0){p=n/2;p=(n+1)*p;}
    else {p=(n+1)/2;p=n*p;}
    
    if(s==p) printf(""YES\n"");
    else printf(""NO\n"");
    
    	return 0;
    }
    

",C
2855186,"
    // -*- C++ -*-
    // File: a.cpp
    // Copyright (C) 2013
    #include <algorithm>
    #include <string>
    #include <vector>
    #include <queue>
    #include <iostream>
    #include <cmath>
    #include <sstream>
    #include <map>
    #include <set>
    #include <numeric>
    #include <memory.h>
    #include <cstdio>
    #include <assert.h>
    //#include <complex>
    
    using namespace std;
    
    #define pb push_back
    #define INF 1011111111
    #define FOR(i,a,b) for (int _n(b), i(a); i < _n; i++)
    #define rep(i,n) FOR(i,0,n)
    #define CL(a,v) memset((a),(v),sizeof(a))
    #define mp make_pair
    #define X first
    #define Y second
    #define all(c) (c).begin(), (c).end()
    #define SORT(c) sort(all(c))
    
    typedef long long ll;
    typedef vector<int> VI;
    typedef pair<int,int> pii;
    
    /*** TEMPLATE CODE ENDS HERE */
    
    //typedef complex<double> base;
    
    struct complex {
    	typedef double DOUBLE;
    	DOUBLE im, re;
    	complex() : re(0), im(0) {}
    	complex(DOUBLE re) : re(re), im(0) {}
    	complex(DOUBLE re, DOUBLE im) : re(re), im(im) {}
    	complex operator+(const complex &a) {
    		return complex(re+a.re,im+a.im);
    	}
    	complex operator-(const complex &a) {
    		return complex(re-a.re,im-a.im);
    	}
    	complex operator*(const complex &a) {
    		return complex(re*a.re-im*a.im, re*a.im+im*a.re);
    	}
    	complex& operator*=(const complex &a) {
    		DOUBLE r = re*a.re-im*a.im, i = re*a.im+im*a.re;
    		re = r;
    		im = i;
    		return *this;
    	}
    	complex& operator/=(double a) {
    		re /= a;
    		im /= a;
    		return *this;
    	}
    	DOUBLE real() const { return re; }
    };
    
    typedef complex base;
    
    
    int rev(int i, int lg_n) {
    	int j = 0;
    	int res = 0;
    	while(i) {
    		if(i&1) res |= 1<<(lg_n-1-j);
    		++j;
    		i>>=1;
    	}
    	return res;
    }
    
    void fft(vector<base> &a, bool inverse) {
    	const int n = (int)a.size();
    	int lg_n = 0;
    	while((1<<lg_n)<n) ++ lg_n;
    	
    	for(int i = 0; i < n; ++i)
    		if(i < rev(i, lg_n))
    			swap(a[i], a[rev(i,lg_n)]);
    	
    	for(int len = 2; len <= n; len <<= 1) {
    		double angle = 2*M_PI/len * (inverse ? -1 : 1);
    		base delta(cos(angle), sin(angle));
    		for(int i = 0; i < n; i += len) {
    			base root(1,0);
    			for(int j = 0; j < len/2; ++j) {
    				base u = a[i+j];
    				base v = a[i+j+len/2]*root;
    				a[i+j] = u + v;
    				a[i+j+len/2] = u - v;
    				root *= delta;
    			}
    		}
    	}
    	
    	if(inverse)
    		for(int i = 0; i < n; ++i) a[i] /= n;
    }
    
    //typedef complex Mod;
    const int NN = 1<<22;
    base tmp[NN];
    
    void fft(base *v, int sh, int n, base w) {
      if(n==1) return;
      base w2 = w*w;
      int n2 = n/2;
      fft(&v[0], sh+1, n2, w2);
      fft(&v[1<<sh], sh+1, n2, w2);
      
      base wx = 1;
      for(int i=0;i<n2;++i) {
        base A = v[i<<(sh+1)];
        base B = v[(i<<(sh+1))+(1<<sh)];
        base wxB = wx*B;
        tmp[i] = A + wxB;
        tmp[n2+i] = A - wxB;
        wx *= w;
      }
    //	for(int i = 0; i < n2; ++i) {
    //		base A = v[i<<(sh+1)];
    //		base B = v[(i<<(sh+1))+(i<<sh)];
    //		base wxv = wx * B;
    //		tmp[i] = A + wxv;
    //		tmp[n2+i] = B - wxv;
    //		wx *= w; 
    //	}	
      rep(i,n) v[i<<sh] = tmp[i];
    }
    
    base b[1<<22];
    
    void fft2(base *a, int shift, const int n, base w) {
    	
    	if(n==1) return;
    	
    	int n2 = n / 2;
    	base w2 = w*w;
    	
    	fft(&a[0],shift+1,n2,w2);
    	fft(&a[1<<shift],shift+1,n2,w2);
    	
    	base wx = 1;
    	//double angle = 2*M_PI/n * (inverse ? -1 : 1);
    	//base delta(cos(angle), sin(angle));
    	
    	for(int i = 0; i < n2; ++i) {
    		base u = a[i<<(shift+1)];
    		base v = a[(i<<(shift+1))+(i<<shift)];
    		base wxv = wx * v;
    		b[i] = u + wxv;
    		b[n2+i] = u - wxv;
    		wx *= w; 
    	}	
    	for(int i = 0; i < n; ++i) a[i<<shift] = b[i]; //{
    		//a[i<<shift] = b[i];
    		//if(inverse) a[i<<shift] /= 2;
    	//}
    }
    
    int N;
    ll A[1<<18];
    
    ll solve_small() { //number of sub-arrays <= 2,001,000; S <= 4*10^10; N <= 2000
    	ll *s = new ll[2010];
        ll *t = new ll[2001000];        
        rep(i,N) s[i] = (i?s[i-1]:0) + A[i];
        int k = 0;    
    	rep(i,N) rep(j,i+1) t[k++] = s[i] - (j?s[j-1]:0ll);
        sort(t,t+k);
        int res = unique(t,t+k)-t;
        delete[] s;
        delete[] t;
        return res;
    }
    
    ll solve_medium() { //number of sub-arrays <= 200,010,000; S <= 20,000,000; 2000 < N <= 20,000
    	vector<ll> s(20010,0);
    	bool *was = new bool[20000010];
    	//memset(was,0,20000010ll * sizeof(bool));
    	assert(N<20000010);
    	rep(i,N) s[i] = (i?s[i-1]:0ll) + A[i];
    	rep(i,N) rep(j,i+1) was[ s[i] - (j?s[j-1]:0ll) ] = true;
    	ll ans = 0;
    	rep(i,20000010) if(was[i]) ++ans;	
    	delete [] was;
    	return ans;
    }
    
    //--------------------------------------------------
    
      // returns x from 1 to m-1 such that m divides a*x-1
      // precondition gcd(a, m) = 1
      ll inv(ll a, ll m) {
        ll x0 = 1, x1 = 0;
        ll b = m;
        while (b > 0) {
    
          ll q = a / b;
    
          // (a; b) := (b; a - q * b)
          ll c = a - q * b;
          a = b;
          b = c;
    
          // (x0; x1) := (x1; x0 - q * x1)
          ll x = x0 - q * x1;
          x0 = x1;
          x1 = x;
        }
        return x0 < 0 ? x0 + m : x0;
      }
      
        // returns A^N mod M
      // exponentiation by squaring
      int powmod(int A, int N, int M) {
        int res = 1;
        while (N > 0) {
          if (N % 2 == 1) {
            res = (ll)res * A % M;
          }
          N /= 2;
          if (N > 0) {
            A = (ll)A * A % M;
          }
        }
        return res;
      }
    
    const int mod = 2130706433;
    const int root = 3;
    const int root_1 = inv(root, mod);
    const int root_pw = 1<<20;
     
    void fft (vector<int> & a, bool invert) {
    	int n = (int) a.size();
     
    	for (int i=1, j=0; i<n; ++i) {
    		int bit = n >> 1;
    		for (; j>=bit; bit>>=1)
    			j -= bit;
    		j += bit;
    		if (i < j)
    			swap (a[i], a[j]);
    	}
    	
    	int lg_n = 0;
    	while((1<<lg_n)<n) ++ lg_n;
    	
    	// g will now have order 2^h in Zp as needed for DFT
        int g = powmod(root, (mod-1) >> lg_n, mod);
    	if(invert) g = inv(g, mod);
     
        // w[] will contain powers of g
    //    w[0] = 1;
    //    for(int i = 1; i < n; i++) {
    //      w[i] = (ll)w[i - 1] * g % mod;
    //    }
     
    	for (int len=2; len<=n; len<<=1) {
    		//int wlen = invert ? root_1 : root;
    		int wlen = g;
    		for (int i=len; i<root_pw; i<<=1)
    			wlen = int (wlen * 1ll * wlen % mod);
    		for (int i=0; i<n; i+=len) {
    			int w = 1;
    			for (int j=0; j<len/2; ++j) {
    				int u = a[i+j],  v = int (a[i+j+len/2] * 1ll * w % mod);
    				a[i+j] = u+v < mod ? u+v : u+v-mod;
    				a[i+j+len/2] = u-v >= 0 ? u-v : u-v+mod;
    				w = int (w * 1ll * wlen % mod);
    			}
    		}
    	}
    	if (invert) {
    		int nrev = inv (n, mod);
    		for (int i=0; i<n; ++i)
    			a[i] = int (a[i] * 1ll * nrev % mod);
    	}
    }
    //---------------------------------------------------------------
    
    ll solve_large() { // number of sub-arrays <= 20,000,100,000; S <= 2,000,000; 20,000 < N ≤ 200,000
    	
    	const int S = accumulate(A,A+N,0ll);
    	
    	assert(S <= 2000000);
    	
    	int n = 1;
    	while(n < (S+1)) n <<= 1;
    	n <<= 1;
    		
    	vector<base> xx(n), yy(n);	
    //	vector<int> xx(n), yy(n);	
    	int s = 0;
    	
    	rep(i,N+1) {
    		xx[s] = base(1,0);
    		yy[S-s] = base(1,0);
    		s += A[i];
    	}
    	
    	double angle = 2*M_PI/n;
    	base delta(cos(angle), sin(angle));
    		
    	fft(&xx[0],0,n,delta);
    	fft(&yy[0],0,n,delta);	
    	
    	rep(i,n) xx[i] *= yy[i];
    	angle = -angle;
    	delta = base(cos(angle), sin(angle));
    	
    	fft(&xx[0],0,n,delta);
    	rep(i,n) xx[i] /= n;
    
    //	rep(i,N+1) {
    //		x[s] = 1;
    //		y[S-s] = 1;
    //		s += A[i];
    //	}
    //
    //	convolution(S+1,S+1);
    //    int res=0;
    //    for(int i=0;i<S;i++) if(c[i]) res++;
    //	return res;
    
    //	rep(i,N+1) {
    //		xx[s] = 1;
    //		yy[S-s] = 1;
    //		s += A[i];
    //	}
    //	
    //	fft(xx,false);
    //	fft(yy,false);	
    //	rep(i,n) xx[i] = int(xx[i] * 1ll * yy[i] % mod);
    //	fft(xx,true);
    	
    	int ans = 0;
    	
    	rep(i,S) {
    		ll t = ll(xx[i].real()+0.5);
    		//int t = x[i];
    		if(t>0) ++ans;
    	}
    
    	return ans;
    }
    
    int main() {
    #ifdef LOCAL_HOST
        freopen(""input.txt"",""r"",stdin);
        //freopen(""output.txt"",""w"",stdout);
    #endif
    
        ios_base::sync_with_stdio(false);
    	
    	cin >> N;
    	rep(i,N) cin >> A[i];
    	
    	if(N <= 2000) {
    		cout << solve_small()-1 << endl;
    	}
    	else if(N <= 20000) {
    		cout << solve_medium()-1 << endl;
    	}
    	else {
    		cout << solve_large()-1 << endl;
    	}
    
    #ifdef LOCAL_HOST
        printf(""TIME: %.3lf\n"",double(clock())/CLOCKS_PER_SEC);
    #endif
    
        return 0;
    }
    

",C++
5035230,"
    import java.io.*;
    class Main
    {
        static int M = 1000000;
        static int b[];
        static int bcount;
        public static void generatePrime()
        { 
            int a[] = new int[M];
            for(int i = 2 ; i < M ; i++)
            a[i] = i;
            
            b = new int[100000];
            bcount = 0;
            int pos = 2;
            while(pos < M)
            {
                if(a[pos] != 0)
                {
                    b[bcount++] = a[pos];
                    for(int i = pos*2 ; i < M ; i += pos)
                    {
                        a[i] = 0;
                    }
                }
                pos++;
            }       
        }
        public static void main(String args[])throws IOException
        {
            generatePrime();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int t = Integer.parseInt(br.readLine());//testcases
            long num;
            int primeIndex;
            int count;//count no. of factors
            long factors[];//store all factors
            String s;
            while(t-- > 0)
            {
                factors = new long[100000];
                count = 0;
                primeIndex = 0;
                s = br.readLine();
                if(s.length() > 18 || s.equals(""1""))
                {
                    System.out.println(""1\n"" + s);
                }
                else
                {
                    num = Long.parseLong(s);
                    while(primeIndex < bcount)
                    {
                        while(num % b[primeIndex] == 0)
                        {
                            factors[count++] = b[primeIndex];
                            num /= b[primeIndex];
                        }
                        primeIndex++;
                    }
                    System.out.println(count);
                    for(int i = 0 ; i < count ; i++)
                    System.out.println(factors[i]);
                }
                
            }
        }
    }

",JAVA
12055043,"
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <stack>
    #include <queue>
    #include <map>
    
    using namespace std;
    
    int main() {
        int t;
        cin>>t;
        while(t--) {
            int n, m;
            int p, q, c, mask;
    
            cin>>n>>m;
            int dp1[1<<n], dp2[1<<n];
            fill(dp1, dp1+(1<<n), 1<<30);
            fill(dp2, dp2+(1<<n), 1<<30);
            dp1[0] = dp2[0] = 0;
            for(int i=0; i<n; i++) {
                cin>>c;
                dp1[1<<i] = c;
            }
            for(int i=0; i<m; i++) {
                cin>>c>>q;
                mask = 0;
                for(int j=0; j<q; j++) {
                    cin>>p;
                    mask = mask | (1<<(p-1));
                }
                dp1[mask] = min(dp1[mask],c);
            }
    
            for(int i=(1<<n)-1; i>=0; i--) {
                for(int j = i & (i-1); ;j = i&(j-1)) {
                    dp1[j] = min(dp1[j], dp1[i]);
                    if(j==0)
                        break;
                }
            }
    
            for(int i=1; i<(1<<n); i++)
                for(int j = i & (i-1); ;j = i&(j-1)) {
                    dp2[i] = min(dp2[i], dp2[j]+dp1[i^j]);
                    if(j==0)
                        break;
                }
            
            cout<<dp2[(1<<n)-1]<<endl;
        }
        
        return 0;
    }

",C++
6559039,"
    number_of_tests = gets.chomp
    data_set = {}
    for i in 0..(number_of_tests.to_i - 1)
      input = gets.chomp
      m, n, k = input.split("" "").map(&:to_i)
      hash = {}
      for l in 1..m
        hash[l] = {}
        input = gets.chomp
        input = input.split("" "").map(&:to_i)
        for b in 0..(n-1)
          hash[l][b+1] = input[b]
        end
      end
      data_set[i] = hash
      gets.chomp if i != number_of_tests.to_i - 1#to ignore input
    end
    
    puts data_set
    
    for test_data in 0..(number_of_tests.to_i - 1)
      puts ""Case #{test_data+1}:""
      for i in 1..(m-k+1)
        result = []
        for j in 1..(n-k+1)
          maxi = 0
          count = 0
          for ii in i..(i+k-1)
            for ij in j..(j+k-1)
              val = data_set[test_data][ii][ij]
              if val > maxi
                maxi = val
                count = 1
              elsif val == maxi
                count += 1            
              end
            end
          end
          s = maxi.to_s
          s += ""(#{count})"" if count > 1
          result << s
        end
        puts result.join("" "")
      end
      puts ""\n"" unless test_data == (number_of_tests.to_i - 1)
    end

",RUBY
1358334,"
    import java.util.Scanner;
    
    
    public class Main {
    
    	public static void main(String args[])
    	{
    		Scanner s =new Scanner(System.in);
    		long tc=Long.parseLong(s.nextLine());
    		int l=1;
    		while(l<=tc)
    		{
    			int m=s.nextInt();
    			int n=s.nextInt();
    			int k=s.nextInt();
    			int [] [] mat=new int[m][n];
    			for( int i=0;i<m;i++)
    				for(int j=0;j<n;j++)
    					mat[i][j]=s.nextInt();
    			
    			
    			
    			System.out.println(""Case ""+l+"":"");
    			for( int i=0;i<m-k+1;i++)
    			{
    				for(int j=0;j<n-k+1;j++)
    				{
    					int max=-9999;
    					int count=0;
    					for(int a=i;a<k+i;a++)
    					{
    						for(int b=j;b<k+j;b++)
    						{
    							if(mat[a][b]>max)
    							{
    								max=mat[a][b];
    								count=1;
    							}
    							else if(mat[a][b]==max)
    								count++;
    						}
    					}
    					if(count>1)
    						System.out.print(max+""(""+count+"") "");
    					else
    						System.out.print(max+"" "");
    				}
    				System.out.println();
    			}		
    			
    			System.out.println();
    			l++;
    			s.nextLine();
    		}
    		
    	}
    }
    

",JAVA
1332230,"
    #include<stdio.h>
    
    int **elevation;
    
    
    void max(int row_start, int row_end, int column_start, int column_end)
    {
    	int i,j,max = 0, count = 0;
    	
    	for(i = row_start;i <= row_end;i++)
    	{
    		for(j = column_start;j <= column_end;j++)
    		{
    			if(elevation[i][j] > max)
    			{
    				max = elevation[i][j];
    				count = 1;
    			}
    			
    			else if(elevation[i][j] == max)
    			{
    				count++;
    			}
    		}
    	}
    	
    	printf(""%d"",max);
    	if(count>1)
    	{
    		printf(""(%d) "",count);
    	}
    	else
    	{
    		printf("" "");
    	}
    }
    
    int main()
    {
    	int m,n,k,t,i,big_i,j,row,column;
    	
    	 char dummy[1];
    	scanf(""%d"", &t);
    	
    	for(big_i=0;big_i<t;big_i++)
    	{
    		scanf(""%d %d %d"",&m,&n,&k);
    		elevation = (int*)malloc(sizeof(int*)*m);
    		
    		for(row = 0;row < m;row++)
    		{
    			elevation[row] = (int)malloc(sizeof(int)*n);
    		}
    		
    		for(row = 0;row < m;row++)
    		{
    			for(column = 0;column < n;column++)
    			{
    				scanf(""%d"",&(elevation[row][column]));
    			}
    		}
    		scanf(""%c"",dummy);
    		printf(""Case %d:\n"",big_i+1);
    		for(i = 0;i< m-k+1;i++)
    		{
    			for(j =0;j<n-k+1;j++)
    			{
    				max(i,i+k-1,j,j+k-1);
    			}
    			printf(""\n"");
    		}
    		printf(""\n"");
    		
    		
    		
    		free(elevation);
    		
    	}
    	
    }

",C
10251526,"
    #include <bits/stdc++.h>
    using namespace std;
    int main() {
    	int t,k;
    	scanf(""%d"",&t);
    	char* str=""zyxwvutsrqponmlkjihgfedcba"";
    	while(t--){
    	   scanf(""%d"",&k);
    	   if(k==0){
    	       cout<<""a\n"";
    	       continue;
    	   }
    	   int a=k/25;
    	   k=k%25;
    	   if(k!=0)
    	        for(int i=25-k;i<=25;i++) printf(""%c"",str[i]);
    	   for(int i=1;i<=a;i++) printf(""%s"",str);
    	   printf(""\n"");
    	}
    	return 0;
    }
     

",C++
9186913,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int T,K,i;
    	cin>>T;
    	while(T--)
    	{
    		cin>>K;
    		if(K==0)
    		cout<<""\n"";
    		else{
    		for(i=(K%25)+1;i>0;i--)
    		{
    			cout<<(char)(96+i);
    		}
    		for(i=0;i<K/25;i++)
    		{
    			for(i=122;i>=97;i--)
    			cout<<(char)i;
    		}
    		cout<<""\n"";
    	}
    	}
    	return 0;
    }
    

",C++
7498660,"
    #include<stdio.h>
    int main()
    {
    	int k,t,i,j,num,rem;
    	scanf(""%d"",&t);
    	while(t--)
    	{
    		scanf(""%d"",&k);
    			num=k/25;
    		rem=k%25;
    		if(num==0)
    		{
    			rem=rem+97;
    			for(i=rem;i>=97;i--)
    			{
    				printf(""%c"",i);
    				
    			}
    		}
    		if(num>0)
    		{
    			rem=rem+97;
    			for(i=rem;i>=97;i--)
    			{
    				printf(""%c"",i);
    				
    			}
    			for(i=0;i<num;i++)
    			{
    				for(j=122;j>=97;j--)
    				{
    					printf(""%c"",j);
    				}
    			}
    		}
    		
    	
    			
    		
    		
    		printf(""\n"");
    	}
    	return(0);
    }

",C
5838911,"
    #include<stdio.h>
    int main(){
    int t,k,i;
    scanf(""%d"",&t);
    while(t--){
        scanf(""%d"",&k);
        printf(""\n"");
        if(k<=25){
        for(i=97+k;i>=97;i--)
            printf(""%c"",i);}
        else{
            while(k){
                for(i=122;i>=97;i--){
                    printf(""%c"",i);}
                k=k-25;
                }
            }
        }
    return 0;
    }
    

",C
5594136,"
    #include <iostream>
    using namespace std;
    
    int main()
    {
        int t;
        cin >> t;
        while(t--) {
                int k,q,r,i;
                char ch;
                cin >> k;
                r = k % 25;
                q = k / 25;
    
    
                    for(ch = 97 + r;ch >= 97;ch--)
                    {
                        cout << ch;
                    }
    
                for(i = 0;i < q;i++)
                    for(ch = 122;ch >= 97;ch--)
                        cout << ch;
                    cout << endl;
        }
        return 0;
    }
    

",C++
11694694,"
    #include <stdio.h>
    int main()
    {
    int t,i,k,j,max=0;
    scanf(""%d"",&t);
    for(k=1;k<=t;k++)
    {
        scanf(""%d"",&i);
        scanf(""%d"",&j);
        if (abs(max)<abs(i-j))
        {
            max=(i-j);
        }
    }
    if (max<0)
    {
        printf (""2 %d"",abs(max));
    }
    else
    {
        printf (""1 %d"",abs(max));
    }
    return(0);
    }
    

",C
11616854,"
    import java.util.*;
    import java.util.Arrays;
    
    class Chut
    {
    	
    	public static void main(String args[])
    
    {
    	
    	Scanner sc=new Scanner(System.in);
    	
    	int n;
    		n=sc.nextInt();
    		int a[]=new int[n];
    		int b[]=new int[n];
    		int c[]=new int[n];
    		int d[]=new int[n];
    		for(int i=0;i<n;i++)
    		{
    			a[i]=sc.nextInt();
    			b[i]=sc.nextInt();
    		}
    		for(int i=0;i<n;i++)
    		{
    			if(a[i]>b[i])
    			{
    				c[i]=a[i]-b[i];
    			}
    			else if(b[i]>a[i])
    			{
    				d[i]=b[i]-a[i];
    			}
    		}
    		Arrays.sort(c);
    		Arrays.sort(d);
        if(c[n-1]>d[n-1])
        {
        	System.out.println(""1""+ "" ""+c[n-1]);
        }
        else if(d[n-1]>c[n-1])
        {
        	System.out.println(""2""+ "" ""+d[n-1]);
        }
        
        
    
    
    
    	
    }	
    	
    	
    	
    	
    	}

",JAVA
11277050,"
    #include <iostream>
    using namespace std;
     
    int main()
    {
    	int lead,n,pl1sum=0,pl2sum=0,maxlead=0;
    	cin>>n;
    	while(n--)
    	{
    		
    		int player1,player2;
    		cin>>player1>>player2;
    		pl1sum+=player1;
    		pl2sum+=player2;
    		lead=(player1)-(player2);
    		if(lead<0){lead*=(-1);}
    		if(lead>maxlead){maxlead=lead;}
    	}
    	if(pl1sum>pl2sum){cout<<""1  ""<<lead<<maxlead;}
    	else {cout<<""2 ""<<maxlead;}
    	
    } 

",C++
11219771,"
    #include<iostream>
    using namespace std;
    void main()
    { int player1[10000];
    int player2[10000];
    int lead[10000];
    int x;
    cin>>x;
    int i;
    for(i = 0;i<x;i++)
    {cin>>player1[i]>>player2[i];
    int lead[i] = player1[i]-player2[i];
    }
    int a = 0;
    for(i = 0;i<x;i++)
    {a = a + player1[i];
    }
    int b = 0;
    for(i = 0;i>x;i++)
    {b = b + player2[i];
    }
    if((a-b)>0)
    {cout<<1<<"" "";
    }
    else
    {cout<<2<<"" "";
    }
    int largest = 0;
    for(i = 0;i<x;i++)
    { if(largest<lead[i])
    {largest = lead[i];
    }
    cout<<largest<<endl;
    return 0;
    }

",C++
11201820,"
    #include<stdio.h>
    int main()
    {
        int r,a=0,b=0,max,n,m,p,diff;
        scanf(""%d"",&r);
        max=-1;
        p=-1;
        while(r--)
        {
            scanf(""%d%d"",&n,&m);
            a=a+n;
            b=b+m;
        if(a>b)
            {
                diff=a-b;
                if(max<diff)
                {
                    max=diff;
                    p=1;
                }
            }
            else
            {
                diff=b-a;
                if(max<diff)
                {
                    p=2;
                    max=diff;
                    
                }
            }
        }
        printf(""%d %d"",p,max);
        return 0;
    }

",C
10860208,"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        int N, i, si, temp2, temp, ti, W, L=0;
        cin>>N;
        for(i=0;i<N;i++)
        {
            cin>>si;
            cin>>ti;
            if(si>ti)
            {
                temp=si-ti;
                temp2=1;
            }
            else
            {
                temp=ti-si;
                temp2=2;
            }
            if(L<temp)
            {
             L=temp;
             W=temp2;
            }
            cout<<""\n"";
        }
        cout<<W<<"" ""<<L;
        return 0;
    }
    

",C++
10780629,"
    #include<stdio.h>
    int main()
    {
    int t1,t2,n,large,winner,lead,i,sum1,sum2;
    scanf(""%d"",&n);
    large=0;
    winner=0;
    sum1=0;
    sum2=0;
    for(i=0;i<n;i++)
    {
    scanf(""%d%d"",&t1,&t2);
    sum1=sum1+t1;
    sum2=sum2+t2;
    lead=sum1-sum2;
    if(abs(lead)>large)
    {
    large=abs(lead);
    if(lead>0)
    winner=1;
    else
    winner=2;
    }
    
    }
    printf(""%d %d\n"",winner,large);
    return 0;
    }
    

",C
10269607,"
    #include <iostream>
    using namespace std;
    int main()
    {
        int rounds,i,w,num,l=0;
        cin>>rounds;
        int p1,p2,x=0,y=0;
        for(i=0;i<rounds;i++)
        {
            cin>>p1;
            cin>>p2;
            x = x+p1;
            y = y+p2;
            if(x-y>l)
            {
                w=1;
                l=x-y;
            }
            else if(y-x>l)
            {
                w=2;
                l=y-x;
            }
        }
            cout<<w<<"" ""<<l<<endl;
            return 0;
    }
    

",C++
10108483,"
    #include<iostream>
    using namespace std;
    
    int main(){
    	int rounds;
    	cin>>rounds;
    	int flag;
    	
    	int m1,m2;
    	int max=0;
    	
    	
    	for(int i=0;i<rounds;i++){
    		scanf(""%1d %1d"",&m1,&m2);
    		
    		if(m1>m2 && m1-m2>max){
    			
    				flag=1;
    				max=m1-m2;
    			
    			
    		}
    		else if(m2>m1 && m2-m1>max){
    			flag=2;
    			max=m2-m1;
    			}
    			
    		}
    	
    	
    
    		cout<<flag<<"" ""<<max;
    	
    }

",C++
10107107,"
    n=int(input())
    t1=t2=i=j=k=0
    while n>0:
        p1,p2=map(int,input().split())
        t1+=p1
        t2+=p2
        if t1-t2>k:
            i=1
            k=t1-t2
        elif t2-t1>k:
            i=2
            k=t2-t1
        n-=1
    
    print(i,"" "",k)
    

",PYTH
9998021,"
    #include<iostream>
    #include<algorithm>
    #include<vector>
    
    int main(){
    	int t,n1,n2,lead=0;
    	std::cin>>t;
    	for(int i=0;i<t;i++){
    		cin>>n1>>n2;
    		if(abs(n1-n2)>lead){
    			lead=abs(n1-n2);
    			if(n1>n2)pl=true;
    			else pl=false;
    		}
    		
    	}
    		cout<<(p1)?1:2<<"" ""<<lead;
    	return 0;
    	}	
    		

",C++
9970211,"
    #include<stdio.h>
    int main(){
        int n,a[10][10],i,j,leader[10],k,m,lead[10],z=0,x=0;
        printf(""Enter the no of rounds"");
        scanf(""%d"",&n);
        printf(""Enter the score for player 1 and 2"");
        for(i=0;i<n;i++)
            for(j=0;j<2;j++)
                scanf(""%d"",&a[i][j]);
        printf(""Round\tplayer1\tplayer2\n"");
        for(i=0;i<n;i++){
            printf(""\n%d"",i);
            for(j=0;j<2;j++)
                printf(""\t%d\t"",a[i][j]);
        }
        for(k=0;k<n;k++){
            int m=0;
            if(a[k][m]>a[k][m+1]){
                leader[k]=1;
                lead[k]=a[k][m]-a[k][m+1];
            }
            else{
                leader[k]=2;
                lead[k]=a[k][m+1]-a[k][m];
            }
        }
        printf(""\nRound\tplayer1\tplayer2\tLeader\tlead\n"");
        for(i=0;i<n;i++){
            printf(""\n%d"",i);
            for(j=0;j<2;j++)
                printf(""\t%d\t"",a[i][j]);
            printf(""player%d\t\t%d"",leader[z++],lead[x++]);
        }
        
    }
    

",C
9945582,"
    #include<stdio.h>
    int main(void)
    {
    
    int N,S[1000],T[1000],a[1000],v[1000],max=0,i;
    scanf(""%d"",&N);
    for(i=1;i<=N;i++)
    {
        scanf(""%d%d"",&S[i],&T[i]);
    if(S[i]>T[i])
        {
     v[i]=1;
     a[i]=S[i]-T[i];
     
        }
    else
        {
        v[i]=2;
        a[i]=T[i]-S[i];
        
        }
    }
    for(i=1;i<=N;i++)
        {
        if(max<a[i])
        max=a[i];
        }
        for(i=1;i<=N;i++)
        {
        if(max==a[i])
        printf(""%d %d"",v[i],a[i]);
        
        
        }
    
    return(0);
    }

",C
9771866,"
    #include<stdio.h>
    int main()
    {long int i,x=0,y=0,a,b,n,u=0,v=0,d,e;
    scanf(""%ld"",&n);
    for(i=0;i<n;i++)
    {scanf(""%ld%ld"",&a,&b);
     if(a>b)
     {u=(a-b+u);
     d=(a-b);
      if(x<d)
      { x=(a-b); 
      } 
     }
     else
     {v=(b-a+v);
     e=(b-a);
       if(y<e)
       {y=(b-a);
       }
      }
     }
     if(u<v)
     {printf(""1 "");
     printf(""%ld"",x);
     }
     else
     {printf(""2 "");
     printf(""%ld"",y);
     }
     return 0;
     }  
    

",C
9711253,"
    #include <stdio.h>
    
    int main(){
        int n,i,c=0,d=0;
        scanf(""%d"",&n);
        int f[n],s[n];
        for(i=0;i<n;i++){
            scanf(""%d%d"",&f[i],&s[i]);
    
            if(abs(f[i]-s[i])>d){
                d = abs(f[i]-s[i]);
                if(f[i]>s[i]) c = 0;else c = 1;
            }
        }
        printf(""%d %d"",c+1,d);
    }
    

",C
9656076,"
    #include<stdio.h>
    int main()
    {
    	int sum1=0,sum2=0,leader,lead[2];
    	int t,num1,num2;
    	int i;
    	
    	lead[0]=0;
    	lead[1]=0;
    	scanf(""%d"",&t);
    	for(i=1;i<=t;i++)
    	{
    		scanf(""%d%d"",&num1,&num2);
    		sum1+=num1;
    		sum2+=num2;
    		if((sum1-sum2)>lead[1])
    		{
    			lead[0]=1;
    			lead[1]=sum1-sum2;
    		}
    		else if((sum2-sum1)>lead[1])
    		{
    			lead[0]=2;
    			lead[1]=sum2-sum1;
    		}
    	}
    	printf(""#=%d %d"",lead[0],lead[1]);
    	return 0;
    }
    

",C
9456702,"
    #include <stdio.h>
    
    int main()
    {int n,p1,p2,i,aux[10],max=0,v[10],part1=0,part2=0,castig;
    printf(""Cate runde jucam: "");
    scanf(""%d"",&n);
    for(i=0;i<n;i++)
         {
            scanf(""%d %d"",&p1,&p2);
            part1+=p1;
            part2+=p2;
    
            if(part1>part2)
                {
                    v[i]=part1-part2;
                    aux[i]=1;
                }
            if(part1<part2)
                {
                    v[i]=part2-part1;
                    aux[i]=2;
                }
         }
    max=v[0];
    castig=aux[0];
    for(i=1;i<n;i++)
        if(v[i]>max)
            {max=v[i];
            castig=aux[i];}
    
    printf(""%d %d"",castig,max);
    
    }
    

",C
9441239,"
    rounds = int(input())
    amax=0
    bmax=0
    for i in range(0,rounds):
        score = input()
        scores = score.split()
        final = int(scores[0]) - int(scores[1])
        if final>0 and final>amax:
            amax=final
        if final<0 and round(final)>bmax:
            bmax=round(final)
    if amax>bmax:
        print(1,amax)
    else:
        print(2,bmax)
    

",PYTH
9359423,"
    #include<stdio.h>
    
    int main()
    
    {  
      int t;
       scanf(""%d"", &t);
      int player1[t], player2[t], lead[t], playno[t], i, p, q=0, large ;
     
      for(i=0;i<t;i++)
      {
        scanf(""%d%d"", &player1[i],&player2[i]);
        printf(""\n"");
        
        if(player1[i]>player2[i])
        {
          lead[i]=player1[i]-player2[i];
          playno[i]=1;
        }
        else
        {
         lead[i]=player2[i]-player1[i];
         playno[i]=2;
        }
        
        large=lead[0];
        for(p=1;p<t;p++)
        {
         if(large<lead[p])
         {
          large=lead[p];
          q=p;
         }
        }
       }
       
       printf(""%d %d"",playno[q],lead[q]);
       return 0;
    }
    

",C
9210429,"
    import java.util.*;
    import java.util.Collection;
    class Test{
    	public static void main(String args[])
    	{
    		int max,min,mint=0,maxt=0;
    	Scanner inp=new Scanner(System.in);
        int limit=inp.nextInt();
        int p1[]=new int[limit];
        int p2[]=new int[limit];
    	int p1s[]=new int[limit];
    	int p2s[]=new int[limit];
    	int lead[]=new int[limit];
    	for(int i=0;i<limit;i++)
    	{
    		p1[i]=inp.nextInt();
    		p2[i]=inp.nextInt();
    	}
    	p1s[0]=p1[0];
    	p2s[0]=p2[0];
    	for(int i=1;i<limit;i++)
    	{
    		p1s[i]=p1s[i-1]+p1[i];
    		p2s[i]=p2s[i-1]+p2[i];
    		
    	}
    	
    		//	max=p1s[0];
    	for(int i=0;i<limit;i++)
    	{
    	 lead[i]=p1s[i]-p2s[i];
        
    	}
    
    	for(int m=0;m<limit;m++)
    	{
    	if(lead[m]<0)
    	{
          min=lead[0];		
          for(int k=1;k<limit;k++)
    	  { 
            if(min>lead[k])
    		{
    			min=lead[k];
    		}
    		
    	  }
    	 mint=min*-1;
    	}
    	else {
    		max=lead[0];
    		for(int mi=1;mi<limit;mi++)
    		{
    			if(max<lead[mi])
    			{
    				max=lead[mi];
    			}
    		}
    		maxt=max;
    		//System.out.println(max);
    	}
    	}
    	
    		if(maxt>mint)
    		{
    			System.out.println(""1 ""+maxt);
    		}
    		else{
    			System.out.println(""2 ""+mint);
    		}
    	
    
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	}
    		
    	
    	
    	
    }

",JAVA
8848825,"
    import java.util.Scanner;
    
    public class Main {
    	static Scanner scanner = new Scanner(System.in);
    
    	public static void main(String[] args) {
    		int TestCases = scanner.nextInt();
    		scanner.nextLine();
    		int maxW = 0;
    		int maxL = 0;
    		int currW = 0;
    		int currL = 0;
    
    		for (int i = 0; i < TestCases; i++) {
    			int s = scanner.nextInt();
    			int t = scanner.nextInt();
    			scanner.nextLine();
    
    			if (s > t) {
    				currL = s - t;
    				currW = 1;
    			}
    			else{
    				currL = -s + t;
    				currW = 2;
    				
    			}
    			if(currW>maxW){
    				maxW= currW;
    				maxL= currL;
    			}
    
    		}
    		System.out.println(maxW+ "" ""+maxL);
    	}
    
    }
    

",JAVA
8344356,"
    t  = int(input())
    p1 = [0]
    p2 = [0]
    for noneed in range(t):
        n,k = map(int,input().split())
        if n>k:
            p1.append(n-k)
    
        elif n<k:
            p2.append(k-n)
    if max(p1) >max(p2):
        print(1,"" "",int(max(p1)))
    elif max(p2) >max(p1):
        print(2,"" "",int(max(p2)))

",PYTH
8327299,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
    int n,i,j,p=0,q=0;
    cin>>n;
    int arr[n][2];
    int a[n],b[n];
    for(i=0;i<n;i++)
    {
    for(j=0;j<2;j++)
    cin>>arr[i][j];
    }
    for(i=0;i<n;i++)
    {
    a[i]=0;
    b[i]=0;
    }
    for(i=0;i<n;i++)
    {
    for(j=0;j<=i;j++)
    {
    p=p+arr[j][0];
    q=q+arr[j][1];
    }
    if(p>q)
    a[i]=p-q;
    else
    b[i]=q-p;
    p=0;
    q=0;
    }
    sort(a,a+n);
    sort(b,b+n);
    if(a[n-1]>b[n-1])
    cout<<1<<"" ""<<a[n-1];
    else
    cout<<2<<"" ""<<b[n-1];
    }
    

",C++
8234173,"
    import java.io.*;
    import java.util.*;
    
    
    
    public class Main {
    	
    	
    	public static void main(String[] args) throws IOException {
    	
    		int L;
    		int N;
    		int lead = 0;
    		int winner = 1;
    		
    		
    		
    		InputStreamReader reader = new InputStreamReader(System.in);
    		BufferedReader br = new BufferedReader(reader);
    		
    		
    		
    		N = Integer.parseInt(br.readLine());
    		
    		for(int i = 0; i < N; i++) {
    			
    			String[] line = br.readLine().split("" "");
    			L = Integer.parseInt(line[0]) - Integer.parseInt(line[1]);
    			if(lead < Math.abs(L)) {
    			
    				if(L < 0) {
    					winner = 2;
    					lead = Math.abs(L);
    				} else {
    				
    					winner = 1;
    					lead = L;
    				}	
    			}	
    		}
    		
    		
    		System.out.println(winner+"" ""+lead);	
    	}
    }
    

",JAVA
7610514,"
    #include<stdio.h>
    int main()
    {
    	int lead1=0,lead2=0,cum1=0,cum2=0,c1,c2;
    	int i,t;
    	scanf(""%d"",&t);
    		for(i=0;i<t;i++)
    		{
    			scanf(""%d%d"",&c1,&c2);
    			cum1=+c1;
    			cum2=+c2;
    				if(cum1>cum2)
    				{
    					if(lead1 < (cum1-cum2))
    					{
    						lead1=(cum1-cum2);
    					}
    				}
    				
    				else
    				{
    					if(lead2<(cum2-cum1))
    					{
    						lead2=(cum2-cum1);
    					}
    				}
    		}
    			if(lead1>lead2)
    				{
    					
    					printf(""1 %d"",lead1);
    				}
    				else
    				{
    					
    					printf(""2 %d"",lead2);
    				}
    		return(0);
    }

",C
7533464,"
    #include <math.h>
    #include <cstdio>
    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
     
    #include <iostream>
    
    
    int main()
    { int T,x,y,A[10001][2],i,max,w;;
    cin>>T;
    max=A[0][0]=0;
    w=A[0][1]=0;
    for( i=0;i<T;i++)
    {cin>>x>>y;
    if(x>y)
    	{A[i][1]=1;
    A[i][0]=x-y;}
    else
    {
    	A[i][1]=2;
    A[i][0]=y-x;
    }
    
    
    if(A[i][0]>max)
    {
    	max=A[i][0];
    	w=A[i][1];
    }
    }
    cout<<w<<max;
    
    
    
    
    return 0;
    }

",C++
7304828,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int n;
    	int ban;
    	int sum1=0,sum2=0,max=0;
    	cin>>n;
    	int banda;
    	while(n--)
    	{
    		
    		int x,y;
    		cin>>x>>y;
    		sum1=sum1+x;
    		sum2=sum2+y;
            int val;
            if(sum2-sum1>0)
    		{
    			val=sum2-sum1;
    			ban=2;
    		}
    		else
    		{
    			val=sum1-sum2;
    			ban=1;
    		}
    		
    		if(max<val)
    		{
    			max=val;
    			banda=ban;
    		}
        }
        cout<<banda<<"" ""<<max<<endl;
    	return 0;
    }
     
     

",C++
7188370,"
    #include<stdio.h>
    #include<iostream>
    #include<math.h>
    using namespace std;
    int main()
    {
        int n,i,m,max;
        scanf(""%d"",&n);
        int ar[n],ar1[n],ar2[n];
        for(i=0;i<n;i++)
        {
                scanf(""%d %d"",&ar[i],&ar1[i]);
                 
        }
          for(i=0;i<n;i++)
          {
                          ar2[i]= fabs(ar[i]-ar1[i]);
                            
          }
          max=0;
          for(i=0;i<n;i++)
          {
                         if(ar2[i]>max)
                         {
                                   max=ar2[i];
                                   m=i;
                         }
          }
              
           if(ar[m]>ar1[m])
           {
                          printf(""1 %d"",max); 
           }
           else
           {
                          printf(""2 %d"",max);
           }
           return 0;
    }                          
    

",C++
7098146,"
    import java.util.*;
    import java.io.*;
    
    /* Name of the class has to be ""Main"" only if the class is public. */
    class Ideone
    {
    	public static void main (String[] args)
    	{
    		int n;
    Scanner ob1=new Scanner(System.in);
    int flag=1,max,t=0,i;
    int [] first=new int [10000];
    int [] second=new int [10000];
    int [] lead=new int[10000];
    Scanner ob2=new Scanner(System.in);
    
    
    System.out.println(""Enter the number of rounds"");
    n=ob1.nextInt();
    System.out.println(""Enter the points scored after each round"");
    for(i=0;i<n;i++)
    {
    System.out.println(""first"");
    first[i]=ob2.nextInt();
    System.out.println(""Second"");
    second[i]=ob2.nextInt();
    }
    
    for(i=0;i<n;i++)
    {
    lead[i]=first[i]-second[i];
    }
    
    max=lead[0];
    
    for(i=0;i<n;i++)
    {
    if(max<Math.abs(lead[i]))
    {
    max=Math.abs(lead[i]);
    t=lead[i];
    }}
    if(t>0)
    flag=1;
    else
    flag=2;
    if(flag==1)
    System.out.println(""Player 1 has won by maximum lead ""+max);
    else
    System.out.println(""Player 2 has won by maximum lead ""+max);
    	}
    }

",JAVA
7050205,"
    #include <iostream>
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {int x,y,d=0,l=0,w,p1=0,p2=0;
     int n;
     scanf(""%d"",&n);
      while(n--)
     {
    
        scanf(""%d%d"",&x,&y);
        p1=p1+x;
        p2=p2+y;
        d=p1-p2;
        d=abs(d);
        if(d>l)
          {
            l=d;
           if(d>0)
               w=1;
           else
              w=2;
          }
        }
    printf(""%d%d"",w,l);
    
        return 0;
    }
    

",C++
7029788,"
    #include <iostream>
    int main(){
        int N;
        short Si,Ti,maxdiff=0,tmpdiff;
        bool maxfirst=true,tmpfirst;
        scanf(""%d"",&N);
        while (N--) {
            scanf(""%hd %hd"",&Si,&Ti);
            tmpdiff=Si-Ti;
            if (tmpdiff<0) {
                tmpdiff=-tmpdiff;
                tmpfirst=false;
            }else{
                tmpfirst=true;
            }
            if (tmpdiff>maxdiff) {
                maxdiff=tmpdiff;
                maxfirst=tmpfirst;
            }
        }
        printf(""%d %d"",maxfirst?1:2,maxdiff);
        return 0;
    }

",C++
6668550,"
    #include<stdio.h>
    
    int main()
    {
    	long long int n,i,max=0,j,k;
    	scanf(""%lld"",&n);
    	long long int a,b,x=0,y=0,c;
    	
    	for(i=0;i<n;i++)
    	{
    		scanf(""%lld"",&a);
    		scanf(""%lld"",&b);
    		a=a+x;
    		b=b+y;
    		x=a;
    		y=b;
    	//	printf(""\na=%lld b=%lld"",a,b);
    		if(a>b)
    		{
    			c=a-b;
    			j=1;
    		}
    		else
    		{
    			c=b-a;
    			j=2;
    		}
    	//	printf("" C=%lld"",c);
    		if(c>max)
    		{
    			max=c;
    			k=j;
    		}
    	}
    	printf(""%lld %lld"",k,max);
    	return 0;
    }

",C
6606569,"
    #include <iostream>
    #include <stdio.h>
    #include <algorithm>
    using namespace std;
    
    void scanint(int &x)
    {
        register int c = getchar_unlocked();
        x = 0;
        int neg = 0;
        for(;((c<48 || c>57) && c != '-');c = getchar_unlocked());
        if(c=='-') {neg=1;c=getchar_unlocked();}
        for(;c>47 && c<58;c = getchar_unlocked()) {x = (x<<1) + (x<<3) + c - 48;}
        if(neg) x=-x;
    }
    void writeint (int n)
        {
            int N = n, rev, neg=0,count = 0;
            rev = N;
            if(n<0)
            {
                neg=1; n*=-1; N*=-1; rev*=-1;
                putchar_unlocked('-');
            }
            if (N == 0) { putchar_unlocked('0'); putchar_unlocked('\n'); return ;}
            while ((rev % 10) == 0) { count++; rev /= 10;} 
            rev = 0;
            while (N != 0) { rev = (rev<<3) + (rev<<1) + N % 10; N /= 10;}
            while (rev != 0) { putchar_unlocked(rev % 10 + '0'); rev /= 10;}
            while (count--) putchar_unlocked('0');
        }
    int main() {
        int t;
        scanint(t);
            int a[t],b[t];
            for(int i=0;i<t;i++)
            {
                scanint(a[i]);
                scanint(b[i]);
            }
            int max=0,maxper=1;
            for(int i=0;i<t;i++)
            {
                if(abs(a[i]-b[i])>max)
                {
                    max=abs(a[i]-b[i]);
                    if(a[i]>b[i])
                    maxper=1;
                    else
                    maxper=2;
                }
            }
            writeint(maxper);
            putchar_unlocked(' ');
            writeint(max);
            putchar_unlocked('\n');
    	return 0;
    }
    

",C++
6577125,"
    t=input()
    l=[]
    while t:
        t-=1
        a,b=map(int,raw_input().split())
        l.append(int(a)-int(b))
    c1=max(l)
    c2=min(l)
    if abs(c1)>abs(c2):
        print ""1"",abs(c1)
    else:
        print ""2"",abs(c2)

",PYTH
6453976,"
    #include <iostream>
    using namespace std;
    int main()
    {
        int round , score1 , score2 , max_score , who_wins;
        max_score = 0;
        cin>>round;
        for (int i = 0 ; i < round ; i++)
        {
            cin >> score1 >> score2;
            if (score1 - score2 > max_score)
            {
                max_score = score1 - score2;
                who_wins = 1;
            }
            else if (score2 - score1 > max_score)
            {
                max_score = score2 - score1;
                who_wins = 2;
            }
        }
        cout<<who_wins<<"" ""<<max_score;
    }
    

",C++
6020543,"
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
        int n,j,i,c,a[10000],b[10000],r[10000],s1=0,s2=0;
          int d;
    
    
        scanf(""%d"",&n);
    
         for(i=0;i<n;i++)
         {
             scanf(""%d%d"",&a[i],&b[i]);
    
             if(a[i]>=b[i])
             {
    
                 d=a[i]-b[i];
                 d=abs(d);
                 r[i]=d;
             }
             else
             {
    
    
                 d=a[i]-b[i];
                 d=abs(d);
                 r[i]=d;
             }
    
    
             s1+=a[i];
             s2+=b[i];
    
    
             //printf(""%d\n"",s1);
             //printf(""%d\n"",s2);
             //printf(""%d\n"",d);
    
         }
    
    
         for(j=0;j<n;j++)
         {
             if(r[j]>=r[j+1])
                c=r[j];
             // printf(""%d\n"",r[j]);
         }
    
    
         if(s1>s2)
    
             printf(""1"");
             else
                printf(""2"");
    
    
                printf(""%d"",c);
    
    
    
    
    
    
    
    
    
    
        return 0;
    }
    

",C
6016890,"
    def lead():
    	player1 = []
    	player2 = []
    	player = []
    	scores = []
    
    	N = int(raw_input(""""))
    	if N <= 10000:
    		while N > 0:
    			S,T = raw_input("""").split()
    			S = int(S)
    			T = int(T)
    			if (S >= 1 and S <= 1000 ) and (T >= 1 and T<= 1000):
    				player1.append(S)
    				player2.append(T)
    			N -= 1
    
    	for i in range(len(player1)):
    		if player1[i] > player2[i]:
    			scores.append(player1[i]-player2[i])
    			player.append(1)
    		elif player1[i] < player2[i]:
    			scores.append(player2[i]-player1[i])
    			player.append(2)
    
    	print player[(scores.index(max(scores)))], max(scores) 
    
    lead()

",PYTH
5834389,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int n;
    	int a,b;
    	int c,d=c=-1;
    	cin>>n;
    	while(n--)
    	{
    		cin>>a>>b;
    		if(a>=b)
    		{
    			if((a-b)>c)c=a-b;
    		}
    		else if(a<=b&&(b-a)<d)
    		d=b-a;
    	}
    	if(c>d)
    	cout<<""1 ""<<c<<""\n"";
    	else cout<<""2 ""<<d<<""\n"";
    	return 0;
    }
    

",C++
5784881,"
    #include<iostream>
    #include<stdlib.h>
    
    using namespace std;
    
    int main()
    {
    	int round,a[10000],b[10000],i,j,max=0;
    	
    	cin>>round;
    	
    	for(i=0; i<round; i++)
    	{
    		cin>>a[i]>>b[i];
    		if(i>0)
    		{
    			a[i]+=a[i-1];
    			b[i]+=b[i-1];
    		}
    		if(a[i]-b[i]>max)
    		{
    			max=a[i]-b[i];
    		}
    	}
    	
    	if(max>0)
    	{
    		cout<<endl<<""1""<<"" ""<<max;
    	}
    	else
    	{
    		cout<<endl<<""2""<<"" ""<<abs(max);
    	}
    	return 0;
    }

",C++
5669320,"
    #include <iostream>
    #include <stdio.h>
    
    int main()
    {
    	int n;
    	scanf(""%d"",&n);
    	printf(""\n"");
    	int a[n],b[n],c[n],Wa=0,Wb=0;
    	for (int i = 0; i < n; i++)
    	{
            scanf(""%d\t%d"",&a[i],&b[i]);
    
    		if (a[i]>b[i])
    	    {
    			Wa++;
    			c[i]=a[i]-b[i];
    	    }
    		else
    			{
    			    Wb++;
    			    c[i]=b[i]-a[i];
    			}
    	}
    	/*if (Wa>Wb)
    	{
    		Wa=1;
    		printf(""%d\t"",Wa);
    	}
    	else
        {
    		Wb=2;
    	printf(""%d\t"",Wb );
        }*/
        int max=c[0];
        for (int i = 0; i < n; i++)
        {
        	if (c[i]> max)
        	{
        		max =c[i];
        	}
        }
        for(int i=0;i<n;i++)
        {
           if(a[i]>b[i])
           {
               if(max==a[i]-b[i])
               {
                   Wa=1;
    		printf(""%d\t"",Wa);
               }
               }
               else if(b[i]>a[i])
               {
                   if(max==b[i]-a[i])
                   {
                       	Wb=2;
    	printf(""%d\t"",Wb );
    
                   }
               }
        printf(""%d\n"",max );
    	return 0;
    }}
    

",C++
5463166,"
    #include<iostream>
    using namespace std;
    int main()
    {
    	int n,s,t;
    	int max=0,diff,f=0,ss=0,ts=0;
    	cin>>n;
    	while(n--)
    	{
    		cin>>s>>t;
    		ss+=s;ts+=t;
    		if(ss>ts){
    			if(max<(ss-ts)){
    				max=ss-ts;
    				f=1;
    			}
    		}
    		else if(ts>ss){
    			if(max<(ts-ss)){
    				max=ts-ss;
    				f=2;
    			}
    		}
    	}
    	cout<<f<<"" ""<<max;	
    	return 0;
    }

",C++
5455006,"
    #include<stdio.h>
    #include<math.h>
    int main()
    {
    	int n,l=0,i,temp,temp2,temp3=0;
    	int si=0,ti=0;
    	scanf(""%d"",&n);
    	for(i=1;i<=n;i++)
    	{
    		scanf(""%d %d"",&temp,&temp2);
    		si=si+temp;
    		ti=ti+temp2;
    		temp3=si-ti;
    		if(abs(temp3)>abs(l))
    			l=temp3;
    	}
    	if(l>0)
    		println(""1 %d"",l);
    	else
    		println(""2 %d"",abs(l));
    	return 0;
    }
    	
    		
    		

",C
5272775,"
    #include<stdio.h>
    int main()
    {
    	int n,i,t;
    	int w,l;
    	scanf(""%d"",&n);
    	int si[n],ti[n],ld[n];
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d%d"",&si[i],&ti[i]);
    		ld[i]=si[i]-ti[i];
    	}
    	int max=0,min=0;
    	for(i=0;i<n;i++)
    	{
    		if(ld[i]>max)
    			max=ld[i];
    		if(ld[i]<min)
    			min=ld[i];
    	}
    		if(max>min*(-1))
    		{
    			l=max;
    			w=1;	
    		}
    		else if(min*(-1)>max)
    		{
    			l=min*(-1);
    			w=2;
    		}
    	printf(""%d %d\n"",w,l);
    	return 0;
    }
    

",C
5227810,"
    def billiard():
        lead = []
        winner = []
        a = int(raw_input())
        for e in range(a):
            b = raw_input().split()
            for e in b:
                if int(b[0]) > int(b[1]):
                    winner.append(1)
                    lead.append(int(b[0]) - int(b[1]))
                else:
                    winner.append(2)
                    lead.append(int(b[1]) - int(b[0]))
        print (""%d""' '""%d"")%(winner[lead.index(max(lead))],max(lead))
    billiard()
            
            
    

",PYTH
5195150,"
    #include<stdio.h>
    int main()
    {
    int N;
    scanf(""%d"",&N);
    int P1[N+1],P2[N+1],lead[N+1],flag[N+1],max,pos=0,i;
    for(i=0;i<N;i++)
    scanf(""%d %d"",&P1[i],&P2[i]);
    
    for(i=0;i<N;i++)
    {
       if(P1[i]>P2[i])
        {
         lead[i]=P1[i]-P2[i];
          flag[i]=1;
          }
         else
           if(P1[i]<P2[i])
           {
            lead[i]=P2[i]-P1[i];
          flag[i]=2;
           }
          
    }
    
    max=lead[0];
    
    for(i=1;i<N;i++)
    {
      if(lead[i]>max)
       {
         max=lead[i];
         pos=i;
        }
    }
    
    printf(""%d %d"",flag[pos],max);
    
    
    return 0;
    }

",C
4925505,"
    #include<stdio.h>
    #include<stdlib.h>
    main()
    {
        int *p,*q,**r,n,i,big,k=0,sum1=0,sum2=0;
        scanf(""%d"",&n);
        p=(int*)calloc(n,sizeof(int));
        q=(int*)calloc(n,sizeof(int));
        r=(int**)calloc(n,sizeof(int*));
        for(i=0;i<n;i++)
            *(r+i)=(int*)calloc(2,sizeof(int));
        i=0;
        while(i<n)
        {
            scanf(""%d"",p+i);
            scanf(""%d"",q+i);
            sum1+=*(p+i);
            sum2+=*(q+i);
            if(sum1>sum2)
            {
                *(*(r+i)+0)=1;
                *(*(r+i)+1)=sum1-sum2;
            }
            else
            {
                *(*(r+i)+0)=2;
                *(*(r+i)+1)=sum2-sum1;
            }
            i++;
        }
        big=0;
        for(i=0;i<n;i++)
        {
            if((*(*r+i)+1)<big)
            {
                big=*(*(r+i)+1);
                k=i;
            }
        }
        printf(""%d %d"",*(*(r+k)+0),*(*(r+k)+1));
    }
    

",C
4903866,"
    #include<stdio.h>
    
    int main()
    {
    int round,a,b,p=0,p1=0,p2=0,r=0;
    int s[2]={0,0};
    scanf(""%d"",&round); fflush(stdin);
    
    while(round--)
    {
    	scanf(""%d%d"",&a,&b);	fflush(stdin);
    	p1+=a;	p2+=b;
    
    	r=a-b;
    	if(s[0]<r)	s[0]=r;
    	r=b-a;
    	if(s[1]<r)	s[1]=r;
    }
    
    if(p1>p2)
    	p=1;
    else
    	p=2;
    
    printf(""%d %d\n"",p,s[p-1]);
    
    getchar();
    return 0;
    }

",C++
4887059,"
    #include<stdio.h>
    
    int main()
    {
        int a, b, n, sum, c, p, q;
        scanf(""%d"", &n);
        if(n>10000) return 0;
        while(n--){
            scanf(""%d %d"", &a, &b);
            if(a<1 || a>1000 || b<1 || b>1000) return 0;
            if(a == b) return 0;
            if(a>b){
                sum = a - b;
                p = 1;
            }
            if(a<b){
                sum = b - a;
                p = 2;
            }
            if(sum == c) return 0;
            if(sum > c){
                c = sum;
                q = p;
            }
        }
    
        printf(""%d %d\n"", q, c);
        return 0;
    }
    

",C
4887022,"
    #include<stdio.h>
    
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	
    	int p1[t],p2[t];
    	int i=0;
    	while(i<t)
    	{
    		scanf(""%d%d"",&p1[i],&p2[i]);
    		i++;
    	}
    	int w=1,maxlead=0;
    	for(i=0;i<t;i++)
    	{
    		if(p1[i]>p2[i])
    		{
    			if(p1[i]-p2[i]>maxlead)
    			{
    				w=1;
    				maxlead=p1[i]-p2[i];
    			}
    		}
    		else
    		{
    			if(p2[i]-p1[i]>maxlead)
    			{
    				w=2;
    				maxlead=p2[i]-p1[i];
    			}
    		}
    	}
    	printf(""\n%d%d"",w,maxlead);
    	return 0;
    }
    

",C
4602657,"
    #include<stdio.h>
    #define gc getchar_unlocked
    typedef long long LL;
    LL get_i(){
    	char c=gc();
    	while(c<'0' || c>'9') c=gc();
    	LL ret=0;
    	while(c>='0' && c<='9'){
    		ret=(ret<<3)+(ret<<1)+c-'0';
    		c=gc();
    	}
    	return ret;
    }
    int main(){
    	LL n,i,r[2],w[2],s;
    	n=get_i();
    	r[0]=get_i();
    	r[1]=get_i();
    	w[0]=(r[0]>r[1])?0:1;
    	w[1]=(r[0]>r[1])?(r[0]-r[1]):(r[1]-r[0]);
    	n--;
    	while(n--){
    		//s=get_i();
    		//t=get_i();
    		r[0]+=get_i();
    		r[1]+=get_i();
    		if((s=r[0]-r[1])>w[1]){
    			w[0]=0;
    			w[1]=s;
    		}
    		else if((s=r[1]-r[0])>w[1]){
    			w[0]=1;
    			w[1]=s;
    		}
    	}
    	printf(""%lld %lld\n"",w[0]+1,w[1]);
    	return 0;
    }
    

",C
4573149,"
    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	int  i;
    	long int inp[100],T,l=0,test,t;
    	scanf(""%ld"",&T);
    	for(i=0;i<T;i++)
    	{
    		scanf(""%ld"",&inp[i]);
    		l++;
    		
    	}
    		
    	t=inp[0];
    	i=0;
    	while(i<l)
    	{
    		if(inp[i]<t&&i>=2)
    		{
    			test=inp[i-1];
    			inp[i-1]=inp[i];
    			inp[i]=test;
    			i--;
    			t=inp[i-1];
    			
    		}
    		else if(inp[i]<t&& i==1)
    		{
    			test=inp[i-1];
    			inp[i-1]=inp[i];
    			inp[i]=test;
    			
    		}
    		else if(inp[i]>=t)
    		{
    			i++;
    		}
    	}
    	
    
    	for(i=0;i<T;i++)
    	{
    		printf(""%ld\n"",inp[i]);
    	}
    	return 0;
    }
    

",C
4502702,"
    #include<stdio.h>
    int main()
    {
        int test,max=0,i,diff=0,flag=1;
        int ar1[1001],ar2[1001];
        scanf(""%d"",&test);
        for(i=0;i<test;i++)
               scanf(""%d%d"",&ar1[i],&ar2[i]);
        for(i=0;i<test;i++)
        {
            diff=(ar1[i]>ar2[i])?(ar1[i]-ar2[i]):(ar2[i]-ar1[i]);
            if(diff>max)
            {
            	max=diff;
            
                if(ar1[i]>ar2[i])
                    flag=i%2+1;
                    
                else if(ar2[i]>ar1[i])
                  flag=i%2+1;
                   //printf(""%d %d\n"",flag,max);
            }
            
          
        }
         printf(""%d %d"",flag,max);
        return 0;
        }

",C
4330594,"
    #include<stdio.h>
    
    int main(){
        
        int i,n;
        
        scanf(""%d\n"",&n);
        int player1[n],player2[n],leader[n],lead[n];
        
        for(i=0;i<n;i++){
    	scanf(""%d"", &player1[i]);
    	scanf(""%d"", &player2[i]);
    	}
        for(i=0;i<n;i++){
    	
    	if(player1[i]>=player2[i]){
    	    
    	    leader[i]=1;
    	    lead[i]= player1[i]-player2[i];
    	
    	}
    	
    	else{
    	   
    	    leader[i] = 2;
    	    lead[i] = player2[i] - player1[i];
    	
    	}
    	
        }
        
        i=0;
        int max = lead[i];
        int winner = leader[i];
        
        for(i=0;i<n;i++){
    	
    	if(max < lead[i]){
    	    
    	    max = lead[i];
    	    winner = leader[i];
    	}
        
        }
    
        printf(""%d %d"",winner,max);
        return 0;
    
    }
    

",C
4139614,"
    #include <iostream>
    #include <stdio.h>
    
    using namespace std;
    
    int main()
    {
    	long int count;
    	cin>>count;
    	int maximum=-10000;
    	int index;
    	int x=1;
    
    	while(x<=count)
    	{
    	       int p1;
    	       int p2;
    	       scanf(""%d"",&p1);
    	       scanf(""%d"",&p2);
    	
    	    	   if(p1-p2>0)
    	    	   {
    	      	 	if(p1-p2>=maximum)
    	                         {	       		
    	       		      maximum=(p1-p2);
    	       	          	       index=1;
    	       	            }
    
                                  }
    	       	
    	     	  else
    	      	 {
                          	       if(p2-p1>=maximum)
                            	     {
    	       		maximum=(p2-p1);
    	       	              index=2;
    
    	                   }
    	               }
    
    
    
                x++;
                }
    
                cout<<index<<"" ""<<maximum;
    
                return 0;
    
    
    }

",C++
4123471,"
    #include <iostream>
    #include <string>
    #include <sstream>
    #include <cmath>
    
    using namespace std;
    
    int main()
    {
    	string input;
    	getline(cin, input);
    	istringstream iss(input);
    
    	int rounds;
    	iss >> rounds;
    
    	int maxScoreDiff = 0;
    	int winner = 0;
    
    	for (int i = 0; i < rounds; i++)
    	{
    		getline(cin, input);
    		istringstream iss(input);
    		int scoreOfLeader1, scoreOfLeader2;
    
    		iss >> scoreOfLeader1 >> scoreOfLeader2;
    
    		if (abs(scoreOfLeader1 - scoreOfLeader2) > maxScoreDiff)
    		{
    			maxScoreDiff = abs(scoreOfLeader1 - scoreOfLeader2);
    			winner = scoreOfLeader1 > scoreOfLeader2 ? 1:2;
    		}
    	}
    
    	cout << winner << "" "" << maxScoreDiff;
    
    	return 0;
    }

",C++
3742432,"
    #include <stdio.h>
    int main(){
        int t,i,a,b,w,maxm=0,k;
        scanf(""%d"",&t);
        for(i=0;i<t;i++)
        {
            scanf(""%d%d"",&a,&b);
            if(b>a){
                k=b-a;
                if(k>maxm){
                    maxm=k;
                    w=2;
                }
            }
            else{
                k=a-b;
                if(k>maxm){
                    maxm=k;
                    w=1;
                }
            }
    
        }
        printf(""%d%d"",w,maxm);
    
    
    
        return 0;
    }
    

",C
3450744,"
    #include<iostream>
    using namespace std;
    int main()
    {
        int n;
        int list[10000][2];
        cin>>n;
        int max=0,postn;
        for(int i=0;i<=(n-1);i++)
        {
                cin>>list[i][0]>>list[i][1];
                if((list[i][0]-list[i][1])>=max)
                {
                                              max=(list[i][0]-list[i][1]);
                                              postn=1;
                }
                else if((list[i][1]-list[i][0])>=max)
                {
                     max=(list[i][1]-list[i][0]);
                     postn=2;
                }
        }
        cout<<postn<<"" ""<<max;
        return 0;
    }
                     
                                    

",C++
3132053,"
    #include<stdio.h>
    int main()
    {
    	long int n,x[10][10];
    	int a,si=0,ti=0;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    		for(j=0;j<=1;j++)
    			scanf(""%d"",&x[i][j]);
    	
    	for(i=0;i<n;i++)
    		si+=x[i][0];
    	
    	for(i=0;i<n;i++)
    		ti+=x[i][1];
    		
    	if(si>ti)
    	{
    		a=1;
    		win=si-ti;
    	}
    	else{
    	 a=2;
    	win=ti-si;
    	}
    	
    	printf(""\n%d %d"",a,win);
    }

",C
3105449,"
    #include <iostream>
    #include <fstream>
    #include <iomanip>
    #include <math.h>
    #include <limits.h>
    #include <algorithm>
    #include <list>
    #include <stack>
    #include <queue>
    #include <set>
    #include <map>
    #include <string>
    #include <sstream>
    
    using namespace std;
    typedef long long ll;
    typedef unsigned long long ull;
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    int n,s,t,maxi,winner;
    int main()
    {
    	scanf(""%d"",&n);
    	maxi=-1;
    	for(int i=1;i<=n;i++)
    	{
    		scanf(""%d%d"",&s,&t);
    		if(s>t)
    		{
    			if(s-t>maxi)
    			{
    				maxi=s-t;
    				winner=1;
    			}
    		}
    		else
    		{
    			if(t-s>maxi)
    			{
    				maxi=t-s;
    				winner=2;
    			}
    		}
    	}
    	printf(""%d %d\n"",winner,maxi);
    	return 0;
    }

",C++
2695052,"
    #include<stdio.h>
    #include<stdlib.h>
    
    int main()
    {
    	int *a,*b,*c,*d,i,t,e,f,s=0,p=0;
    	scanf(""%d"",&t);
    
    		c=(int*)malloc(sizeof(int)*t);
    		d=(int*)malloc(sizeof(int)*t);
    		a=(int*)malloc(sizeof(int)*t);
    		b=(int*)malloc(sizeof(int)*t);
    	for(i=0;i<t;i++)
    	{
    		*(c+i)=0;
    		*(d+i)=0;
    		scanf(""%d%d"",(a+i),(b+i));
    		s+=*(a+i);
    		p+=*(b+i);
    		if(s>p)
    		*(c+i)= s - p;
    		else
    		*(d+i)= p - s;
    	}
    	for(i=1;i<t;i++)
    	{
    	     if( *(c+0) < *(c+i))
    	     *(c+0)=*(c+i);
    	}
    	e=*(c+0);
    	for(i=1;i<t;i++)
    	{
    	     if(*(d+0)<*(d+i))
    	     *(d+0)=*(d+i);
    	}
    	f=*(d+0);
    	if(e<f)
    	printf(""2 %d"",f);
    	else
    	printf(""1 %d"",e);
    	return 0;
    }

",C
2587765,"
    #include<stdio.h>
    int mod(int k){
        if(k>0)
        return(k);
        return(-k);
    }
    int main()
    {
        int n,i;
        scanf(""%d"",&n);
        int a[n],p,q;
        for(i=1;i<=n;i++)
        {
          scanf(""%d%d"",&p,&q);
          a[i]=p-q;
          }
         int t;
         t=a[n];
         while(--n)
         {
               if(mod(t)<mod(a[n]))
               t=a[n];
               }
         if(t<0)
         {
               t=mod(t);
         printf(""%d%d"",2,t);
         }
         else
         printf(""%d %d\n"",1,t);
         return 0;
         }

",C
2554262,"
    #include <iostream>
    #include <cmath>
    
    
    using namespace std;
    
    int * p1=NULL;
    int * p2=NULL;
    int * roundvalue=NULL;
    int * roundwinner=NULL;
    
    int numofrounds =0;
    
    
    void readInput()
    {
    	int t=0;
    	for(t=0;t<numofrounds;t++)
    	{
    		cin>>p1[t]>>p2[t];
    	}
    }
    
    int findWinner()
    {
    	int t=0;
    	int largest = 0;
    	int ind = 0;
    	for(t=0;t<numofrounds;t++)
    	{
    		if(largest < roundvalue[t])
    		{
    			largest = roundvalue[t]	;
                ind = t;	
    		}
    		
    	}
    	return ind;
    }
    
    void compute()
    {
    	int t=0;
    	int tem =0;
    	roundvalue = new int[numofrounds*sizeof(int)];
    	roundwinner = new int[numofrounds*sizeof(int)]; 
    	
    	for(t=0;t<numofrounds;t++)
    	{
    		if(p1[t]<p2[t])
    		{
    			roundvalue[t]=p2[t]-p1[t];
    			roundwinner[t]=2;			
    		}
    		else
    		{
    			roundvalue[t]=p1[t]-p2[t];
    			roundwinner[t]=1;
    		}
    	}
        tem = findWinner();
    	cout<<roundwinner[tem]<<"" ""<<roundvalue[tem]<<endl;
    
    	delete[] roundvalue;
    	delete[] roundwinner;
    }
    
     int main(int argc, char const *argv[])
    {
    	/* code */
    	
    	cin>>numofrounds;
    	
    	p1 = new int[numofrounds*sizeof(int)];
    	p2 = new int[numofrounds*sizeof(int)]; 
    	readInput();
    	compute();
    
    	delete[] p1;
    	delete[] p2;
    	system(""pause"");
    	return 0;
    }
    

",C++
2312208,"
    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 num = Integer.parseInt(br.readLine());
    
    	int s=0,t=0;
    	int winner = 1, lead = 0;
    
    	for(int i=0;i<num ;i++){
    		String words[] = (br.readLine()).split("" "");
            s = Integer.parseInt(words[0]);
            t = Integer.parseInt(words[1]); 
    		if(s > t){
        		if(lead< s-t){
        			winner = 1;
        			lead = s-t;
        		} 
        	}
        	else{
        		if(lead < t-s){
        			winner = 2;
        			lead = t-s;
        		}
        	}
        }
        System.out.println(winner+"" ""+lead);
    }	
    }

",JAVA
1934761,"
    n = int(raw_input())
    T = [0, 0]
    p = 0
    score = 0
    for i in xrange(0, n):
        ss = raw_input().split()
        T[0] += int(ss[0])
        T[1] += int(ss[1])
        d = abs(T[0] - T[1])
        if (d > score):
            if (T[0] > T[1]): p = 0
            else: p = 1
            score = d
    print 1+p, score

",PYTH
1806987,"
    #include<stdio.h>
    int main(){
        unsigned int N;
        int max=-1;
        int diff,f,s,w;
         scanf(""%ud"",&N);
         
         while(N--){
                    scanf(""%d %d"",&f,&s);
                    w=0;
                      if(f>s){
                              diff=f-s;
                               w=1;
                              if(diff>max){
                                           max=diff;
                                          
                                           }
                              }
                       if(s>f){  w=2;
                                    diff=s-f;
                                    if(diff>max)
                                       max=diff;
                                      
                                   }             
                                   
                                     
                  }
                  
        if(N>0){
                                
                                printf(""%d\t%d"",w,max);
                                }
        
        return(0);
        
        
        }
    

",C
1643043,"
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {   int p,n,i,p1,p2,c=0,d;
    
        scanf(""%d"",&n);
        for(i=0;i<n;i++)
        {
            scanf(""%d%d"",&p1,&p2);
            d=p1-p2>0?p1-p2:p2-p1;
            c=c>d?c:d;
            if(c>0)
            p=1;
            else
            p=2;
        }
        printf(""%d %d"",p,p==1?c:-c);
        return 0;
    }
    

",C
1566685,"
    import java.io.*;
    
    public class Main {
    
    	public static void main(String[] args) throws IOException 
    	{
    		PrintWriter pr=new PrintWriter(new BufferedOutputStream(System.out));
    
    		//readFileWithManyTestCases();
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		
    
    		int taille = Integer.parseInt(br.readLine());
    		int winner = 0;
    		int maxLead = 0;
    		
    		for(int i=0; i<taille; i++)
    		{
    			String[] input = br.readLine().split("" "");
    			
    			int score1 = Integer.parseInt(input[0]);
    			int score2 = Integer.parseInt(input[1]);
    			
    			int currentLead = Math.abs(score1-score2);
    			
    			if(currentLead > maxLead)
    			{
    				maxLead = currentLead;
    				if(score1 > score2) winner = 1;
    				else winner = 2;
    			}
    			
    		}
    		pr.println(winner + "" "" + maxLead);
    		pr.close();
    			
    	}
    }

",JAVA
926630,"
    #include<stdio.h>
    
    int main()
    {
        int r, arr[10000][2],i,w[10000][2],max[2],j;
        scanf(""%d"",&r);
        max[0]=0; max[1]=0; 
        for(i=0;i<r;i++)
        {
                        scanf(""%d %d"",&arr[i][0],&arr[i][1]); 
                        if(arr[i][0]>arr[i][1])
                        {
                        w[i][0]=arr[i][0]-arr[i][1];
                        w[i][1]=1;
                        if(w[i][0]>max[1])
                        {
                                          max[1]=w[i][0];
                                          max[0]=w[i][1];
                        }
                        }
                        else
                        {
                        w[i][0]=arr[i][1]-arr[i][0];
                        w[i][1]=2;
                        if(w[i][0]>max[1])
                        {
                                          max[1]=w[i][0];
                                          max[0]=w[i][1];
                        }
                        }
        }      
          
        
                       printf(""%d %d"",max[0],max[1]);
                         
                         return 0;
                         }
                                 

",C
865638,"
    #include<stdio.h>
    
    
     
    int main()
    {
    	int t,i,x=0,y=0,w,ms,a,b;
    	scanf(""%d"",&t);
    	ms=0;
    
    	for (i=0;i<t;i++)
    	{
    		scanf(""%d%d"",&a,&b);
    		x=x+a;
    		y=y+b;
    		if (x-y>0)
    		{
    			if (x-y>ms)
    			{
    				ms=x-y;
    				w=1;
    			}
    		}
    		else 
    		{
    			if (y-x>ms)
    			{
    				ms=y-x;
    				w=2;
    			}
    		}
    	}
    	printf(""%d %d\n"",w,ms);
    	
         return 0;
    } 

",C
786431,"
    program leadgame;
    var N,S,T,i,max,winner:integer;
    BEGIN
    readln(N);
    for i:=1 to N do
    begin
    Readln(S,T);
    if i=1  then begin
                 max:=abs(S-T);
                 if S-T>=0 then winner:=1
                          else winner:=2;
                 end;
    if abs(S-T)>max then begin
                         max:=abs(S-T);
                         if S-T>=0 then winner:=1
                                  else winner:=2;
                         end;
    end;
    writeln(winner,' ',max);
    END.

",PAS fpc
625454,"
    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    
    using namespace std;
    
    int main()
    {
        int a,s1,s2;
        cin>>a;
        
        int l1=0,l2=0,lead=0;
        
        while(a--)
        {
                  cin>>s1>>s2;
                  l1=l1+s1;
    	          l2=l2+s2;
                  lead = lead>abs(s1-s2) ? lead :abs(s1-s2);	
        }           
        
        if(l1>l2)
        cout<<""1"" <<lead;
        else
        cout<<""2"" <<lead;
        return 0;
    }
    

",C++
603440,"
    import java.util.Scanner;
    import java.math.BigDecimal;
    import java.io.File;
    import java.io.FileNotFoundException;
    
    
    public class Main{
    
    public static void main(String[] args){
    
    
    Scanner sc= new Scanner(System.in);
    
    int T = sc.nextInt();
    int W=1;
    int L=0;
    for(int i=0;i<T;i++)
    {
    	int s1=sc.nextInt();
    	int s2=sc.nextInt();
    	int temp=s1-s2;
    	if(s1>s2)
    	{
    		if((s1-s2)>L)
    		{
    			L=s1-s2;
    			W=1;
    		}
    	}
    	else
    	{
    		if((s2-s1)>L)
    		{
    			L=s2-s1;
    			W=2;
    		}
    	}	
    }
    System.out.println(W+"" ""+L);
    }
    
    
    
    
    }

",JAVA
583478,"
    /* ******************************************* */
    // \_/\_/\_/\_/---Coded by Panks---\_/\_/\_/\_/ //
    /* ******************************************* */
    
    ////////////////////SHORTHANDS\\\\\\\\\\\\\\\\\\\\\
    #define ll long long
    #define ull unsigned long long
    
    #define FOR(i,a,b) for(int i=a;i<=b;i++)
    #define REP(i,n) FOR(i,0,n-1)
    
    #define FORD(i,a,b) for(int i=a;i>=b;i--)
    #define REPD(i,n) FOR(i,n-1,0)
    
    #define testcase(t) int t;scanf(""%d"",&t);while(t--)
    #define s(x) scanf(""%d"",&x)
    #define sl(x) scanf(""%lld"",&x)
    #define ss(x) scanf(""%s"",x)
    
    #define p(x) printf(""%d"",x)
    #define pl(x) printf(""%lld"",x)
    #define ps(x) printf(""%s"",x)
    
    #define pn(x) printf(""%d\n"",x)
    #define pln(x) printf(""%lld\n"",x)
    #define psn(x) printf(""%s\n"",x)
    //////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\
    
    
    #include<iostream>
    //#include<cmath>
    #include<cstring>
    #include<cstdio>
    #include<cstdlib>
    #include<vector>
    
    using namespace std;
    
    // ---------Fast IO using getchar----------
    int getint()
    {
        int c = 'a';
        while (!(c >= '0' && c <= '9') && c != '-')
            //c = getchar_unlocked();
            c = getchar();
        int c2;
        if (c != '-')
            c2 = c;
        else
            c2 = '0';
        int res = 0;
        while((c2 >= '0' && c2 <= '9'))
        {
            res = (res << 3) + (res << 1) + (c2 - '0');
            //c2 = getchar_unlocked();
            c2 = getchar();
        }
        return res * (c == '-' ? -1 : 1);
    }
    // -------------------------------------------------
    
    //~~~~~~~~~~~~~~~~~~~~Actual code~~~~~~~~~~~~~~~~~~~~~//
    
    
    using namespace std;
    
    
    
    int main()
    {
        int n,s1,s2,wlead=0,lead,k;
        cin>>n;
    
        while(n--)
        {
    
            cin>>s1>>s2;
            lead=(s1-s2);
            if(lead<0){lead=~lead;}
            if(lead>wlead)
            {
                if(s1>s2){k=1;}
                else{k=2;}
                wlead=lead;
            }
        }
        printf(""%d %d\n"",k,wlead);
    
    }
    
    
    
    //
    //#include <stdio.h>
    //
    //int main()
    //{
    //
    //    int rounds,p1max=0,p2max=0,lead=0;
    //    scanf(""%d"",&rounds);
    //
    //    for(int i=0; i<rounds; i++)
    //    {
    //        int p1,p2;
    //        scanf(""%d%d"",&p1,&p2);
    //
    //        lead += p1 - p2;
    //
    //        if(lead>0)
    //        {
    //            if(p1max < lead)
    //                p1max = lead;
    //        }
    //        else if(p2max < (-lead))
    //            p2max = (-lead);
    ////		printf(""%d\n"",lead);
    //    }
    //
    //    if(p1max > p2max)
    //        printf(""1 %d\n"",p1max);
    //    else
    //        printf(""2 %d\n"",p2max);
    //
    //
    //    return 0;
    //}
    //
    

",C++
583477,"
    /* ******************************************* */
    // \_/\_/\_/\_/---Coded by Panks---\_/\_/\_/\_/ //
    /* ******************************************* */
    
    ////////////////////SHORTHANDS\\\\\\\\\\\\\\\\\\\\\
    #define ll long long
    #define ull unsigned long long
    
    #define FOR(i,a,b) for(int i=a;i<=b;i++)
    #define REP(i,n) FOR(i,0,n-1)
    
    #define FORD(i,a,b) for(int i=a;i>=b;i--)
    #define REPD(i,n) FOR(i,n-1,0)
    
    #define testcase(t) int t;scanf(""%d"",&t);while(t--)
    #define s(x) scanf(""%d"",&x)
    #define sl(x) scanf(""%lld"",&x)
    #define ss(x) scanf(""%s"",x)
    
    #define p(x) printf(""%d"",x)
    #define pl(x) printf(""%lld"",x)
    #define ps(x) printf(""%s"",x)
    
    #define pn(x) printf(""%d\n"",x)
    #define pln(x) printf(""%lld\n"",x)
    #define psn(x) printf(""%s\n"",x)
    //////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\
    
    
    #include<iostream>
    //#include<cmath>
    #include<cstring>
    #include<cstdio>
    #include<cstdlib>
    #include<vector>
    
    using namespace std;
    
    // ---------Fast IO using getchar----------
    int getint()
    {
        int c = 'a';
        while (!(c >= '0' && c <= '9') && c != '-')
            //c = getchar_unlocked();
            c = getchar();
        int c2;
        if (c != '-')
            c2 = c;
        else
            c2 = '0';
        int res = 0;
        while((c2 >= '0' && c2 <= '9'))
        {
            res = (res << 3) + (res << 1) + (c2 - '0');
            //c2 = getchar_unlocked();
            c2 = getchar();
        }
        return res * (c == '-' ? -1 : 1);
    }
    // -------------------------------------------------
    
    //~~~~~~~~~~~~~~~~~~~~Actual code~~~~~~~~~~~~~~~~~~~~~//
    
    
    using namespace std;
    
    
    
    int main()
    {
        int n,s1,s2,wlead=0,lead,k;
        cin>>n;
    
        while(n--)
        {
    
            cin>>s1>>s2;
            lead=(s1-s2);
            if(lead<0){lead=~lead;}
            if(lead>wlead)
            {
                k=s1>s2 ? 1:2;
                wlead=lead;
            }
        }
        printf(""%d %d\n"",k,wlead);
    
    }
    
    
    
    //
    //#include <stdio.h>
    //
    //int main()
    //{
    //
    //    int rounds,p1max=0,p2max=0,lead=0;
    //    scanf(""%d"",&rounds);
    //
    //    for(int i=0; i<rounds; i++)
    //    {
    //        int p1,p2;
    //        scanf(""%d%d"",&p1,&p2);
    //
    //        lead += p1 - p2;
    //
    //        if(lead>0)
    //        {
    //            if(p1max < lead)
    //                p1max = lead;
    //        }
    //        else if(p2max < (-lead))
    //            p2max = (-lead);
    ////		printf(""%d\n"",lead);
    //    }
    //
    //    if(p1max > p2max)
    //        printf(""1 %d\n"",p1max);
    //    else
    //        printf(""2 %d\n"",p2max);
    //
    //
    //    return 0;
    //}
    //
    

",C++
476173,"
    //The Lead Game
    #include<stdio.h>
    int main()
    {
    	typedef struct
    	{
    		int p1,p2,lead,leader;
    	}round;
    	
    	int i,n,max=0,add;
    	scanf(""%d"",&n);
    	round arr[n];
    
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&arr[i].p1);
    		scanf(""%d"",&arr[i].p2);	
    		if(arr[i].p1>arr[i].p2)
    		{
    			arr[i].lead=arr[i].p1-arr[i].p2;
    			arr[i].leader=1;
    		}
    		else if(arr[i].p1<arr[i].p2)
    		{
    			arr[i].lead=arr[i].p2-arr[i].p1;
    			arr[i].leader=2;
    		}
    
    		if(max<arr[i].lead)
    		{
    			max=arr[i].lead;
    			add=i;
    		}
    	}
    	
    	printf(""%d %d"",arr[add].leader,arr[add].lead);
    	return 0;
    }
    

",C
399976,"
    #include<stdio.h>
    #include<stdlib.h>
    
    int main()
    {
    	int cases, max=0,lead=0,s1,s2;
    	scanf(""%d"",&cases);
    	while(cases>0)
    	{
    	scanf(""%d"",&s1);
    	scanf(""%d"",&s2);
    	if(abs(s1-s2)>max)
    		{
    		if(s1>s2)
    			lead=1;
    		else
    			lead=2;
    		max=abs(s1-s2);	
    		}
    
    
    
    	cases--;
    	}
    	printf(""%d %d"",lead,max);
    
    	return 0;
    }
    

",C
381630,"
    import java.io.*;
    public class Main {
    	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    	public static void main(String[] args) throws NumberFormatException, IOException {
    		int n = Integer.parseInt(br.readLine());
    		int lead = 0;
    		int maxLead = 0;
    		for (int i = 0; i < n; i++) {
    			String round = br.readLine();
    			lead += Integer.parseInt(round.split("" "")[0]) - Integer.parseInt(round.split("" "")[1]);
    			if (Math.abs(lead) > Math.abs(maxLead)) maxLead = lead;
    		}
    		if (maxLead > 0) bw.write(""1 "" + Math.abs(maxLead));
    		else bw.write(""2 "" + Math.abs(maxLead));
    		bw.flush();
    	}
    
    }
    

",JAVA
313317,"
    /*
      Name:
      Copyright:
      Author:
      Date: 19-08-10 17:00
      Description:
    */
    
    #include<iostream>
    #include<cstdio>
    using namespace std;
    int main()
    {
              int n,s,t,m1=0,m2=0;
              scanf(""%d"",&n);
              //cin>>i;
              while(n--)
              {
                        scanf(""%d%d"",&s,&t);
                        if(s>t)
                        {
                                            
                            if(m1<(s-t))
                               m1=s-t;
                        }
                        else if(t>s)
                        {
                          if(m2<(t-s))
                               m2=t-s;
                        }
               }
              if(m1>m2)
              printf(""1 %d"",m1);
              else
              printf(""2 %d"",m2);
              //system(""pause"");            
    return 0;
    }
    

",C++
285393,"
    #include<iostream>
    //#include<conio.h>
    #include<stdio.h>
    int a[10000];
    int b[10000];
    int main()
    {
        int n,i;
        scanf(""%d"",&n);
        for(i=0;i<n;i++)
        {
                        scanf(""%d"",&a[i]);
                        scanf(""%d"",&b[i]);
                        }
        int lead1=0;
        int lead2=0;
        for(i=0;i<n;i++)
        {
                        if(a[i]>=b[i])
                        {
                                     if((a[i]-b[i])>lead1)
                                     {
                                                         lead1=a[i]-b[i];
                                                         }
                                     
                                     }
                        else
                        {
                            if((b[i]-a[i])>lead2)
                            {
                                                 lead2=b[i]-a[i];
                                                 }
                        }
                        }
        if(lead1>lead2)
        {
                       printf(""1"");
                       printf("" %d"",lead1);
                       }
        else
        {
            printf(""2"");
            printf("" %d"",lead2);
        }
      //  getch();
    }
    

",C++
96459,"
    using namespace std;
    #include<iostream>
    int main()
    {
        int cases,m,maxlead,win,p1,p2;
        while(cin>>cases)
        {
        maxlead=-1;
        for(int i=0;i<cases;i++)
        {
                cin>>p1>>p2;
                m=p1-p2;
                m=m>0?m:-m;
                if(m>=maxlead)
                {
                             maxlead=m;
                             if(p1-p2>0)win=1;
                             else win=2;
                }
        }
        cout<<win<<"" ""<<maxlead<<endl;
        }
        return 0;
    }
    

",C++
12121278,"
    #include<stdio.h>
    int main()
     {
    int A[1000000],n,t,a,b,c,i=0;
    scanf(""%d"",&t);
    while(t--)
    {
    scanf(""%d"",&A[i]);
    i++;
    }
    for(a=0; a<t; a++)
    {
    if(A[a]>A[a+1])
    {b=A[a];
    A[a]=A[a+1];
    A[a+1]=b;
    }
    }
    for(c=0; c<t; c++)
    {
    printf(""%d\n"",A[c]);
    c++;
    }
    return 0;
    }
    

",C
12095122,"
    # include<stdio.h>
    int main()
    {
    int a[1000000],t,i,j,temp;
    scanf(""%d"",&t);
    for(i=0;i<t;i++)
    scanf(""%d"",&a[i]);
    for(i=1;i<t;i++)
    {
    temp=a[i];
    j=i-1;
    while(temp<a[j]&&j>=0)
    {
    a[j+1]=a[j];
    j--;
    }
    a[j+1]=temp;
    }
    for(i=0;i<t;i++)
    printf(""%d\n"",a[i]);
    return 0;
    }

",C
11846464,"
    import java.util.*;
    import java.math.*;
    
    
    public class Main  {
    	
    public static void mergeSort(int[] arr, int l, int n){
    	if(l < n){
    		int m = (l + n) / 2;
    		mergeSort(arr, l, m);
    		mergeSort(arr, m + 1, n);
    		merge(arr, l ,m, n);
    
    	}
    }
    
    public static void merge(int[] arr, int l, int m, int n){
    	int nl = m - l + 1;
    	int nr = n - m;
    	int[] L = new int[nl];
    	int[] R = new int[nr];
    
    	for(int i = 0; i < nl; i++)
    		L[i] = arr[l + i];	
    	for(int i = 0; i < nr; i++)
    		R[i] = arr[m + i + 1];
    
    	int x = 0;
    	int y = 0;
    	int z = l;
    	while(x < nl && y < nr){
    		
    		
    		if(L[x] < R[y]){
    			arr[z] = L[x];
    			x++;
    			
    		}
    
    		else{
    			arr[z] = R[y];
    			y++;
    			
    		}
    
    		z++;
    
    	}
    
    	while(x < nl){
    		
    		arr[z] = L[x];
    		x++;
    		z++;
    	}
    
    	while(y < nr){
    		
    		arr[z] = R[y];
    		y++;
    		z++;
    	}
    
    
    }
    
    	public static void main(String[] args){
    		Scanner sc = new Scanner(System.in);
    		int t = sc.nextInt();
    		int[] arr = new int[t];
    		for(int i = 0; i < t; i++){
    
    			arr[i] = sc.nextInt();
    		}
    
    		mergeSort(arr, 0, t - 1);
    
    		for(int i = 0; i < t; i++){
    			System.out.print(arr[i]+"" "");
    		}		
    	}	
    }

",JAVA
11753363,"
    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	long int t,temp;
    	vector<long int> arr;
    	cin>>t;
    	for(int i=0;i<t;i++)
    	{
    		cin>>temp;
    		arr.push_back(temp);
    	}
    	sort(arr.begin(),arr.end());
    	for(int i=0;i<t;i++)
    	cout<<arr[i]<<'\n';
    	return 0;
    	
    }

",C++
11649090,"
    #include<stdio.h>
    int main()
    {
    	int t,var,i=0,j;
    	int arr[20];
    	scanf(""%d"",&t);
    	var=t;
    	while(t>0)
    	{	
    		scanf(""%d"",&arr[i]);
    		//printf(""\n"");
    		i++;
    		t--;
    	}
    	//i=0;
    	for(i=0;i<var;i++)
    	{
    		for(j=0;j<var;j++)
    		{
    			if((i<j)&& arr[i]>arr[j])
    			{
    				arr[i]=arr[i]+arr[j];
    				arr[j]=arr[i]-arr[j];
    				arr[i]=arr[i]-arr[j];
    			}
    		}
    	}
    	printf(""\n"");
    	for(i=0;i<var;i++)
    	{
    		printf(""%d\n"",arr[i]);
    	}
    	return 0;
    		
    }

",C
11642191,"
    #include<bits/stdc++.h>
    using namespace std;
    void  countingsorting(int a[],int k,int n,int b[])
    {  
         int c[k],i,j;
    	for(i=0;i<k;i++)
    	{
    		c[i]=0;
    	}
    	for(j=0;j<n;j++)
    	{
    		c[a[j]]=c[a[j]]+1;
    	}
    	for(i=1;i<k;i++)
    	{
    		c[i]=c[i]+c[i-1];
    	}
    
    	for(j=n-1;j>=0;j--)
    	{
    		b[c[a[j]]]=a[j];
    		
    		c[a[j]]=c[a[j]]-1;
    	}
    
    }
    int main()
    {
    	int k=10^6;
    	int n;
    	cin>>n;
    	int a[n],b[n];
    	for(int i=0;i<n;i++)
    	{
    		cin>>a[i];
    	}
    	countingsorting(a,k,n,b);
    	for(int i=1;i<=n;i++)
    	{
    		cout<<b[i]<<endl;
    	}
    }
    

",C++
11450413,"
    #include<stdio.h>
    #define size 1000000
    int main()
    {
    int t,N,j,temp;
    int a[1000000];
    scanf(""%d"",&t);
    if(t<size)
    for(int i=0;i<t;i++)
    {
    scanf(""%d"",&N);
    if(N<size)
    a[i]=N;
    }
    for(i=0;i<t-1;i++)
      {
        for(j=i+1;j<t;j++)
        {
           if(a[j]<a[i])
           {
             temp=a[i];
             a[i]=a[j];
             a[j]=temp;
           }
        }
      }
    for(i=0;i<t;i++)
    printf(""%d\n"",a[i]);
    return 0;
    }

",C
11246602,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
    	int t;
    	cin >> t;
    	int a[t];
    	for (int i = 0; i < t; i++) {
    		cin >> a[i];
    	}
    	sort(a,a+t);
    	for (int i = 0; i < t; i++) {
    		cout << a[i] << endl;
    	}
    }

",C++
11128970,"
    #include <stdio.h>
    int main(){
    	int t, n, i, j, arr[1000001];
    	scanf(""%d"", &t);
    	while (t--){
    		scanf(""%d"", &n);
    		arr[n]++;
    	}
    	for (i = 1000001; i >= 0; i--)
    		if (arr[i] != 0)
    			for (j = 1; j <= arr[i]; j++)
    				printf(""%d\n"", i); 
    	return 0;
    }
    

",C
11117400,"
    .
    
        #include <stdio.h>
         
        static int ch[1000001];
        int main() 
        {
            int n,i,j,t;
            scanf(""%d"",&t);
            for(i=0;i<t;i++)
            {
                scanf(""%d"",&n);
                ch[n]++;
            }
            for(i=0;i<1000001;i++)
            {
                if(ch[i]>0)
                {
                    for(j=0;j<ch[i];j++)
                    printf(""%d\n"",i);
                }
            }
        	return(0);
        }

",C
11005382,"
    #include<stdio.h>
    int main(){
    	long int t,a[1000000],i,j,temp;
    	scanf(""%ld"",&t);
    	for(i=0;i<t;i++)
    		scanf(""%ld"",&a[i]);
    	for(i=0;i<t;i++){
          for(j=i+1;j<t;j++){
               if(a[i]>a[j]){
                   temp=a[i];
                  a[i]=a[j];
                  a[j]=temp;
              }
          }
      }
          for(i=0;i<t;i++)
          printf(""%ld\n"",a[i]);
          return 0;
    }

",C
10887778,"
    i,#include<stdio.h>
    int main()
    {
    int i,n;
    scanf(""%d"",&n);
    int a[n];
    for(i=0;i<=(n-1);i++);
    {
    scanf(""%d"",&a[i]);
    }
    for(j=0;j<(n-1);j++)
    {
    for(k=0;k<(n-1-j);k++)
    {
    if(a[k]>a[k+1])
    {
    sort=a[k];
    a[k]=a[k+1];
    a[k+1]=sort;
    }
    }
    }
    
    for ( i = 0 ; i < n ; i++ )
         printf(""%d\n"", a[i]);
         return 0;
         }
    
    

",C
10637343,"
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    int a[1000001]={0};
    long long int t,n,j,k,i,temp=0;
    scanf(""%lld"",&t);
    for(i=0;i<t;i++)
    {
    scanf(""%lld"",&n);
    a[n]++;
    	if(n>temp)
    	{
    	temp=n;
    	}
    }
    for(j=0;j<=temp;j++)
    {
    	for(k=0;k<a[j];k++)
    	{
    	printf(""%lld"",j);
    	}
    }
    return 0;
    }	 

",C
10516972,"
    #include<iostream>
    #include<algorithm>
    using namespace std ;
    int main()
    {
        long long int t  , l , i , j , flag   ;
        cin >> t ;
        long long int a[t] ;
        i = 0 ;
        while(t--)
        {
            cin >> a[i] ;
            i++ ;
        }
        sort(a,a+i) ;
        for(l=0;l<i;l++)
        {
            cout << a[l] << endl ;
        }
        return 0 ;
    }
    

",C++
10266077,"
    #include<iostream>
    #include<stdio.h>
    #include<algorithm>
    int main()
    {int i;
    int t;
    scanf(""%d"",t);
    int a[t];
    for(i=0;i<t;i++)
    {scanf(""%d"",a[i]);}
    sort(a,a+t);
    for(i=0;i<t;i++)
    {printf(""%d"",a[i]);
    printf(""\n"");
    }
    return 0;
    }
    

",C++
9780672,"
    #include<stdio.h>
    
    int main(){
      int t,num,a[1000000]={0},i;
      scanf(""%d"",&t);
      while(t != 0){
        scanf(""%d"",&num);
        a[num]++;
        t--;
      }
      i=0;
      while(i<1000000){
        if(a[i]>0){
        while(a[i]>0){
        printf(""%d\n"",i);
        a[i]--;
        }
        }
        i++;
      }
      return 0;
    }
    

",C
9739454,"
    #include<stdio.h>
    
    int main()
    {
     	unsigned int a[10000001],i,n,j,temp;
     	scanf(""%d"",&n);
     	for(i=0;i<n;i++)
     	{
     		scanf(""%d"",&a[i]);
     	}
     	for(i=0;i<n;i++)
     	{
     		for(j=i+1;j<n;j++)
     		{
     			if(a[i]>a[j])
     			{
     				temp=a[i];
     				a[i]=a[j];
     				a[j]=temp;
     			}
     		}
     	}
     	for(i=0;i<n;i++)
     	{
    	    printf(""%d\n"",a[i]);
    	}
    	return 0;
    }
     		
    	
    

",C
9636468,"
    #include <iostream>
    using namespace std;
    
    int main() {
    	// your code goes here
    	int n,temp,i,j;
    	cin>>n;
    	int a[n];
    	for(i=0;i<n;i++)
    	{
    		cin>>a[i];
    	}
    	for(i=0;i<n;i++)
    	{
    		for(j=i+1;j<n;j++)
    		{
    		if(a[i]<a[j])
    		{
    			temp=a[j];
    			a[j]=a[i];
    			a[i]=temp;
    		}
    		}
    		
    	}
    		for(i=0;i<n;i++)
    	{
    		cout<<a[i]<<""\n"";
    	}
    	return 0;
    }

",C++
9607159,"
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
        int i,j,a[1000000];
        long n;
        cin>>n;
        for(i =0 ;i<n;i++)
        {
            cin>>a[i];
        }
        sort(a,a+n);
    
     for(i=0;i<n;i++)
     {
         cout<<a[i]<<endl;
     }
    }
    

",C++
9486345,"
    #include <stdio.h>
    
    int main()
    {
        int a;
        float c;
        scanf(""%d %f"", &a, &c);
        if(a%5==0&&c>(a - 0.5))
        {
             printf(""%0.2f"", c - a - 0.5);
        }
        else
        {
            printf(""%0.2f"", c);
        }
    }

",C
9477598,"
    #include<bits/stdc++.h>
    using namespace std;
    int ar[1000010];
    void swap(int *a,int *b)
    {
        int temp=*a;
        *a=*b;
        *b=temp;
    }
    void heapify(int ar[],int m,int n)
    {
        int k=m*2;
        if(k+1<=n)
        {
            if((ar[k]>ar[m])&&(ar[k]>ar[k+1]))
            {
                swap(&ar[k],&ar[m]);
                heapify(ar,k,n);
            }
            if((ar[k+1]>ar[m])&&(ar[k+1]>=ar[k]))
            {
                swap(&ar[k+1],&ar[m]);
                heapify(ar,k+1,n);
            }
    
        }
        else
        {
            if(k<=n&&ar[k]>ar[m])
            {
                swap(&ar[k],&ar[m]);
                //heapify(ar,k,n);
            }
        }
    }
    void maxheap(int ar[],int n)
    {
        for(int i=n/2; i>=1; i--)
            heapify(ar,i,n);
    }
    void heapsort(int ar[],int n)
    {
        maxheap(ar,n);
        swap(&ar[1],&ar[n]);
        for(int i=n-1; i>=1; i--)
        {
            heapify(ar,1,i);
            swap(&ar[1],&ar[i]);
        }
    }
    int main()
    {
        int n;
        cin>>n;
        for(int i=1; i<=n; i++)
            scanf(""%d"",&ar[i]);
        heapsort(ar,n);
        for(int i=1; i<=n; i++)
            printf(""%d\n"",ar[i]);
    }
    

",C++
9473316,"
    t = int(input(""Enter a number: ""))
    print (""this is what you entered: %d"" %t)
    n = []
    while (t>0):
    	n.append(int(input(""Enter a number: "")))
    	t = t-1
    n.sort()
    
    i = 0
    while i < to :
    	print a[i]
    	i = i + 1

",PYTH
9295979,"
    #include <iostream>
    using namespace std;
    #include <conio.h>
    void merge(int *,int, int , int );
    void mergesort(int *a, int low, int high)
    {
        int mid;
        if (low < high)
        {
            mid=(low+high)/2;
            mergesort(a,low,mid);
            mergesort(a,mid+1,high);
            merge(a,low,high,mid);
        }
        return;
    }
    void merge(int *a, int low, int high, int mid)
    {
        int i, j, k, c[50];
        i = low;
        k = low;
        j = mid + 1;
        while (i <= mid && j <= high)
        {
            if (a[i] < a[j])
            {
                c[k] = a[i];
                k++;
                i++;
            }
            else
            {
                c[k] = a[j];
                k++;
                j++;
            }
        }
        while (i <= mid)
        {
            c[k] = a[i];
            k++;
            i++;
        }
        while (j <= high)
        {
            c[k] = a[j];
            k++;
            j++;
        }
        for (i = low; i < k; i++)
        {
            a[i] = c[i];
        }
    }
    int main()
    {
        int n;
        cin>>n;
        int a[n]={0};
        for(int i=0;i<n;i++)
        	cin>>a[i];
        mergesort(a, 0, n-1);
        for (int j = 0; j < 5; j++)
        {
            cout<<a[j]<<endl;
        }
    }

",C++
9178046,"
    import java.util.Scanner;
    public class Main {
      private static final int N = 1000010;
      static int[] arr = new int[N];
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long t = scanner.nextInt();
        
        
        for (int i = 0; i < t; i++) {
          arr[scanner.nextInt()]++;
        }
        for (int i = 0; i < N; i++) {
          int n = arr[i];
          if (n != 0) {
          for(int j = 0; j < n; j++) {
          	System.out.println(i);
          
          }}
        }
        scanner.close();
      }
    } 

",JAVA
8983677,"
    /**
     * CodeChef TSORT
     * 19.12.2015
     */
    
    #include<iostream>
    #include<algorithm>
    using namespace std;
    
    int main(void){
        int n, item;
        cin >> n;
        int a[n];
        for (int i = 0; i < n; i++) cin >> a[i];
        sort(a,a+n);
        for (int i = 0; i < n; i++) cout << a[i] << '\n';
        cout << endl;
        return 0;
    }
    

",C++
8844919,"
    #include <iostream>
    using namespace std;
    
    int main() {
    	// your code goes here
    	int a,b[1000001]={0},i,j;
    	cin>>a;
    	for(i=0;i<a;i++)
    	{
    	    cin>>j;
    	    b[j]++;
    	}
    	for(i=0;i<1000001;i++)
    	{
    while(b[i]>0)
    {
        cout<<i<<""\n"";
    b[i]--;
    }
    	    
    	}
    	return 0;
    }
    

",C++
8572539,"
    #include<stdio.h>
    main()
    {
       long int a[10],i,t,c;
       scanf(""%d"",&t);
       for(i=1;i<=t;i++)
       scanf(""%d"",&a[i]);
        for(i=1;i<=t;i++)
        {
            for(int n=i+1;n<=t;n++)
            {
            if(a[i]>a[n])
            {
               c=a[n];
               a[n]=a[i];
               a[i]=c;
                }
            }
            }
           for(i=1;i<=t;i++)
           printf(""%d"",a[i]);
           }
    

",C
8331730,"
    #include<bits/stdc++.h>
    using namespace std;
    int a[1000000],b[1000000]={0};
    long long int n,i,j=0;
    int main()
    {
        cin>>n;
        for(i=0;i<n;i++)
        {
            cin>>a[i];
            b[a[i]]++;
        }
        for(i=0;i<1000000;i++)
        {
            while(b[i]>0)
            {
                cout<<i<<endl;
                b[i]--;
    
            }
        }
        return 0;
    }
    

",C++
7969293,"
    import java.io.*;
    import java.util.*;
    class Test
    {
    public static void main(String []args)
    {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long []a=new long[n];
    for(long i=0;i<n;i++)
    {
    a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    for(long x:a)
    System.out.println(x);
    }
    }

",JAVA
7869620,"
    using System;
    using System.Collections.Generic;
    
    namespace TurboSort
    {
    	class MainClass
    	{
    		public static void Main (string[] args)
    		{
    			string text = Console.ReadLine ();
    			int ilosc = Convert.ToInt32 (text);
    
    			var tablica = new List<int> ();
    
    			for (int i = 0; i < ilosc; i++) 
    			{
    				tablica.Add (Convert.ToInt32 (Console.ReadLine()));							
    			}
    
    			 tablica.Sort ();
    
    			for (int i = 0; i < ilosc; i++) 
    			{
    				Console.WriteLine (tablica [i].ToString ());
    			}
    
    
    		}
    	}
    }
    

",C#
7849998,"
    main = do
        ns <- getLine
        let n = (read :: String -> Int) ns
        l <- sequence [getLine | i <- [1..n]]
    
        let nums :: [Int]
            nums = [read i | i <- l]
            sorted = quicksort nums
    
        putStrLn $ unlines $ map show sorted
    
    quicksort :: [Int] -> [Int]
    quicksort [] = []
    quicksort (x:xs) =
        let smallerSorted = quicksort [a | a <- xs, a <= x]
            biggerSorted = quicksort [a | a <- xs, a > x]
        in smallerSorted ++ [x] ++ biggerSorted
    

",HASK
7833355,"
    #include<stdio.h>
    int main()
    {  int a[],n,i,j,temp;
       scanf(""%d\n"",&n);
       for(i=0;i<n;i++)
       {  scanf(""%d\n"",&a[i]);
       }
       for(i=0;i<n-1;i++)
       {  for(j=0;j<n-i-1;j++)
           {
             if(a[j]>a[j+1])
             { temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
             }
           }
       }
       for(i=0;i<n;i++)
       {  printf(""%d\n"",a[i]);
       }
       }

",C
7600104,"
    #include <stdio.h>
    void ts(int [],int);
    int main(void) {
    	// your code goes here
    	int n,a[100001],i;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    	{
    	    scanf(""%d"",&a[i]);
    	}
    	ts(a,n);
    	for(i=0;i<n;i++)
    	printf(""%d\n"",a[i]);
    	return 0;
    }
    void ts(int a[],int n)
    {
        int i,j,temp=0;
        for(i=0;i<n-1;i++)
        {
            for(j=0;j<n-i-1;j++)
            {
                if(a[j]>a[j+1])
                {
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }
    

",C
7518665,"
    #include <stdio.h>
    
    int main()
    {
    int a[1000000],t,i,j,temp;
    scanf(""%d\n"",&t);
    for(i=0;i<t;i++)
    {
    scanf(""%d\n"",&a[i]);
    }
    for(i=0;i<t;i++)
    {
    for(j=0;j<t-1;j++)
    {
    if(a[j]>a[j+1])
    {
    temp=a[j];
    a[j]=a[j+1];
    a[j+1]=temp;
    }
    }
    }
    for(i=0;i<t;i++)
    {
    printf(""%d\n"",a[i]);
    }
    return 0;
    }

",C
7474588,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.List;
    
    class TSORT {
    	public static void main(String [] args) throws IOException{
    		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    	    int t=Integer.parseInt(reader.readLine());
    	    int n;
    	    List<Integer> nums  =   new ArrayList<Integer>();
    	    for( int i=0;i<t;i+=1)
    	    {
    	    	n = Integer.parseInt(reader.readLine());
    	    	nums.add(n);
    	    }   
    	    
    	    for(int j=0;j<nums.size()-1;j+=1)
    		{
    			for (int k=j+1;k<nums.size();k+=1)
    			{
    				if(nums.get(j)>nums.get(k))
    				{
    					Collections.swap(nums, j, k);
    				}
    			}
    		}
    	    for (int i=0;i<nums.size();i++)
    	    {
    	    	System.out.println(nums.get(i));	
    	    }
    	    
    	}
    }

",JAVA
7155572,"
    #include<stdlib.h>
    #include<stdio.h>
    
    /* Function to merge the two haves arr[l..m] and arr[m+1..r] of array arr[] */
    void merge(long long int arr[], long long int l, long long int m, long long int r)
    {
        long long int i, j, k,n1 = m - l + 1,n2 =  r - m;
        
        /* create temp arrays */
        int L[n1], R[n2];
    
        /* Copy data to temp arrays L[] and R[] */
        for(i = 0; i < n1; i++)
            L[i] = arr[l + i];
        for(j = 0; j < n2; j++)
            R[j] = arr[m + 1+ j];
    
        /* Merge the temp arrays back into arr[l..r]*/
        i = 0;
        j = 0;
        k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
    
        /* Copy the remaining elements of L[], if there are any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
    
        /* Copy the remaining elements of R[], if there are any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    
    /* l is for left index and r is right index of the sub-array
      of arr to be sorted */
    void mergeSort(long long int arr[], long long int l, long long int r)
    {
        if (l < r)
        {
            long long int m = l+(r-l)/2; //Same as (l+r)/2, but avoids overflow for large l and h
            mergeSort(arr, l, m);
            mergeSort(arr, m+1, r);
            merge(arr, l, m, r);
        }
    }
    
    
    /* UITLITY FUNCTIONS */
    /* Function to print an array */
    void printArray(long long int A[], long long int size)
    {
        long long int i;
        for (i=(size-1); i >=0; i--)
            printf(""%lld \n"", A[i]);
        printf(""\n"");
    }
    
    /* Driver program to test above functions */
    int main()
    {
        long long int arr[1000000];
        long long int i=0,n;
        scanf(""%lld"",&n);
        for(i=0;i<n;i++)
         scanf(""%lld"",&arr[i]);
        int arr_size = n;
    
        mergeSort(arr, 0, arr_size - 1);
    
        printArray(arr, arr_size);
        return 0;
    }

",C
6935691,"
    #include <stdio.h>
    
    int main(void) {
    	int a[1000000],t,i,j,tp;
    	scanf(""%d\n"",&t);
    	for(i=0;i<t;i++)
    	{
    	    scanf(""%d\n"",&a[i]);
    	   
    	}
    	for(i=0;i<t-1;i++)
    	{
    	    
    	    for(j=0;j<t-i-1;j++)
    	    {
    	        if(a[j]>a[j+1])
    	        {
    	          tp=a[j];
    	          a[j]=a[j+1];
    	          a[j+1]=tp;
    	        }
    	        
    	    }
    	}
    	for(i=0;i<t;i++)
    	    printf(""%d\n"",a[i]);
    	
    	return 0;
    }
    
    

",C
6765182,"
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.math.BigInteger;
    import java.sql.Array;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Scanner;
    
    
    class TestClass1
    {
    	public static void main (String[] args) throws java.lang.Exception
    	{
    		BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
    		//BufferedWriter write = new BufferedWriter(new OutputStreamWriter(System.out));
    		int input = Integer.parseInt(read.readLine());
    		//System.out.println(input);
    		List<Integer> list = new ArrayList();
    		for (int i = 0; i < input; i++){
    			list.add(Integer.parseInt(read.readLine()));
    			//System.out.println(list);
    		}
    		Collections.sort(list);
    		for (int element : list){
    			//write.write(element);
    			System.out.println(element);
    		}
    		read.close();
    	}
    	}

",JAVA
6070254,"
    import java.util.Scanner;
    import java.util.TreeSet;
    
    class TurboSort {
    
    	public static void main(String[] args) {
    		TreeSet<Integer> ts = new TreeSet<Integer>();
    		@SuppressWarnings(""resource"")
    		Scanner sc = new Scanner(System.in);
    		int i = sc.nextInt(), k = 0;
    		while(i!=0)
    		{
    			i--;
    			k = sc.nextInt();
    			ts.add(k);
    		}
    		for(int o : ts)
    		{
    			System.out.println(o);
    		}
    	}
    
    }
    

",JAVA
6061431,"
    /*
     * Merge Sort
     */
    #include <iostream>
    using namespace std;
    
    void merge(int *,int, int , int );
    void mergesort(int *a, int low, int high)
    {
        int mid;
        if (low < high)
        {
            mid=(low+high)/2;
            mergesort(a,low,mid);
            mergesort(a,mid+1,high);
            merge(a,low,high,mid);
        }
        return;
    }
    void merge(int *a, int low, int high, int mid)
    {
        int i, j, k, c[50];
        i = low;
        k = low;
        j = mid + 1;
        while (i <= mid && j <= high)
        {
            if (a[i] < a[j])
            {
                c[k] = a[i];
                k++;
                i++;
            }
            else
            {
                c[k] = a[j];
                k++;
                j++;
            }
        }
        while (i <= mid)
        {
            c[k] = a[i];
            k++;
            i++;
        }
        while (j <= high)
        {
            c[k] = a[j];
            k++;
            j++;
        }
        for (i = low; i < k; i++)
        {
            a[i] = c[i];
        }
    }
    int main()
    {
        int  i,n, b[200000];
        cin>>n;
        int a[n];
        for (int k=0;k<n;k++)
        {
        	cin>>a[k];
    	}
        mergesort(a, 0, n-1);
        //cout<<""sorted array\n"";
        for (i = 0; i < n; i++)
        {
            cout<<a[i]<<endl;
        }
    }

",C++
5986805,"
    #include<stdio.h>
    int main()
    {
     int n,i,j,temp;
    // printf(""enter the test cases\n"");
     scanf(""%d"",&n);
     int a[n];
     //printf(""INPUT:\n"");
     for(i=0;i<n;i++)
     {
            scanf(""%d"",&a[i]);
     }
     //printf(""OUTPUT:\n"");
     for(i=0;i<n-1;i++)
     {
            for(j=0;j<n-1-i;j++)
            {
                    if(a[j]>a[j+1])
                    {
                            temp=a[j];
                            a[j]=a[j+1];
                            a[j+1]=temp;
                    }
            }
     }
     for(i=0;i<n;i++)
     {
            printf(""%d\n"",a[i]);
     }
     return 0;
    }

",C
5945009,"
    #include <stdio.h>
    #include <stdlib.h>
    void main() {
        int i,j,n,temp ;
        int *t ;
        scanf(""%d"",&n) ;
        t = (int*) malloc(n*sizeof(int)) ;
        for(i=0;i<n;i++) scanf(""%d"",&t[i]) ;
        for(i=0;i<n;i++) for(j=0;j<n-1;j++) if(t[j] > t[j+1]) {
                         temp = t[j] ;
                         t[j] = t[j+1] ;
                         t[j+1] = temp ;
                         }
        for(i=0;i<n;i++) printf(""%d\n"",t[i]) ;
        
        
    }            

",C
5827689,"
    #include<stdio.h>
    
    //quick Sort function to Sort Integer array list
    void quicksort(int array[], int firstIndex, int lastIndex)
    {
        //declaaring index variables
        int pivotIndex, temp, index1, index2;
        
        if(firstIndex < lastIndex)
        {
            //assigninh first element index as pivot element
            pivotIndex = firstIndex;
            index1 = firstIndex;
            index2 = lastIndex;
            
            //Sorting in Ascending order with quick sort
            while(index1 < index2)
            {
                while(array[index1] <= array[pivotIndex] && index1 < lastIndex)
                {
                    index1++;
                }
                while(array[index2]>array[pivotIndex])
                {
                    index2--;
                }
                
                if(index1<index2)
                {
                    //Swapping opertation
                    temp = array[index1];
                    array[index1] = array[index2];
                    array[index2] = temp;
                }
            }
            
            //At the end of first iteration, swap pivot element with index2 element
            temp = array[pivotIndex];
            array[pivotIndex] = array[index2];
            array[index2] = temp;
            
            //Recursive call for quick sort, with partiontioning
            quicksort(array, firstIndex, index2-1);
            quicksort(array, index2+1, lastIndex);
        }
    }
    
    int main()
    {
        //Declaring variables
        int array[1000000],n,i;
        
        //Number of elements in array form user input
        
        scanf(""%d"",&n);
        
        //code to ask to enter elements from user equal to n
        
        for(i = 0; i < n; i++)
        {
            scanf(""%d"",&array[i]);
        }
        
        //calling quickSort function defined above
        quicksort(array,0,n-1);
        
        //print sorted array
        
        for(i=0;i<n;i++)
            printf(""%d\n"",array[i]);
        
        
        return 0;
    }
    

",C++
5757316,"
    #include<stdio.h>
    int main(){
    int t,n,i,j=0,temp,arr[1000000];
    scanf(""%d"",&t);
    for(i=0;i<t;i++){
    scanf(""%d"",&n);
    arr[i]=n;
    i++;
    }
    for(i=0;i<1000000;i++){
    while(arr[i]-->0){
    printf(""%d\n"",i);
    }
    }
    return 0;
    }
     

",C
5485193,"
    #include<iostream>
    using namespace std;
    int partition(int *a,int start,int end)
    {
    int pivot=a[end];
    int j=start;
    int temp;
    for(int i=start;i<end;i++)
    {
        if(a[i]<=pivot)
        {
            temp=a[i];
            a[i]=a[j];
            a[j]=temp;
            j=j+1;
        }
    }temp=a[j];
     a[j]=pivot;
     a[end]=temp;
    return j;
    }
    void quick_sort(int *a,int start,int end)
    {
        if(start<end)
        {
        int j=partition(a,start,end);
        quick_sort(a,start,j-1);
        quick_sort(a,j,end);
        }
    }
    
    int main()
    {int n,a[1000000];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int start=0,end=n-1;
    quick_sort(a,start,end);
    for(int i=0;i<n;i++)
    {cout<<a[i]<<""\n"";
    }
    }
    

",C++
5442617,"
    import java.io.BufferedReader;
    import java.io.PrintWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    //import java.io.OutputStreamWriter;
     
    class TSORT {
    	public static void main(String[] args) throws IOException{
    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		PrintWriter bw = new PrintWriter(System.out, false);
    		int t = Integer.parseInt(br.readLine());
    		int[] list = new int[1000001];		
    		for(int i = 0; i < t; i++){
    			int n = Integer.parseInt(br.readLine());
    			list[n]++;
    		}
    		int r=0;
    		for(int i = 0; i < 1000001; i++){
    	
    			if(list[i] > 0){
    		
    				for(int j = 0; j < list[i]; j++){
    					//bw.write(String.valueOf(i));	
    					//bw.write(i);
    					bw.println(i);
    					//bw.newLine();
    					//bw.println();
    						
    				}
    			}
    	}
    		bw.flush();
    	}
    }
    	 
    

",JAVA
5342428,"
    #include<stdio.h>
    int main()
    { int n,i,temp,j;
      long int a[10000];
     scanf(""%d"",&n);
     for(i=0;i<n;i++)
     {scanf(""%ld"",&a[i]);
     }
     for(i=0;i<n;i++)
       {for(j=0;j<n-i-1;j++)
         {if(a[j]>a[j+1]);
           {temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;       
           }
         } 
       }
      for(i=0;i<n;i++)
      {printf(""%ld/n"",a[i]);} 
    } 

",C
5004655,"
    #include<iostream>
    int main()
    {
    	long array[1000001],s,j=0,i=0,temp;
    	cin>>s;
    	for(i=0;i<s;i++)
    	{	cin>>array[i];
    	}
    	
    	for(j=0;j<s;j++)
    	{	for(i=0;i<s-1;i++)
    		{	if(array[i]>array[i+1])
    			{	temp=array[i];
    				array[i]=array[i+1];
    				array[i+1]=temp;
    			}
    		}
    	}
    	
    	for(i=0;i<s;i++)
    	{	
    		cout<<endl<<array[i];
    	}
    	cout<<endl;
    	return 0;
    	
    }
    

",C++
4861458,"
    #include<iostream>
    #include<cstdio>
    #include<set>
    #include<iterator>
    #include<sstream>
    using namespace std;
    int main()
    {
    int i,t,temp;
    set<int> a;
    fscanf(stdin,""%d"",&t);
    for(i=0;i<t;i++)
       {fscanf(stdin,""%d"",&temp);
       a.insert(temp);
       }
        stringstream ss;
        copy( a.begin(), a.end(), ostream_iterator<int>(ss, ""\n""));
        string s = ss.str();
        s = s.substr(0, s.length()-1);  // get rid of the trailing space
    
    cout<<s;
    return 0;
    }
    

",C++
4698451,"
    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <algorithm>
    using namespace std;
    #define MAX 1000001
    
    int t;
    int N[MAX];
    
    int main()
    {
    	cin>>t;
    	for(int i=0;i<t;++i)
    	scanf(""%d"",&N[i]);
    	
    	sort(N,N+t);
    	
    	for(int i=0;i<t;++i)
    		printf(""%d\n"",N[i]);
    
    return 0;
    }

",C++
4582282,"
    #include<stdio.h>
    
    void tsort(int a[], int len);
    
    int main()
    {
            int length, i;
            int a[1000000];
    
            scanf(""%d"", &length);
            for(i = 0; i < length; i++){
                    scanf(""%d"", &a[i]);
            }
            tsort(a, length);
            printf(""\n\n%d\n"",length);
            for(i = 0; i < length; i++){
                    printf(""%d\n"", a[i]);
            }
    
            return 0;
    }
    void tsort(int a[], int len)
    {
            int i, j, temp;
            for(i = 0; i < len; i++){
                    for(j = 0; j < i; j++){
                            if(a[i] < a[j]){
                                    temp = a[j];
                                    a[j] = a[i];
                                    a[i] = temp;
                            }
                    }
            }
    }
    

",C
4529101,"
    #include <stdio.h>
    #define MAX 100
    #define SWAP(x,y,t) ((t)=(x),(x)=(y),(y)=(t))
    int main(void) {
    	// your code goes here
    	int list[MAX],i,n;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    	{
    		scanf(""%d"",&list[i]);
    	}
    	sort(list,n);
    	for(i=0;i<n;i++)
    	{
    		printf(""%d\n"",list[i]);
    	}
    	return 0;
    }
    void sort(int list [MAX],int n)
    {
    	int i,j,min,temp;
    	for(i=0;i<n;i++)
    	{
    		min=i;
    		for(j=i+1;j<n;j++)
    		{
    			if(list[j]<list[min])
    			{
    				min=j;
    				SWAP(list[i],list[min],temp);
    			}
    		}
    	}
    }
    

",C
4455973,"
    #include<stdio.h>
    
    int main()
    {
    int arr[1000000];
    int i,j,t,a;
    scanf(""%d"",&a);
    for(i=0;i<a;i++)
    printf(""\t%d"",arr[i]);
    for(i=0;i<a;i++)
    {
    for(j=0;j<a-i-1;j++)
    {
    if(arr[j]>arr[j+1])
    {
    t=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=t;
    }
    }
    }
    for(i=0;i<a;i++)
    printf(""\n%d"",arr[i]);
    return 0;
    }
    

",C
4410310,"
    import java.io.*;
    import java.util.*;
     
    public class Main {
     
        public static StringBuffer answer = new StringBuffer();
        
        public static void main(String[] args) throws java.lang.Exception {
           BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
           int t = Integer.parseInt(r.readLine());
           
           int[] array = new int[t];
           
          for(int i=0; i<t;i++) {
              array[i] = Integer.parseInt(r.readLine());	
          }
          
          /*for(int i=0;i < t-1;i++) {
              for(int j=i+1;j < t;j++) {
                  int temp = array[j];
                  
                  if(array[i] > array[j]) {
                      array[j] = array[i];
                      array[i] = temp;
                  }
              }
          }*/
          
          Arrays.sort(array);
          
          for(int i = 0;i < t;i++) {
              System.out.println(array[i]);
          }
        }
           
        } 

",JAVA
4360690,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main(void)
    {
        int n,i;
        cin>>n;
        int a[n];
        for(i=0;i<n;i++)
            cin>>a[i];
    
        sort(a,a+n);
    
        for(i=0;i<n;i++)
            cout<<a[i]<<endl;
    
        return 0;
    
    
    
    }
    

",C++
4207968,"
    import sys
    
    lst=[]
    x=int(raw_input())
    for i in xrange(x): 
        y=int(sys.stdin.readline())
        lst.append(y)
    lst.sort()
    
     
    print lst    

",PYTH
4077077,"
    import java.util.*;
    import java.io.*;
    class  SortLib
    {
    	 public static void main(String args[])throws IOException
    	 {  
    	 	BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
    	 	int x;
    	 	x=Integer.parseInt(br.readLine());
    	 	
    	 	int arr[]=new int[x];
    	 	for(int i=0;i<x;i++)
    	 	{
    	 		arr[i]=Integer.parseInt(br.readLine());
    	 	}
    	 	
    	 	Arrays.sort(arr);
    	 	
    	 	
    	 	for(int n=0;n<x;n++)
    	 	{
    	 		System.out.println(arr[n]);
    	 	}
    	 }
    }

",JAVA
4071906,"
    #include <iostream>
    #include <algorithm>
    #include<stdio.h>
    
    int main() {
      int n;
      scanf(""%d"",&n);
      int array[n];
      //int elements = sizeof(array) / sizeof(array[0]);
      for(int i=0;i<n;i++)
      scanf(""%d"",&array[i]);
      std::sort(array, array + n);
      for (int i = 0; i < n; ++i)
         std::cout << array[i] << ""\n"";
    }
    

",C++
3970490,"
    //Count sort
    
    #include<stdio.h>
    void count(int [],int,int );
    int main()
    {
     int arr[30];
     int i,size;
     scanf(""%d"",&size);
     for(i=0; i<size; i++)
     {
       scanf(""%d"",&arr[i]);
     }
     count(arr,10,size);
    for(i=0;i<size;i++)
      printf(""%d\n"",arr[i]);
      return 0;
    }
    
    void count(int a[],int high,int size){
        int b[high],c[size];
        int i,j=0;
        for(i=0;i<high;i++)
            b[i]=0;
        for(i=0;i<size;i++)
            b[a[i]]=b[a[i]]+1;
        for(i=0;i<high;i++){
            while(b[i]>0){
                a[j]=i;
                b[i]--;
                j++;
            }
        }
    
    }
    

",C
3926024,"
    #include<stdio.h>
    #define gc() getchar_unlocked
    int x;
    int temp;
    int partitionA(int *A,int p,int r);
    inline int read_int() {
      char c = gc();
      while(c<'0' || c>'9') c = gc();
      int ret = 0;
      while(c>='0' && c<='9') {
        ret = 10 * ret + c - 48;
        c = gc();
      }
      return ret;
    }
    
    inline void write_int (int n)
    {
        int N = n, rev, count = 0;
        rev = N;
        if (N == 0) { pc('0'); pc('\n'); return ;}
        while ((rev % 10) == 0) { count++; rev /= 10;} //obtain the count of the number of 0s
        rev = 0;
        while (N != 0) { rev = (rev<<3) + (rev<<1) + N % 10; N /= 10;}  //store reverse of N in rev
        while (rev != 0) { pc(rev % 10 + '0'); rev /= 10;}
        while (count--) pc('0');
    }
    
    int qsort(int *A,int p,int r){
        int q;
        if(p<r)
        {
            q=partitionA(A,p,r);
            qsort(A,p,q-1);
            qsort(A,q+1,r);
        }
    }
    int partitionA(int *A,int p,int r){
    int i=p-1;
    x=A[r];
    int j;
    for(j=p ;j<=r-1;j++){
        if(A[j]<=x)
            {
                i=i+1;
                temp=A[i];
                A[i]=A[j];
                A[j]=temp;
            }
        }
       temp=A[i+1];
        A[i+1]=A[r];
        A[r]=temp;
    return i+1;
    }
    
    int main(){
    int t;
    t=read_int();//scanf(""%d"",&t);
    int A[t],i;
    for(i=0;i<t;i++)
        {
         A[i]=read_int();//scanf(""%d"",&A[i]);
        }
    qsort(A,0,t);
    for(i=0;i<t;i++){
        write_int(A[i]);//printf(""%d\n"",A[i]);
        pc('\n');
     }
     return 0;
    }
    

",C++
3910087,"
    #include<iostream>
    using namespace std;
    int main()
    {
      ios::sync_with_stdio(false); 
      int i,j,temp,t,num;
      cin>>t;
      int arr[t];
      for(i=0;i<t;i++)
         cin>>arr[i];
      for(i=0;i<(t-1);i++)
         for(j=i+1;j<t;j++)
    	     {
    	     	if(arr[i]>arr[j])
    	     	{
    	     		temp=arr[i];
    	     		arr[i]=arr[j];
    	     		arr[j]=temp;
    				 
    	     	}
    	     	
    	     }     
      for(i=0;i<t;i++)
         cout<<""\n""<<arr[i];
     return 0;
    }
    
      

",C++
3880905,"
    def main ():
        from sys import stdin
        l = stdin.readline()
        t = int(l)
    
        lista = []
        for x in xrange(t):
            num = stdin.readline()
            n = int(num)
            lista += [n]
            lista = sorted(lista)
        for n in lista
            print n
    main()
    

",PYTH
3751585,"
    #include <iostream>
    #include <cstdio>
    
    void sort(int *nums,int ts);
    
    int main(int argc, const char * argv[])
    {
        int t,i,input;
        scanf(""%d"",&t);
        int *nums;
        nums =(int *)malloc(t*sizeof(int));
        
        for(i=0;i<t;i++)
        {
            scanf(""%d"",&input);
            nums[i]=input;
        }
        sort(nums,t);
        
        for(i=0;i<t;i++)
        {
            printf(""%d\n"",nums[i]);
        }
        return 0;
    }
    
    void sort(int *nums,int t)
    {
        int i,j;
        for(i=0;i<t;i++)
        {
            for(j=i+1;j<t;j++)
            {
                if(nums[i]>nums[j])
                {
                    int temp = nums[j];
                    nums[j]=nums[i];
                    nums[i]=temp;
                }
            }
        }
    }

",C++
3642962,"
    #include<iostream>
    #include<stdio.h>
    #define MAX 1000 //maximum buffer(array) size
    #define N 20
    
    using namespace std;
    int left(int i);
    int right(int i);
    void Max_Heapify(int [],int,int);
    void Build_Max_Heap(int [],int);
    void printHeap(int [],int);
    void swap(int *a,int *b);
    void sort(int [],int);
    
    
    
    int main()
    {
    	register int t,i;
    	cin>>t;
    	int A[t];
    	for(i=0;i<t;i++)
    	{
    		scanf(""%d"",&A[i]);
    	}
    	//printHeap(A,t);
    	sort(A,t);
    	printHeap(A,t);
    	
    	return 0;
    }
    
    int left(int i) {return 2*i+1;}
    
    int right(int i) {return 2*i+2;}
    	
    void Max_Heapify(int A[],int i,int n)
    {
    	int l,r,largest;
    	l = left(i);
    	r = right(i);
    	
    	if(l < n && A[l] > A[i])
    		largest = l;
    	else
    		largest = i;
    	if(r < n && A[r] > A[largest])
    		largest = r;
    	
    	if(largest != i)
    	{
    		swap(&A[i],&A[largest]);
    		Max_Heapify(A,largest,n);
    	}
    }
    
    void printHeap(int A[],int n)
    {
    	int i;
    	for(i =0; i<n; i++)
    		printf(""%d\n"",A[i]);
    }
    
    void swap(int *a,int *b)
    {
    	int t;
    	t= *a;
    	*a = *b;
    	*b=t;
    }
    
    void Build_Max_Heap(int A[],int n)
    {
    	int i;
    	for(i = n/2-1; i >= 0; i--)
    	{
    		Max_Heapify(A,i,n);
    	}
    }
    
    void sort(int A[], int n)
    {
    	int i;
    	Build_Max_Heap(A,n);
    	for(i=n-1 ; i >= 0 ; i--)
    	{
    		swap(A[0],A[i]);
    		Max_Heapify(A,0,i);	
    		
    	}
    }

",C++
3632471,"
    #include<stdio.h>
    int main()
    {
    	int t;
    	scanf(""%d"",&t);
    	int a[100];
    	int i;
    	int j;
    	int k;
    	for(i = 0;i < t;i++){
    		scanf(""%d"",&a[i]);
    			}
    	for(i = 0;i < t;i++){
    		for(j = i+1;j < t;j++){
    		if(a[i] >> a[j]){
    		k = a[i];
    		a[i] = a[j];
    		a[j] = k;   
    		}
    		}
    	}
    	for(j = 0;j < t;j++){
    		printf(""%d\n"",a[j]);
    	}
    	
    	return 0;
    }

",C
3493687,"
    #include<cstdio>
    #include<iostream>
    #include<cstdlib>
    #include<algorithm>
    using namespace std ;
    
    int main(){
    	int t,i;
    
    	scanf(""%d"", &t);
    
    	int *a;
    	a=(int*)calloc(t,sizeof(int));
    
    	for(i=0;i<t;i++)
    		scanf(""%d"", &a[i]);
    
    	sort(a,a+t);
    
    	for(i=0;i<t;i++)
    		printf(""%d\n"", a[i]);
    
    	free(a);
    
    	return 0;
    }
    

",C++
3438359,"
    #include <stdio.h>
    
    int main() {
      int t;
      scanf(""%d"", &t);
      int n[t];
      register int x;
    
      for (x = 0; x < t; x++) {
        int y;
        register int i;
        scanf(""%d"", &y);
        /*printf(""Got: %d\n"", y);*/
    
        int tmp = -1;
        for (i = 0; i < x; i++) {
          if (tmp != -1) {
            int _tmp = tmp;
            tmp = n[i];
            n[i] = _tmp;
          } else if (y < n[i]) {
            tmp = n[i];
            n[i] = y;
          }
        }
    
        if (tmp != -1) {
          n[x] = tmp;
        } else {
          n[x] = y;
        }
      
        /*for (int i = 0; i <= x; i++) {*/
          /*printf(""%d "", n[i]);*/
        /*}*/
        /*puts("""");*/
      }
    
      for (x = 0; x < t; x++) {
        printf(""%d\n"", n[x]);
      }
    
      return 0;
    }
    

",C
3325095,"
    #include<iostream>
    using namespace std;
    
    int main()
    {
    unsigned long int ,i,j,temp=0,t,a[200];
    cin>>t;
    for(i=0;i<t;i++)
    {
    cout<<""\n"";
    cin>>a[i];
    }
    for(i=0;i<t;i++)
    {
    for(j=i+1;j<t;j++)
    {
    if(a[i]>a[j])
    {
    temp=a[i];
    a[i]=a[j];
    a[j]=temp;
    }
    }}
    for(i=0;i<t;i++)
    {
    cout<<""\n""<<a[i];
    }
    return 0;
    
    }

",C++
3307307,"
    #include<vector>
    #include<string>
    #include<algorithm>
    #include<iostream>
    #include<cmath>
    #include<cstdlib>
    #include<cstdio>
    #include<stack>
    #include<cstring>
    using namespace std;
    #define MOD 1000000007
    #define MAXLEN 111
    int a[1111111];
    int main()
    {
    	int i,n;
    	scanf(""%d"",&n);
    	for(i=0;i<n;i++)
    		scanf(""%d"",&a[i]);
    	sort(a,a+n);
    	for(i=0;i<n;i++)
    		printf(""%d\n"",a[i]);
    	system(""pause"");
        return 0;
    }

",C++
3209721,"
    #include<stdio.h>
    
    using namespace std;
         
    int a[1000000];
    void quickSort(int arr[], int left, int right)
     {
      int i = left, j = right;
      int tmp;
      int pivot = arr[(left + right) / 2];
      while (i <= j) 
      {
            while (arr[i] < pivot)
                  i++;
            while (arr[j] > pivot)
                  j--;
            if (i <= j) 
            {
                  tmp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = tmp;
                  i++;
                  j--;
            }
      }
       if (left < j)
        quickSort(arr, left, j);
        if (i < right)
            quickSort(arr, i, right);
    }
    
    
    int main()
    {
    	int t;
    printf(""enter the test cases:"");
    	scanf(""%d"",&t);
       
        for(int i=0;i<t;i++)
        scanf(""%d"",&a[i]);
        quickSort(a,0,t-1);
        for(int i=0;i<t;i++)
        printf(""%d\n"",a[i]);
        
        
    }
    

",C++
3152299,"
    #include <cstdio>
    #include <iostream>
    #include <string>
    
    #define S (1000000+1)
    static int data[S] = {0};
    
    int main()
    {
    	int i;
    	int lineCount;
    	scanf(""%d"", &lineCount);
    
    	while ( lineCount-- ) {
    		scanf(""%d"", &i);
    		data[i]++;
    	}
    
    	for ( int i = 1 ; i < S ; i++ ) {
    		while ( data[i]-- ) printf(""%d\n"", i);
    	}
    
    	return 0;
    }
    

",C++
3128592,"
    //counting short whith getchar_unlocked()
    #include<stdio.h>
    #include<stdlib.h>
    #define SIZE 1000000
    void scanint(long *);
    long temp[SIZE]={0};
    int main()
    {
    	long t;
    	scanint(&t);
    	long input[t],output[t],i=1,count=t;
    	while(count--)
    	{
    		long userInput;
    		scanint(&userInput);
    		input[i]=userInput;
    		i++;
    	}
    	for(i=1;i<=t;i++)
    		temp[input[i]]++;
    	for(i=1;i<=SIZE;i++)
    		temp[i]=temp[i]+temp[i-1];
    	for(i=t;i>=1;i--)
    	{
    		output[temp[input[i]]] = input[i];
    		temp[input[i]]--;
    	}
    	for(i=1;i<=t;i++)
    		printf(""%ld\n"",output[i]);
    	return 0;
    		
    }
    
    void scanint(long *x)
    {
    	int c=getchar_unlocked();
    	*x=0;
    	for(;c<48||c>57;c=getchar_unlocked());
    	for(;c>=48 && c<=57;c=getchar_unlocked())
    	{
    		*x=*x*10 + c - '0';
    	}
    }
    
    

",C
2899485,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.List;
    
    class TSort {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    			BufferedReader reader = new BufferedReader(new InputStreamReader(
    					System.in));
    			int t = Integer.parseInt(reader.readLine());
    			List<Long> list = new ArrayList<Long>();
    			while (t > 0) {
    				list.add(Long.parseLong(reader.readLine()));
    				t--;
    			}
    			Collections.sort(list);
    			Iterator<Long> iterator = list.iterator();
    			while (iterator.hasNext()) {
    				System.out.println((Long) iterator.next());
    			}
    		} catch (NumberFormatException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    
    }
    

",JAVA
2890397,"
    #include <iostream>
    #include <algorithm>
    #include <vector>
    
    using namespace std;
    
    int main()
    {
    	int n, d;
    	vector <int> v;
    	scanf(""%d"", &n);
    	for (int i = 0; i < n; i++) {
    		scanf(""%d"", &d);
    		v.push_back(d);
    	}
    	sort(v.begin(), v.end());
    	for (int i = 0; i < n; i++) {
    		printf(""%d\n"", v[i]);
    	}
    }

",C++
2868757,"
    // insertion sort
    #include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    int main(void) {
    	void sort(int[], int);
    	int i, j, n;
    	cin >> n;
    	int a[n];
    	for(int i = 0; i < n; i++)
    		cin >> a[i];
    	sort(a, n);
    	for(int i = 0; i < n; i++)
    		cout << a[i] << endl;
    	return 0;
    }
    
    // sorting function
    
    void sort(int a[], int n) {
    	int i, j, k;
    	for(i = 1; i < n; i++){
    		k = a[i];
    		for(j = i-1; (j >= 0) && (a[j] > k); j--) {
    			a[j+1] = a[j];
    		}
    		a[j+1] = k;
    	}
    }

",C++
2784901,"
    #include<stdio.h>
    
    int main()
    {
     int t, i,j,temp,a[6];
    scanf(""%d"",&t);
    for(i=0;i<t;i++)
    {
    scanf(""%d\n"",&a[i]);
    }
    for(i=0;i<t-1;i++)
    {
    for(j=0;j<t-i-1;j++)
    {
    if(a[j]>a[j+1])
    {
    temp =a[j];
    a[j]=a[j+1];
    a[j+1]=temp;
    }}}
    printf(""%d\n"",a[i]);
    return 0;
    }

",C
2746537,"
    #include <stdio.h>
    
    int main(void) {
    	long int t,arr[1000000],i,max=0,j,ans[1000000];
    	scanf(""%ld"",&t);
    	for(i=0;i<t;i++)
    	{
    		scanf(""%ld"",&arr[i]);
    	}
    	for(j=0;j<t;j++)
    	{
    		for(i=0;i<t;i++)
    		{
    			if(max<arr[i])
    			max=arr[i];
    		}
    		ans[j]=max;
    		for(i=0;i<t;i++)
    		{
    			if(max==arr[i])
    			arr[i]=0;
    			
    		}
    		max=0;
    	}
    	for(i=0;i<t;i++)
    	printf(""\n%ld"",ans[i]);
    	return 0;
    }
    

",C
2389586,"
    #include<cstdio>
    #include<algorithm>
    using namespace std;
    
    int main(){
    	int arr[1000000];
    	int t,i;
    	scanf(""%d"",&t);
    	for(i=0;i<t;i++) scanf(""%d"",&arr[i]);
    	sort(arr,arr+t);
    	for(i=0;i<t;i++) printf(""%d\n"",arr[i]);
    }

",C++
2369108,"
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    
    int list[1000001];
    char chararr[10000000];
    char out[10000000];
    int main()
    {
        int i=0,num=0,j,lines=0;
       // FILE* fp=fopen(""input1.txt"",""r"");     
        double start=clock(); 
        int br=fread(chararr,sizeof(char),10000000,stdin);
        chararr[br]=0;
         
         puts(chararr);
        for(i=0;chararr[i]!='\n';i++)
          lines=chararr[i]-'0'+lines*10;
        i++;
        j=i;
        int k;
        for(k=0;k<lines;k++)
        {
            num=0;
            for(;chararr[j]!='\n'&&chararr[j]!='\0';j++)
            {
             num=chararr[j]-'0'+num*10;
             
            }
            list[num]=1;
             printf(""\t%d"",num);
             j++;
            // printf(""\n%d"",num);
        }
        int r=0,k2=0;
        char temp[7];
        
       // for(num=0;num<=56;num++)
         //  printf(""\n%d"",list[num]);
        int num2;
        for(num=0;num<=1000000;num++)
        {
            if(list[num]==1)
            {
                r=0;
                if(num==0)
                   temp[r++]=num+48;
                    
                num2=num ;   
                while(num2)
                {
                    temp[r++]=num2%10+48;
                    num2=num2/10;
                }
                
               // printf(""\n%s"",temp);
                while(r!=0)
                  out[k2++]=temp[--r];
                  
                  out[k2++]='\n';
            }
        }
        
       // FILE* f2=fopen(""outfile2.txt"",""w"");
        fwrite(out,sizeof(char),strlen(out),stdout);
          //puts(""hi"");
        //  printf(""execution time is %lf"",(clock()-start)/CLOCKS_PER_SEC);
          
         // printf(""\n%d"",num);
        return 0;
    }
    

",C
2188851,"
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
     {
         int t;
     cin>>t;
     int array[t];
     if(t<=10*10*10*10*10*10)
      {
          for(int i=0;i<t;i++)
           { 
              cin>>array[i];
           }
          sort(array,array+t);
           for(int n=0;n<t;n++)
           {if(array[n]!=array[n+1])
           {cout<<array[n];}}   
      }
      return 0;
     }

",C++
1955401,"
    #include<iostream>
    #include<stdio.h>
    
    using namespace std;
    
    class StandardInputStreamReader
    {
    	char *arr;
    	int index;
    	int BufferSize;
    	public:
    	StandardInputStreamReader()
    	{
    		BufferSize=4096;
    		arr=new char[BufferSize+1];
    		index=0;
    		readNextBlock();
    	}
    	
    	inline void readNextBlock()
    	{
    		fread(arr,1,BufferSize,stdin);
    	}
    		
    	inline void skipEmptySpaces()
    	{
    		while(arr[index] == ' ' || arr[index]== '\n' || arr[index]=='\t')
    		{   index++;
    			if(index==BufferSize){
    				index=0; readNextBlock(); 	}
    		}
    		if(index==BufferSize){ //if both non ' ' or '\n' collide with BufferSize
    				index=0; readNextBlock(); 	}
    	}
    	inline int nextInt()
    	{
    		int res=0; bool isNegative=false;
    		skipEmptySpaces();
    		if(arr[index]=='-')
    		{	index++;  isNegative=true; 	}
    		res=nextUnsignedInt();
    		if(isNegative)
    			return res*-1;
    	}
    	
    	inline unsigned nextUnsignedInt()
    	{
    		unsigned res=0;
    		skipEmptySpaces();
    		while(arr[index] !=' ' && arr[index] != '\n' && arr[index] != EOF)
    		{ 	
    			res= (res*10) + (arr[index] - '0'); index++;
    			if(index==BufferSize)
    			{	index=0; readNextBlock(); 	}
    		}
    		return res;				
    	}
    };
    
    
    int main()
    {	
    	StandardInputStreamReader r=StandardInputStreamReader();
    	int n,num;
    	n=r.nextInt();
    	char arr[1000001]={0};
    	for(int i=0;i<n;i++)
    	{
    		cin>>num;
    		arr[num]++;
    	}
    	for(int i=0;i<1000001;i++)
    		  while(arr[i]--)
    			cout<<i<<endl;	
    	
    	return 0;
    }
    
    
    
    

",C++
1854179,"
         #include<stdio.h>
        long int m(long int);
        int main()
        {
        int i=0;
        int count=0,cnt=0;
        long int t=0;
        long int n=0;
        long int a[100],b[100],c[100],max=0;
        scanf(""%ld"",&t);
        for(i=0;i<t;i++)
        {
        scanf(""%ld"",&a[i]);
        count++;
        max=m(a[i]);
        }
        for(i=0;i<=max;i++) c[i]=0;
        for(i=0;i<count;i++)
        {
        c[a[i]]=c[a[i]]+1;
        }
        for(i=1;i<=max;i++)
        {
        c[i]=c[i]+c[i-1];
        }
        cnt=count;
        for(i=0;i<count;i++)
        {
        b[c[a[i]]]=a[i];
        c[a[i]]--;
        }
        i =1;
        while(count>0)
        {
        printf(""%ld\n"",b[i]);
        i++;count--;
        }
        return 0;
        }
        long int m(long int X)
        {
        static long int i=0;
        if(X>i)
        i=X;
        return i;
        } 

",C
1480514,"
    /*
     * PERMUT2.cpp
     *
     *  Created on: Oct 16, 2012
     *      Author: sanjeev
     */
    
    #include <cstdio>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
    	int n;
    	int pos[1000000];
    
    	scanf(""%d"", &n);
    
    	for(int i = 0; i < n; ++i)
    		scanf(""%d"", &pos[i]);
    
    	sort(pos, pos+n);
    
    	for(int i=0;i<n;++i)
    		printf(""%d\n"", pos[i]);
    
    	return 0;
    }
    
    
    
    

",C++
1125022,"
    #include<stdio.h>
    inline int inp( )
    {
    int n=0;
    char ch;
    for(ch=getchar(); ch >= '0' && ch <= '9' ; ch=getchar())
    n = (n*10) + ch-'0';
    return n;
    }
    int arr[1000000];
    int main()
    {
    int i,n;
    n=inp();
    while(n--)
    arr[inp()]++;
    for(i=0;i<1000000;i++)
    while(arr[i]--)
    printf(""%d\n"",i);
    return 0;
    }
    

",C
979992,"
    #include<stdio.h>
    int main()
    {
        long int t,i,j,k,num[100],temp;
        puts(""Input:"");
        scanf(""%d"",&t);
       if(t<=1000000)
       {
        for(i=0;i<t;i++)
        {
          scanf(""%d"",&num[i]);
          if(!(num[i]>=0 && num[i]<=1000000))
            exit(1);
        }
        puts(""Output:"");
        for(i=0;i<t-1;i++)
        {
         for(j=i+1;j<t;j++)
         {
          if(num[i]>num[j])
          {
           temp=num[i];
           num[i]=num[j];
           num[j]=temp;
          }
         }
        }
        for(k=0;k<t;k++)
          printf(""%d\n"",num[k]);
       }
        getch();
        return(0);
    }
    

",C
812136,"
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    class turbosort {
        public static void main(String args[]) throws IOException
        {
        
          BufferedReader b=new BufferedReader(new InputStreamReader(System.in));
            int t=Integer.parseInt(b.readLine());
          int a[]=new int[t];
    
            for(int i=0;i<t;i++)
            {
                a[i]=Integer.parseInt(b.readLine());
            }
          for(int i=0;i<t;i++)
          {
              for(int j=0;j<t-i-1;j++)
              {
                  if(a[j]>a[j+1])
                  {
                      int temp=a[j];
                      a[j]=a[j+1];
                      a[j+1]=temp;
                  }
    
              }
          }
          for(int i=0;i<t;i++)
          {
              System.out.println(a[i]);
          }
    
        }
    
    }
    

",JAVA
779797,"
    #include <iostream>
    using namespace std;
    
    
    void turboSort(long numbers[], unsigned long array_size)
    {
      int i, j, increment, temp;
    
      increment = 3;
      while (increment > 0)
      {
        for (i=0; i < array_size; i++)
        {
          j = i;
          temp = numbers[i];
          while ((j >= increment) && (numbers[j-increment] > temp))
          {
            numbers[j] = numbers[j - increment];
            j = j - increment;
          }
          numbers[j] = temp;
        }
        if (increment/2 != 0)
          increment = increment/2;
        else if (increment == 1)
          increment = 0;
        else
          increment = 1;
      }
    }
    
    long n[1000000];
    int main()
    {
         unsigned long t,s;
    
        cin >>t;
        if(t>0 && t<=1000000)
            {
              for(int i=0;i<t;i++)
              {
               cin>>s;
                if(s>=0 && s<=1000000)
                {
                    n[i]=s;
    
                }
    
    
              }
            }
    
        turboSort(n,t);
    
    
        for(int g=0;g<t;g++)
        cout << n[g]<<endl;
    
    
    }
    

",C++
770369,"
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    
    public class Main {
    	public static void main(String[] args) throws java.lang.Exception {
    		BufferedReader buff = new BufferedReader(new InputStreamReader(
    				System.in));
    		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    		int i, aux,j;
    		int n = Integer.parseInt(buff.readLine());
    		int[] arr = new int[1000000];
    		for (i = 0; i < n; i++) {
    			aux = Integer.parseInt(buff.readLine());
    			arr[aux - 1]++;
    			
    		}
    		for (i = 0; i < 1000000; i++) {
    			for (j = 0; j < arr[i]; j++) {
    			pw.println(i+1);
    			}
    		}
    		pw.flush();
    	}
    
    }
    

",JAVA
758411,"
    #include<stdio.h>
    #include<malloc.h>
    int partition(int *a,int low,int high)
    {
        int i,j,x;
        i=low;
        x=a[high];
        for(j=low;j<high;j++)
        {
            if(a[j]<=x)
            {
                int tmp=a[j];
                a[j]=a[i];
                a[i]=tmp;
                i++;
            }
        }
        int tmp = a[i];
        a[i]=a[high];
        a[high]=tmp;
        return i;
    }
    
    void quickSort(int *a,int low,int high)
    {
       int mid;
       if(low>=high)
       return;
       mid = partition(a,low,high);
       quickSort(a,low,mid-1);
       quickSort(a,mid+1,high);
    }
    
    int main()
    {
    int i,j,t,*a;
    a=malloc(1000000*sizeof(int));
    scanf(""%d"",&t);
    for(i=0;i<t;i++)
    {
        scanf(""%d"",&a[i]);
    }
    quickSort(a,0,t-1);
    for(j=0;j<t;j++)
    printf(""%d\n"",a[j]);
    }
    
    

",C
745628,"
    puts STDIN.read.split(""\n"")[1..-1].map(&:to_i).sort.join(""\n"")
    

",RUBY
702517,"
    #include<stdio.h>
    #include<cstdlib>
    void quicksort(unsigned int *,int,int);
    int split(unsigned int [],int ,int);
    int main()
    {
            unsigned int t,n,temp=0;
            scanf(""%d"",&t);
            if(t>1000000)
                    exit(0);
            unsigned int ar[t];
            for(int i=0;i<t;++i)
            {
                    scanf(""%d"",&ar[i]);
                    if(ar[i]<0||ar[i]>1000000)
            }
            quicksort ( ar, 0, t ) ;
            for ( int i = 0 ; i <t  ; i++ )
                    printf ( ""%d\n"", ar[i] ) ;
            return 0;
    }
    void quicksort ( unsigned int a[ ], int lower, int upper )
    {
            int i ;
            if ( upper > lower )
            {
                    i = split ( a, lower, upper ) ;
                    quicksort ( a, lower, i - 1 ) ;
                    quicksort ( a, i + 1, upper ) ;
            }
    }
    
    int split ( unsigned int a[ ], int lower, int upper )
    {
            int i, p, q, t ;
            p = lower + 1 ;
            q = upper ;
            i = a[lower] ;
          while ( q >= p )
            {
                    while ( a[p] < i )
                            p++ ;
                    while ( a[q] > i )
                            q-- ;
                    if ( q > p )
                    {
                            t = a[p] ;
                            a[p] = a[q] ;
                            a[q] = t ;
                    }
            }
            t = a[lower] ;
            a[lower] = a[q] ;
            a[q] = t ;
            return q ;
    }

",C++
616759,"
    #include<stdio.h>
    main()
    {
          int n,a[1000001]={0},i;
          scanf(""%d"",&n);
          while(n!=0)
          {
                     scanf(""%d"",&i);
                     a[i]=1;     
                     
                     
                     n--;
                     }
                     for(i=0;i<1000001;i++)
                     {if(a[i]==1)
                     printf(""%d\n"",i);}
                    
                     return 0;
    }
    

",C
539492,"
    import java.util.Scanner;
    
    public class Main{
    	public static void main(String args[]) {
    		int i = 0;
    		int arr[] = new int[1000000];
    		Scanner in = new Scanner(System.in);
    		Integer x = new Integer(in.nextLine());
    		for (i = 0; i < x; i++) {
    			Integer num=new Integer(in.nextLine());
    			arr[num]++;
    		}
    		for(i=0;i<1000000;i++)
    		{
    			int count=arr[i];
    				if(count==0)
    				continue;
    				for(int j=0;j<count;j++)
    					System.out.println(i);
    		}
    	}
    }
    
    

",JAVA
406093,"
    #include<stdio.h>
    int ary[1000000];
    void swap(long *a,long *b)
    {
    	*a=*a+*b;
    	*b=*a-*b;
    	*a=*a-*b;
    }
    void heapify(long,long);
    void createheap(long k)
    {	long i;
    	for(i=k-1;i>=0;i--)
    	{	heapify(i,k);
    	}
    	return;
    }
    void heapify(long a,long n)
    {	long l,r,lr;
    	l=2*a+1;
    	r=l+1;
    	if(l<=n && ary[l]>ary[a])
    		lr=l;
    	else
    		lr=a;
    	if(r<=n && ary[r]>ary[lr])
    		lr=r;
    	if(lr!=a)
    	{	swap(ary+a,ary+lr);
    		heapify(lr,n);
    	}
    }
    void heapsort(long n)
    {	long i,j;
    	createheap(n);
    	printf(""\n"");
    	for(i=n-1;i>0;i--)
    	{	swap(ary,ary+i);
    		heapify(0,i-1);
    		for(j=0;j<n;j++)
    			printf(""%d "",ary[j]);
    		printf(""\n"");
    	}
    }
    int main()
    {
    	long i,n;
    	scanf(""%ld"",&n);
    	for(i=0;i<n;i++)
    		scanf(""%ld"",ary+i);
    	heapsort(n);
    	for(i=0;i<n;i++)
    	 	printf(""%ld\n"",ary[i]);
    }
    

",C
315722,"
    #include<cstdio>
    #include<iostream>
    #include<cmath>
    
    using namespace std;
    
    inline int ndigits(long long n){return (int)log10(n) + 1;}
    
    void merge(int * arr1, int n1, int n){
    	int temp[n];
    	
    	int it1 = 0, it2 = n1;
    	int i;
    	for (i = 0 ; it1 != n1 && it2 != n ; i++){		
    		if (arr1[it1] >= arr1[it2]){
    			temp[i] = arr1[it2];
    			it2++;	
    		}	
    		else{
    			temp[i] = arr1[it1];
    			it1++;		
    		}
    	}	
    	
    	if (it1 == n1){
    		for (int j = 0 ; j < it2 ; i++)
    			arr1[i] = temp[i];	
    			
    		return;
    	}
    	
    	if (it2 == n){
    		for (int j = i ; j < n ; j++){			
    			temp[j] = arr1[it1];		
    			it1++;
    		}
    	}
    	
    	for (int i = 0 ;i  < n ; i++)
    		arr1[i] = temp[i];
    }
    
    void bsort(int * arr, int n){
    	if (n == 1)
    		return;
    	
    	bsort(arr, n/2);
    	bsort(arr + n/2, n - n/2);
    	
    	merge(arr, n/2, n);
    }
    
    int main(){
    	int n, k;
    	
    	scanf(""%d"", &n);
    
    	int ans = 0;	
    	long long num;
    	
    	int inpSize = 7 * n;
    	char * input = new char[inpSize];
    	fread(input, 1, inpSize, stdin);
    	
    	int arr[n];
    	
    
    	//cout << input ;
    	
    	int j = 1;
    	for (int i = 0 ; i < n ; i++){		
    		num = 0;
    		for ( ; j < inpSize ; j++){
    			if (input[j] == '\n')
    				break;
    			else
    				num = num * 10 + input[j] - '0';	
    		}
    		j++;		
    
    
    		arr[i] = num;		
    	}
    
    	bsort(arr, n);
    
    	for (int i = 0 ; i < n ; i++)
    		printf(""%d\n"", arr[i]);
    
    	//system(""pause"");	
    }
    

",C++
310318,"
    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    
    using namespace std;
    
    #define N 1000000
    
    int main()
    {
        unsigned long long t;
        
        cin>>t;
        
        unsigned long long *A,*B;
        
        A=(unsigned long long *)malloc(sizeof(unsigned long long)*(t+1));
        B=(unsigned long long *)malloc(sizeof(unsigned long long)*(t+1));
        
        unsigned int *C;
        
        C=(unsigned int *)malloc(sizeof(unsigned int)*(N+1));
        
        unsigned long long i;
        
        for(i=1;i<t+1;i++)
        cin>>A[i];
        
        for(i=0;i<=N;i++)
        C[i]=0;
        
        for(i=1;i<t+1;i++)
        C[A[i]]=C[A[i]]+1;
        
        for(i=1;i<=N;i++)
        C[i]=C[i]+C[i-1];
        
        for(i=t;i>=1;i--)
        {
                         B[C[A[i]]]=A[i];
                         C[A[i]]--;
        }
        
        for(i=1;i<=t;i++)
        cout<<B[i]<<""\n"";
        
        getchar();
        getchar();
        
        return 0;
    }
    

",C++
195735,"
    #include<iostream>
    #include<cmath>
    #include<algorithm>
    #include<vector>
    #include<fstream>
    #include<bitset>
    
    
    using namespace std;
    
    int t,n;
    
    
    
    
    int main()
    {
       scanf(""&d"",&t);
       vector<int>v;
       for(int i=0;i<t;i++)
       {
               scanf(""%d"",&n);
               v.push_back(n);
       }
       sort(v.begin(),v.end());
       for(int i=0;i<t;i++)
       printf(""%d\n"",v[i]);
    
       system(""pause"");
       return 0;
    
    }
    

",C++
150251,"
    #include <iostream>
    #include <set>
    #include <algorithm>
    
    using namespace std;
    
    int main()
    {
    	int t;
    	int n;
    	set<int> data;
    
    	cin >> t;
    
    	for (int i = 0; i < t; i++)
    	{
    		cin >> n;
    
    		data.insert(n);
    	}
    
    	for (set<int>::iterator i = data.begin(); i != data.end(); i++)
    	{
    		cout << *i << '\n';
    	}
    }

",C++
89179,"
    #include<stdio.h>
    
    int main()
    {
    int t=0;
    int i=0;
    int n=0;
    char num[8];
    int count[8]={0};
    int x=0,d=0;
    int a[10][29]={0};
    int k=0,j=0;
    scanf(""%d"",&t);
    
    for(i=0;i<t;i++)
    {
    d=0;
    scanf(""%s"",num);
    if(num[0]=='0') { printf(""0\n""); continue; }
    n=0;
    while(num[n]!='\0') { d++; n++; }
    count[d]++;
    n=0;
    x=1;
    while(x<=d)
    {
    a[num[x-1]-48][x+d*(d-1)/2]++;
    x++;
    }
    }
    
    
    for(i=1;i<=7;i++)
    {
    while(count[i])
    {
    for(j=1;j<=i;j++)
    {
    for(k=0;k<=9;k++)
    {
    if(a[k][j+i*(i-1)/2]) {printf(""%d"",k);a[k][j+i*(i-1)/2]--;break;}
    }
    }
    count[i]--;
    printf(""\n"");
    }
    }
    return 0;
    }

",C
86064,"
    #!/usr/bin/python
    
    import heapq
    
    def funct():
    	t=int(raw_input())
    
    	l=[]
    
    	heappush=heapq.heappush
    	for times in range(t):
    		heappush(l,int(raw_input()))
    	heappop=heapq.heappop
    
    	while l:
    		print heappop(l)
    
    funct()
    

",PYTH
71425,"
    <?php
    
    $n = fgets(STDIN);
    
    $numbers = array();
    
    for ($i = 0; $i < $n; $i++)
    {
        $numbers[] = fgets(STDIN);
    }
    
    sort($numbers);
    
    foreach ($numbers as $number)
        echo $number;

",PHP
57163,"
    #include<iostream>
    using namespace std;
    int main(){
        int n,mx,mn,i,x;
        while(cin>>n){
        char arr[1000001]={0};
        mx=-1;
        mn=10000000;
        for(i=0;i<n;i++){
        cin>>x;
        if(mx<x)
        mx=x;
        if(mn>x)
        mn=x;
        arr[x]++;}
        for(i=mn;i<=mx;i++){
        if(arr[i]>0){
        while(arr[i]--)
        cout<<i<<""\n"";}}}}
    

",C++
35945,"
    #include <iostream>
    #include <cstdio>
    
    #define rep(i,n) for(int i=0; i<n; i++)
    
    using namespace std;
    void mergeSort(int f, int l);
    int n;
    int a[300000];
    int main()
    {
        
        scanf(""%d"",&n);
        rep(i,n)
           scanf(""%d"",&a[i]);
        mergeSort(0,n-1);
        rep(i,n)
                printf(""%d\n"",a[i]);
        
        return 0;
    }
    void mergeSort(int f,int l)
    {
         if(f==l)
                return;
         int mid =(f+l)/2;
         mergeSort(f, mid);
         mergeSort(mid+1, l);
         
         
         int * tmp=new int[l-f+1];
         int i=0,li=f,ri=mid+1;
         while((li<=mid)&&(ri<=l))
         {
              if(a[li]<a[ri])
              {
                 tmp[i++]=a[li++];
              }
              else
              {
                 tmp[i++]=a[ri++];
              }
         }
         if(li<=mid)
         {
              for(int j=li;j<=mid;j++)
                 tmp[i++]=a[j];
         }
         if(ri<=l)
         {
              for(int j=ri;j<=l;j++)
                 tmp[i++]=a[j];
         }
         int t=0;
         for(int i=f;i<=l;i++)
         {
              a[i]=tmp[t++];
         }
         
    }
    

",C++