akhauriyash/Code-Regression huggingface dataset:
/**
 *  author: mahfuzz
 *  created: 06.07.2020
**/
 
#include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define trace(x) cout << #x << ':' << x << "\n"
typedef long long ll;

int main(int argc, char* argv[]){
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    
    int sum = 0;
    for(int i = 0; i < 5; i++){
        int x; cin >> x;
        sum += x;
    }
    
    cout << 15 - sum << "\n";
        
    return 0;
}



Measured memory_bytes: 3628
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
int a[1005];
vector<int> va[1005];
int b[5005];
int main(){
	int n,m;
	int i,j,k;
	int s=0,x=0,y=0,z=0;
	cin>>n>>m;
	for(i=0;i<n;i++){
		cin>>j;
		va[j].push_back(i+1);
	}
	for(i=0;i<m;i++){
		cin>>b[i];
	}
	for(i=0;i<m;i++){
		memset(a,0,sizeof(a));
		for(j=i;j<m;j++){
			for(z=0,k=a[b[j]];k<va[b[j]].size();k++){
				if(x<va[b[j]][k]){
					x=va[b[j]][k];
					y++;
					a[b[j]]=k+1;
					z=1;
					break;
				}
			}
			if(z==0){
				if(s<y)s=y;
				x=0,y=0;
				break;
			}
		}
		if(s<y)s=y;
		x=0,y=0;	
	}
	cout<<s<<endl;
	return 0;
}

Measured memory_bytes: 3232
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define MOD (1000000007l)
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)

using namespace std;

void solve() {
  char input[2000];
  cin.getline(input, sizeof(input));
  rep (i, 2000) {
    char tmp = input[i];
    if (tmp == 0) break;
    if ('a' <= tmp and tmp <= 'z') input[i] += 'A' - 'a';
    else if ('A' <= tmp and tmp <= 'Z') input[i] += 'a' - 'A';
  }
  cout << input << endl;
}

int main(void) {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout.precision(12);
  cout << fixed;
  solve();
  return 0;
}



Measured memory_bytes: 3172
#include<iostream>
    #include<algorithm>
    #include<functional>
    #include<cmath>
    #include<string>
    #include<vector>
    #include<stack>
    #include<queue>
    #include<map>
    #include<set>
    #include<deque>
    using namespace std;
    #define ll long long
    const int mod = 1000000007;
    const ll INF = 1000000000000000000;
     
    struct UnionFind {
    	vector<int> par;
    	UnionFind(int x) : par(x, -1) {}
    	void init(int x) { par.assign(x, -1); }
    	int root(int x) {
    		if (par[x] <= -1) return x;
    		else return root(par[x]);
    	}
    	bool issame(int x, int y) {
    		return root(x) == root(y);
    	}
    	bool merge(int x, int y) {
    		x = root(x); y = root(y);
    		if (x == y) return false;
    		if (par[x] > par[y]) swap(x, y);
    		par[x] += par[y];
    		par[y] = x;
    		return true;
    	}
    	int size(int x) {
    		return -par[root(x)];
    	}
    };
     
    int p[100010];
    int main()
    {
    	int N, M;
    	cin >> N >> M;
    	for (int i = 0; i < N; i++) {
    		cin >> p[i];
    		p[i]--;
    	}
    	UnionFind uf(N);
    	for (int i = 0; i < M; i++) {
    		int a, b;
    		cin >> a >> b;
    		a--; b--;
    		uf.merge(a, b);
    	}
    	int ans = 0;
    	for (int i = 0; i < N; i++) {
    		if (uf.issame(i, p[i])) ans++;
    	}
    	cout << ans << endl;
    }

Measured memory_bytes: 4016
#[allow(unused_imports)]
use itertools::Itertools;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;

fn main() {
    input! {
        n: usize,
        k: usize,
        a: [i64; n],
    }
    for i in k..n {
        if a[i] > a[i - k] {
            println!("Yes");
        } else {
            println!("No");
        }
    }
}


Measured memory_bytes: 5532
import java.util.HashSet;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
//		String s = sc.next();
		int n = sc.nextInt();

		HashSet<Integer> set = new HashSet<>();

		for(int i=0;i<n;i++) {
			set.add(sc.nextInt());
		}

		if(set.size() == n) {
			System.out.println("YES");
		}else {
			System.out.println("NO");
		}

//		System.out.println();



	}
}


Measured memory_bytes: 100044
N, M = map(int, input().split())
l = []
for _ in range(M):
    a, b = map(int, input().split())
    c = tuple(map(int, input().split()))
    l.append((a, c))

inf = 10**12
dp = [inf]*(2**N)
dp[0] = 0

for i in range(2**N):
    for cost, j in l:
        v=0
        for k in j:
            v+=2**(k-1)
        dp[i|v] = min(dp[i|v], dp[i]+cost)

print(dp[2**N-1] if dp[2**N-1]!=inf else -1)

Measured memory_bytes: 45928
#include <bits/stdc++.h>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::bitset;

#define rep(i,n)    for(int i=0; i<(int)(n); i++)
#define reps(i,s,e) for(int i=s; i<(int)(e); i++)
#define coutd(i) cout << std::fixed << std::setprecision(i)
typedef long double ld;
typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;

template<class T>
using Set = std::set<T>;
template<class T, class U>
using Map = std::map<T, U>;

template<class T>
using Graph = vector<vector<T>>;

const int INT_BIG = 1<<28;

int main() {
    int N;
    cin >> N;
    vint nums(N);
    rep(i, N) {
        cin >> nums[i];
    }
    int judgenot = -1;
    rep(i, N-1) {
        if (judgenot == -1) {
            judgenot = std::__gcd(nums[i], nums[i+1]);
        } else {
            judgenot = std::__gcd(judgenot, std::__gcd(nums[i], nums[i+1]));
        }
    }
    if (judgenot != 1) {
        cout << "not coprime" << endl;
        return 0;
    }
    vector<bool> flag(1000000+10, false);
    rep(i, N) {
        int num = nums[i];
        for (int j = 2; j*j <= num; j++) {
            if (num % j == 0) {
                // cout << num << " " << j << endl;
                if (flag[j] || flag[num/j]) {
                    cout << "setwise coprime" << endl;
                    return 0;
                }
                flag[j] = true;
                flag[num/j] = true;
            }
        }
        if (num != 1) {
            if (flag[num]) {
                cout << "setwise coprime" << endl;
                return 0;
            }
            flag[num] = true;
        }
    }
    cout << "pairwise coprime" << endl;
}

Measured memory_bytes: 7128
#pragma region include
#include "bits/stdc++.h"
#define ALL(obj) (obj).begin(),(obj).end()
#define RALL(obj) (obj).rbegin(),(obj).rend()
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define REPR(i, n) for(int i = (int)(n); i >= 0; i--)
#define FOR(i,n,m) for(int i = (int)(n); i < int(m); i++)
#define MOD (int)(1e9+7)
#define INF (int)(1e9)
#define LLINF (int)(4e18)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
void input() {}
template<typename... R> void input(int& f, R&... r) { scanf("%d", &f); input(r...); }
template<typename... R> void input(double& f, R&... r) { scanf("%lf", &f); input(r...); }
template<typename... R> void input(ll& f, R&... r) { scanf("%lld", &f); input(r...); }
template<typename... R> void input(char& f, R&... r) { scanf("%c", &f); input(r...); }
template<typename T, typename... R> void input(vector<T>& f, R&... r) { REP(i, f.size())input(f[i]); input(r...); }
#pragma endregion

int main() {
    string s; cin >> s;
    map<char, int> mp;
    REP(i, 4) mp[s[i]]++;
    for (auto p : mp) {
        if (p.second != 2) {
            cout << "No" << endl;
            return 0;
        }
    }
    cout << "Yes" << endl;
    getchar(); getchar();
}

Measured memory_bytes: 256
#include"bits/stdc++.h"
using namespace std;
#define LL long long
#define REP(i, n) for(int (i)=0; (i)<(n); (i)++)
#define PB push_back
#define MP make_pair
#define all(x) x.begin(),x.end()

#define MOD 998244353LL

//累乗 O(log N)
long long power(long long x, int N){
	if(N == 1) return x;
	long long tmp = power(x, N/2);
	if(N%2 == 0) return tmp * tmp % MOD;
	else return tmp * tmp % MOD * x % MOD;
}

int N, a[300], sum=0;
int dp[300][90001];
LL solve(int now, int s){
	if(now == N){
		if(s >= ceil((double)sum/2)) return 1;
		else return 0;
	}
	if(dp[now][s] != -1) return dp[now][s];
	dp[now][s] = (solve(now+1, s)*2 + solve(now+1, s+a[now])) % MOD;
	//cout << now << " " << s << " " << dp[now][s] << endl;
	return dp[now][s];
}
int dp2[300][90001];
LL solve2(int now, int s){
	if(sum%2 == 1) return 0;
	if(now == N){
		if(s == sum/2) return 1;
		else return 0;
	}
	if(dp2[now][s] != -1) return dp2[now][s];
	dp2[now][s] = (solve2(now+1, s) + solve2(now+1, s+a[now])) % MOD;
	//cout << now << " " << s << " " << dp[now][s] << endl;
	return dp2[now][s];
}
int main(){
	cin >> N;
	sum = 0;
	for(int i=0; i<N; i++){
		cin >> a[i];
		sum += a[i];
		for(int j=0; j<=N*300; j++) dp[i][j] = -1;
		for(int j=0; j<=N*300; j++) dp2[i][j] = -1;
	}
	//cout << sum << endl;
	cout << (power(3,N) + 5*MOD - solve(0,0)*3 + solve2(0,0)*3) % MOD << endl;
}
//ジャスト半々になる場合を忘れずに

Measured memory_bytes: 211200
#include <iostream>
using namespace std;
int main()
{
    int i, j, k, h, w;

    cin >> h >> w;
    while(h>0 || w>0)
    {
        for(i=1; i<=h; i++)
        {
            for(j=1; j<=w; j++)
            {
                if (i%2==1 && j%2==0 || i%2==0 && j%2==1)
                    cout << ".";
                else
                    cout << "#";
            }
            cout << endl;
        }
        cout << endl;
        cin >> h >> w;
    }
}


Measured memory_bytes: 3092
#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<algorithm>
#include<map>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<set>
using namespace std;

typedef long long ll;
typedef pair<int,int> P;
#define INF 1000000100
#define rep(i,n) for (int i=0;i<n;i++)

int main(){
    int N,M;
    cin >> N >> M;
    priority_queue<int, vector<int>> p;
    rep(i,N){
        int a;
        cin >> a;
        p.push(a);
    }
    rep(i,M){
        int a = p.top(); p.pop();
        a /= 2;
        p.push(a);
    }

    ll sum=0;
    while(!p.empty()){
        sum += p.top();
        p.pop();
    }
    cout << sum << endl;
    return 0;
}

Measured memory_bytes: 3524
#include <bits/stdc++.h>
using namespace std;


void solve(long long A, long long B, long long C, long long D){
    cout << min(A, B)+min(C, D)<< endl;
}

int main(){
    long long A;
    scanf("%lld",&A);
    long long B;
    scanf("%lld",&B);
    long long C;
    scanf("%lld",&C);
    long long D;
    scanf("%lld",&D);
    solve(A, B, C, D);
    return 0;
}


Measured memory_bytes: 256
import math
from decimal import Decimal, ROUND_DOWN
def main():
    a,b = list(input().split())
    a = Decimal(a)
    b = Decimal(b)
    ans = a * b
    print(Decimal(ans).quantize(Decimal(1), rounding=ROUND_DOWN))
 
if __name__=='__main__':
    main()

Measured memory_bytes: 9844
#include <iostream>
#include<stdio.h>
using namespace std;

int main()
{
   int n;
   double a[120],sum=0;
   cin>>n;
   for(int i=0;i<n;i++)
   {
       cin>>a[i];
       sum=sum+1.0/a[i];
   }
   printf("%.6f\n",1.0/sum);

}


Measured memory_bytes: 256
#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
#define all2(a, b) (a).begin(), (a).begin() + (b)
#define debug(vari) cerr << #vari << " = " << (vari) << endl;

int main()
{
    int S, W;
    cin >> S >> W;
    string ans = (W >= S) ? "unsafe" : "safe";
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 3596
import java.util.*;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int K = sc.nextInt();
    for (int i = 0; i < N; i++) {
      int a = sc.nextInt();
    }
    int ans = (N - 1) / (K - 1);
    if ((N - 1) % (K - 1) != 0) {
      ans += 1;
    }
    System.out.println(ans);
  }
}

Measured memory_bytes: 48588
# -*- coding: utf-8 -*-
from heapq import heappop, heappush
def inpl(): return list(map(int, input().split()))
N, M, P, A, B = inpl()
INF = 10**6

while N:
    T = inpl()
    G = [[] for _ in range(M+1)]
    D = [2**i for i in range(N)]

    for _ in range(P):
        x, y, z = inpl()
        G[x].append([y, z])
        G[y].append([x, z])
    HQ = [[0, A, 0]] # time, where, used_ticket
    memo = [[INF]*(2**N) for _ in range(M+1)]

    while HQ:
        t, p, u = heappop(HQ)
        if memo[p][u] < t:
            continue
        if p == B:
            print(t)
            break
        for q, c in G[p]:
            for i in range(N):
                nu = u&D[i]
                if u&D[i] == 0 and t + c/T[i] < memo[q][u^D[i]]:
                    memo[q][u^D[i]] = t + c/T[i]
                    heappush(HQ, [t + c/T[i], q, u^D[i]])
    else:
        print("Impossible")
    N, M, P, A, B = inpl()


Measured memory_bytes: 12368
#include <bits/stdc++.h>
using namespace std;

//#define int long long
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<n;++i)
#define exrep(i, a, b) for(ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<bool> > vvb;
typedef vector<vector<double> > vvd;
typedef vector<vector<string> > vvs;
typedef vector<ll> vl;
typedef vector<vector<ll> > vvl;
typedef vector<vector<vector<ll> > > vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647; // 2^31-1
const double PI = acos(-1);
//cout<<fixed<<setprecision(10);

template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T> void debug(T v){rep(i,v.size()) cout<<v[i]<<" ";cout<<endl;}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const unsigned long MAX = 1000000000000000000;
signed main()
{   
  gearup;
  int n; cin >> n;
  vl a(n);
  bool is_ze = false;
  rep(i,n){
    cin >> a[i];
    if(a[i] == 0)is_ze = true;
  }
  if(is_ze){
    out(0);
    return 0;
  }
  ll now = a[0];
  ll ma = a[0];
  rep1(i,n){
    now *= a[i];
    ma = max(now,ma);
    if(ma > now || now > MAX){
      out(-1);
      return 0;
    }
  }
  out(now);
}

Measured memory_bytes: 4000
#include <bits/stdc++.h>
using namespace std;

#define int long long

struct edge{
  int u, v, cost;
  bool operator < (edge const &other){
	   return cost < other.cost;  
	}	
};

const int N = 1e4 + 11;
int p[N], sz[N];
vector<edge> ret, edge_list;
int weight = 0;

int get(int x){
  if (p[x] == x) return x;
  return p[x] = get(p[x]);	
}

void unite(int x, int y){
  x = get(x), y = get(y);
  if (sz[x] < sz[y]) swap(x, y);
  sz[x] += sz[y];
  p[y] = x;	
}

void KruskalMST(vector<edge> &edge_list){
  	sort(edge_list.begin(), edge_list.end());
  	for(auto it : edge_list){
		if (get(it.u) != get(it.v)){
		   weight += it.cost;
		   ret.push_back(it);
		   unite(it.u, it.v);	
		}
	}
}

int32_t main(){
	int n, m;
	cin >> n >> m;
	for(int i = 0; i < n; i++){
	  p[i] = i;
	  sz[i] = 0;	
	}
	vector<edge> g;
	for(int i = 0; i < m; i++){
	  int x, y, val;
	  cin >> x >> y >> val;
	  g.push_back({x, y, val});	
	}
   KruskalMST(g);
   cout << weight << endl;
}




Measured memory_bytes: 6184
// Vicfred
// https://atcoder.jp/contests/abc156/tasks/abc156_d
// math
import std.stdio;

long binpow(long a, long b, long m) {
    a %= m;
    long res = 1L;
    while(b > 0L) {
        if(b&1)
            res = res * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return res;
}

long binomial(long n, long k, long m) {
    long x, y;
    x = y = 1;
    for(int i = 0; i < k; i++) {
        x *= n-i;
        x %= m;
        y *= i+1;
        y %= m;
    }
    y = binpow(y, m-2, m);
    return (x*y)%m;
}

void main() {
    long mod = 10^^9+7;
    long n, a, b;
    readf("%s %s %s\n", &n, &a, &b);
    writeln((binpow(2L,n,mod) - binomial(n,a,mod) - binomial(n,b,mod) - 1L + 3L*mod)%mod);
}



Measured memory_bytes: 256
#include <iostream>
#include <stack>
#include <vector>
using namespace std;

void printAreas(vector< int > areas) {
  int sum = 0;
  for (int j = 0; j < areas.size(); j++)
    sum += areas[j];
  cout << sum << endl;
  if (areas.size())
    cout << areas.size() << ' ';
  else
    cout << 0 << endl;
  for (int j = 0; j < areas.size(); j++) {
    cout << areas[j];
    if (j == areas.size()-1)
      cout << endl;
    else
      cout << ' ';
  }
}

// void printLakeLeftWalls(vector< int > lakeLeftWalls) {
//   for (int i = 0; i < lakeLeftWalls.size(); i++) {
//     cout << lakeLeftWalls[i] << ' ';
//   }
//   cout << endl;
// }

int main(int argc, char **argv) {
  ios_base::sync_with_stdio(false);
  char current;
  int i = 0;
  vector < int > areas;
  stack < int > leftWalls;
  vector < int > lakeLeftWalls;
  while (true) {
    current = cin.get();
    if (current == '\\') {
      leftWalls.push(i);
    } else if (current == '/') {
      if (leftWalls.size()) {
  	if (!areas.size()) {
  	  areas.push_back(i-leftWalls.top());
  	  lakeLeftWalls.push_back(leftWalls.top());
  	  leftWalls.pop();
  	} else if (leftWalls.top() > lakeLeftWalls.back()) {
  	  areas.push_back(i-leftWalls.top());
  	  lakeLeftWalls.push_back(leftWalls.top());
  	  leftWalls.pop();
  	} else {
	  int j = areas.size()-1;
	  while ((j > 0) && (leftWalls.top() < lakeLeftWalls[j-1])) {
	    areas[j-1] += areas[j];
	    lakeLeftWalls.pop_back();
	    areas.pop_back();
	    j--;
	  }
	  areas[areas.size()-1] += i-leftWalls.top();
	  lakeLeftWalls[lakeLeftWalls.size()-1] = leftWalls.top();
	  leftWalls.pop();
	}
      }
    } else if (current != '_')
      break;
    i++;
  }
  printAreas(areas);
  return 0;
}



Measured memory_bytes: 3284
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
 
#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
 
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
 
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
 
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
 
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
 
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001; //check the limits, dummy
 
int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);    
	
    ll A, B; cin >> A >> B;
    char C; cin >> C;
    int D; cin >> D;
    B *= 100; B += D;
    ll X = A*B; X /= 100;
    cout << X << nl;
	
	return 0;
}
 




Measured memory_bytes: 3656
N,M = map(int,input().split())
dp = [[float("inf")]*(2**N) for i in range(M+1)]
AC = []
ans = 0
for i in range(M):
    ai,bi = map(int,input().split())
    ci = list(map(int,input().split()))
    ci = sum([2**(i-1) for i in ci])
    AC.append([ai,ci])
for i in range(M+1):
    dp[i][0] = 0
for i in range(M):
    for j in range(2**N):
        if dp[i][j] != float("inf"):
            dp[i+1][j|AC[i][1]] = min(dp[i+1][j|AC[i][1]],dp[i][j]+AC[i][0]) 
            dp[i+1][j] = min(dp[i+1][j],dp[i][j])

if dp[M][2**N-1] == float("inf"):
    print(-1)
else:
    print(dp[M][2**N-1])



Measured memory_bytes: 172776
import sys
import math
import collections
from collections import deque
#n = int(input())
#n, k = map(int, sys.stdin.readline().split())
s = input()
#x = list(map(int, sys.stdin.readline().split()))

for i in range(len(s)):
    if i % 2 == 0:
        if s[i] == "L":
            print("No")
            sys.exit()
    else:
        if s[i] == "R":
            print("No")
            sys.exit()

print("Yes")


Measured memory_bytes: 3316
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func solve() {
	a := nextInt()
	b := nextInt()

	if a*b%2 == 1 {
		fmt.Fprintln(out, "Odd")
	} else {
		fmt.Fprintln(out, "Even")
	}

	return
}

func main() {
	in.Split(bufio.ScanWords)

	defer out.Flush()
	solve()
}

// --- template ---

var (
	in  = bufio.NewScanner(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
)

func next() string {
	in.Scan()
	return in.Text()
}

func nextInt() int {
	s := next()
	i, e := strconv.Atoi(s)
	if e != nil {
		fmt.Println(e)
	}
	return i
}


Measured memory_bytes: 640
#include <stdio.h>

int main(){
    int a, b;
    char op;
    while(1){
        scanf("%d %c %d", &a, &op, &b);
        if(op=='?'){
            break;
    	}else if(op=='+'){
    	    printf("%d\n", a+b);
    	}else if(op=='-'){
    	    printf("%d\n", a-b);
    	}else if(op=='*'){
    	    printf("%d\n", a*b);
    	}else if(op=='/'){
    	    printf("%d\n", a/b);
        }
    }
    return 0;
}


Measured memory_bytes: 2704
#include <iostream>
#include <string>
using namespace std;

int main(){
  int sx,sy,tx,ty;
  cin >> sx >> sy >> tx >> ty ;
  int a[5000];
  for (int i = 0 ; i<ty-sy ;i++){
    cout << "U";
  }
  for (int i = 0 ; i<tx-sx ;i++){
    cout << "R";
  }
  for (int i = 0 ; i<ty-sy ;i++){
    cout << "D";
  }
  for (int i = 0 ; i<tx-sx ;i++){
    cout << "L";
  }
  cout << "L";
  for (int i = 0 ; i<= ty-sy ;i++){
    cout << "U";
  }
  for (int i = 0 ; i<=tx-sx ;i++){
    cout << "R";
  }
  cout<< "D";
  cout << "R";
  for (int i = 0 ; i<=ty-sy ;i++){
    cout << "D";
  }
  for (int i = 0 ; i<=tx-sx ;i++){
    cout << "L";
  }
  cout << "U" << endl;
  
}


Measured memory_bytes: 256
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
    ll n,w;
    cin>>n>>w;
    vector<vector<ll> > v(n+1,vector<ll>(2));
    for(int i=1;i<=n;i++)
    {
        cin>>v[i][0]>>v[i][1];
    }
    vector<vector<ll> > v1(n+1,vector<ll>(w+1));
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=w;j++)
        {
            if(i==0||j==0)
                v1[i][j]=0;
                else if(v[i][0]<=j)
            {
                v1[i][j]=max(v[i][1]+v1[i-1][j-v[i][0]],v1[i-1][j]);
            }
            else
            {
                v1[i][j]=v1[i-1][j];
            }
        }
    }
    cout<<v1[n][w]<<endl;
    return 0;
}


Measured memory_bytes: 83160
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
	ll a,b,c; cin>>a>>b>>c;
	double d=(double)a/c;
	if(d<=b)
	{
		cout<<"Yes\n";
	}
	else
	{
		cout<<"No\n";
	}
}
	

Measured memory_bytes: 3628
#include <bits/stdc++.h>
#include <queue>
using namespace std;

bool find(vector<int> P, int i, int siP){
  for(int j = 0; j < siP; j++){
    if( P[j] == i )
      return true;
  }
  return false;
}
  

int main() {
  int X, N;
  cin >> X >> N;
  if(N == 0){
    cout << X << endl;
  }
  
  else if(N == 100){
    if(X <= 50){
      cout << 0 << endl;;
    }
    else{
      cout << 101 << endl;
    }
  }
  
  else{
    vector<int> P(N);
    for(int i = 0; i < N; i++)
    cin >> P.at(i);
  
    queue<int> Q;
    int siP = P.size();
    for(int i = 0; i <= 101; i++){
      bool ar = find(P, i, siP);
      if(ar == false){
        Q.push(i);
      }
    }
    
    int siQ = Q.size();
    
    int r = 0;
    int dif = X;
    int temp_r = r;
    int temp_dif = dif;
  
    for(int i = 0; i < siQ; i++){
      temp_r = Q.front();
      temp_dif = abs(temp_r - X);
      if (temp_dif < dif){
        dif = temp_dif;
        r = temp_r;
      }
      Q.pop();
    }
    
    cout << r << endl;
    
  }
  
  
}



Measured memory_bytes: 3640
#include <bits/stdc++.h>
using namespace std;

const int N = (int) 2e5 + 1;
int pos[N];
int a[N];

int main() {
    ios::sync_with_stdio(false);
    int n; cin >> n;
    for (int i = 0; i < n; ++i) cin >> a[i], pos[a[i]] = i;
    set<pair<int, int> > ints;
    ints.emplace(0, n);
    long long res = 0;
    for (int i = 1; i <= n; ++i) {
        auto x = --ints.upper_bound(make_pair(pos[i], N));
        res += 1LL * i * (pos[i] - x->first + 1) * (x->second - pos[i]);
        if (x->first != pos[i]) ints.emplace(x->first, pos[i]);
        if (pos[i] + 1 != x->second) ints.emplace(pos[i] + 1, x->second);
        ints.erase(x);
    }
    cout << res << endl;
    return 0;
}


Measured memory_bytes: 4224
fn main() {
    proconio::input! {
        n: usize,
        a: [u64;n],
    }
    let mut m=1000;
    let mut t=0;
    for i in 0..n {
        if i==n-1 || a[i]>a[i+1] {
            m+=t*a[i];
            t=0;
        }
        if i!=n-1 && a[i]<a[i+1] {
            t+=m/a[i];
            m-=m/a[i]*a[i];
        }
    }
    println!("{}",m);
}

Measured memory_bytes: 2160
#include "bits/stdc++.h"
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define mFOR(i, a, b) for (int i = a; i > b; i--)
#define MP make_pair
#define PB push_back
#define ALL(v) v.begin(), v.end()
#define N 100007
#define INF 1000000007
using namespace std;

typedef long long ll;

ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll fceil(ll a, ll b) { return (a % b == 0 ? a / b : a / b + 1); }
int main()
{
   ll n, k, q, a;
   cin >> n >> k >> q;
   ll point[n] = {};
   FOR(i, 0, q)
   {
      cin >> a;
      point[a-1]++;
   }
   FOR(i, 0, n)
   {
      if (point[i] > q - k)
         cout << "Yes" << endl;
      else
         cout << "No" << endl;
   }
   return 0;
}


Measured memory_bytes: 1408
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int main(){
	double r,a,b;
	cin >> r;
	a=r*r*M_PI;
	b=2*r*M_PI;
	printf("%.5f ",a);
	printf("%.5f\n",b);
	return 0;
}

Measured memory_bytes: 3192
#include <bits/stdc++.h>
using namespace std;
 
int main() {
    char b; 
    cin >> b;
    if(b == 'A'){
        cout << 'T' << endl;
    }
    else if(b == 'T'){
        cout << 'A' << endl;
    }
    else if(b == 'G'){
        cout << 'C' << endl;
    }
    else{
        cout << 'G' << endl;
    }
}

Measured memory_bytes: 256
#include<bits/stdc++.h>
#include<bitset>

using namespace std;

#define M 1000000007
#define pb push_back
#define f first
#define s second
#define rep(i, st, ed) for(int i=st; i<ed; i++)
#define repn(i, st, ed) for(int i=st; i<=ed; i++)
#define repb(i, ed, st) for(int i=ed; i>=st; i--)

typedef long long ll;
typedef unsigned long long int llt;
typedef long double ld;

const long double PI  =3.141592653589793238463;
const int N = 5e5 + 10;

vector<int> g[N];
bool viss[N];
int vis[N];

// Normal DFS
void dfs(int curr, int par)
{
  for(auto x: g[curr])
    if(x != par)
      dfs(x, curr);
}

// DFS with visiting status
void dfs1(int curr, int par)
{
  viss[curr] = 1;
  for(auto x: g[curr])
    if(!viss[x])
      dfs1(x, curr);
}

// DFS with strongly connected component
void dfs2(int curr, int par, int num)
{
  vis[curr] = num;
  for(auto x: g[curr])
    if(vis[x] == 0)
      dfs2(x, curr, num);
}

// XOR from 0 to n
ll fxor(ll n)
{
  if(n < 0) return 0;
  if(n % 4 == 3) return 0;
  else if(n % 4 == 0) return n;
  else if(n % 4 == 1) return n^(n-1);
  else if(n%4 == 2) return n^(n-1)^(n-2);
}

// Power in logn with mod 1000000007
llt ppow(llt x, llt y)
{
  llt res = 1;
  while(y > 0){
    if(y&1)
      res = (res * x)%M;
    y = y >> 1;
    x = (x * x)%M;
  }
  return res;
}

// Factorial with dp
llt factdp[N];
llt fact(llt x)
{
  if(x == 0) return 1;
  if(x == 1) return 1;
  if(factdp[x] != -1) return factdp[x];
  return factdp[x] = (x*fact(x-1))%M;
}

// String return to base b
string ansConv ="";
void convert10tob(llt N, int b)
{
     if (N == 0)
        return;
     int x = N % b;
     N /= b;
     if (x < 0)
        N += 1;
     convert10tob(N, b);
     ansConv += to_string(x);
     return;
}

// Convert string to num wiht base b
llt convertstrtob(string a, int b)
{
  llt aa = 0;
  llt mul = 1;
  for(int i=a.length()-1; i>=0; i--)
  {
    int curr = a[i] - '0';
    aa += (curr * mul);
    mul *= b;
  }
  return aa;
}

// Union Find algo with array
// Find()
int findpar(int curr, int arr[])
{
  while(arr[curr] != curr) curr = arr[curr];
  return curr;
}
// Union()
void Union(int b, int spa, int arr[])
{
  while(arr[b] != b)
  {
    int c = arr[b];
    arr[b] = spa;
    b = c;
  }
  arr[b] = spa;
}

// Main Code

int main()
{
  string s;
  rep(i, 0, 3)
  {
    cin>>s;
    char x = s[0] - 'a' + 'A';
    cout<<x;
  }
  cout<<endl;
  return 0;
}


Measured memory_bytes: 12160
/*
Keep clam  Believe youself
*/
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#include<stack>
#include<set>
#include<cmath>
#define Xiaobo main
#define DEBUG(x) cerr<<#x<<": "<<(x)<<endl
using namespace std;
const int maxn=2e5+7;
const int mod=1e9+7;
const double eps=1e-15;
const double pi=acos(-1);
const int INF=0x3f3f3f3f;
typedef long long ll;
ll read(){ll c = getchar(),Nig = 1,x = 0;while(!isdigit(c) && c!='-')c = getchar();if(c == '-')Nig = -1,c = getchar();while(isdigit(c))x = ((x<<1) + (x<<3)) + (c^'0'),c = getchar();return Nig*x;}
ll gcd(ll a,ll b){ return b==0?a:gcd(b,a%b);}
//别急 dp找状态 问题看看本身的规律 贪心找方法
int Xiaobo()
{
	string s;
	cin>>s;
	int f1=0,f2=0;
	for(int i=0;i<(int)s.size();i++) {
		if(s[i]=='A') f1++;
		if(s[i]=='B') f2++;
	}
	if(f1&&f2) puts("Yes");
	else puts("No");
}

Measured memory_bytes: 256
import java.util.*;

public class Main {

	public static boolean dis(int x[], int y[], int d){
		long ans = 0;
		for(int i = 0; i < d; ++i){
			int tmpx = x[i];
			int tmpy = y[i];
			ans += (tmpx - tmpy) * (tmpx - tmpy);
		}
		double ansd = Math.sqrt((double)ans);
		return (ansd == Math.floor(ansd));
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), d = sc.nextInt();
		int x[][] = new int[n][d];
		for (int i = 0; i < n; ++i)
			for (int j = 0; j < d; ++j)
				x[i][j] = sc.nextInt();
		sc.close();
		int ans = 0;
		for(int i = 0; i < n;++i){
			for(int j = i + 1; j < n; ++j){
				if(dis(x[i], x[j], d))++ans;
			}
		}

		System.out.println(ans);
	}
}


Measured memory_bytes: 22612
#include <stdio.h>

int abs(int x){
  if(x > 0) return x;
  else return -x;
}

int main(){
  int n;
  scanf("%d\n",&n);
  int w[n];
  for(int i = 0; i < n; ++i) scanf("%d",&w[i]);
  int s1 = w[0], s2 = 0;
  for(int i = 1; i < n; ++i) s2 += w[i];
  int answer = abs(s2-s1);
  for(int i = 1; i < n; ++i){
    s1 += w[i];
    s2 -= w[i];
    if(answer > abs(s2-s1)) answer = abs(s2-s1);
  }
  printf("%d",answer);
  return 0;
}

Measured memory_bytes: 128
#include <bits/stdc++.h>
using namespace std;
int main(void){
    
    int n, k, c=0;
    cin >> n >> k;
    int h[n];
    for (int i=0;i<n;i++) cin >> h[i];
    
    for(int i=0;i<n;i++){
        if(k <= h[i]) c++;
    }
    
    cout << c << endl;
    
    return 0;
}


Measured memory_bytes: 640
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep1(i,n) for(ll i=1;i<=n;i++)
#define all(n) n.begin(),n.end()
#define yn(x) cout << (x ? "Yes":"No") << endl;

int main() {
  ll n;
  cin >> n;
  vector<ll>a(n),b(n+1);
  rep(i,n){
    cin >> a[i];
    b[ a[i] ] = i+1;
  }
  rep1(i,n) cout << b[i] << " ";
  cout << endl;
  return 0;
}


Measured memory_bytes: 2432
#include<stdio.h>

int main(void)
{
	int H;
	int W;
	int i;
	int j;
	
	while(1){
		scanf("%d %d", &H, &W);
		if(H == 0 && W == 0){
			break;
		}
		
		for(i = 1;i <= H;i++){
			for(j = 1;j <= W;j++){
				if((i%2 != 0 && j%2 != 0) || (i%2 == 0 && j%2 == 0)){
					printf("#");
				}
				else {
					printf(".");
				}
			}
			printf("\n");
		}
		printf("\n");
	}
	
	return (0);
}

Measured memory_bytes: 572
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
count = 0
ans = -1

K = i()
N = "7"
s = 10
if K == 7 or K == 1:
    print(1)
    exit()
if K % 2 == 0:
    print(-1)
    exit()
mod = 7 % K

for i in range(10**8):
    if mod == 0:
        print(i+1)
        exit()
    else:
        mod *= 10
        mod += 7
        mod %= K
print(-1)

Measured memory_bytes: 63392
import java.util.Scanner;

public class Main {

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

		int a, b, ans = 0;
		a = sc.nextInt();

		for (int i = 1; i < N; i++) {
			b = sc.nextInt();
			if (a == b) {
				ans++;
				a = -1;
			} else {
				a = b;
			}
		}

		System.out.println(ans);
		sc.close();
	}

}


Measured memory_bytes: 21844
//Binary Search Tree III
#include <iostream>

using namespace std;

struct Node {
    int key;
    Node *parent = nullptr, *left = nullptr, *right = nullptr;
    explicit Node(int key) : key(key){}
};

class Tree {
public:
    void insert(int key);
    Node * find(int key);
    void deleteNode(int key);
    Node * getMinimum(Node *x);
    Node *root = nullptr;
};

void Tree::insert(int key) {
    Node *x = root;
    Node *y = nullptr;
    auto *n = new Node(key);
    while(x != nullptr) {
        y = x;
        if(key < x -> key) x = x -> left;
        else x = x -> right;
    }
    if(y == nullptr) {
        root = n;
    }
    else {
        n -> parent = y;
        if(key < y -> key) y -> left = n;
        else y -> right = n;
    }
}

Node * Tree::find(int key) {
    Node *x = root;
    while(x != nullptr) {
        if(x -> key == key) break;
        else if(key < x -> key) x = x -> left;
        else x = x -> right;
    }
    return x;
}

void Tree::deleteNode(int key) {
    Node *x = find(key), *y, *z;

    if(x -> left == nullptr || x -> right == nullptr) y = x;
    else {
        y = getMinimum(x -> right);
        x -> key = y -> key;
    }

    if(y -> left != nullptr) z = y -> left;
    else z = y -> right;

    if(z != nullptr) z -> parent = y -> parent;

    if(y -> parent == nullptr) root = z;
    else if(y == y -> parent -> left) y -> parent -> left = z;
    else y -> parent -> right = z;

    delete y;
}

Node * Tree::getMinimum(Node *x) {
    while(x -> left != nullptr) x = x -> left;
    return x;
}

void inOrder(Node *N) {
    if(N == nullptr) return;
    inOrder(N -> left);
    cout << " " << (N -> key);
    inOrder(N -> right);
}

void preOrder(Node *N) {
    if(N == nullptr) return;
    cout << " " << (N -> key);
    preOrder(N -> left);
    preOrder(N -> right);
}


int main() {
    Tree T;

    int n;
    cin >> n;
    for(int i = 0; i < n; i++) {
        string opr;
        int key;
        cin >> opr;
        if(opr == "insert") {
            cin >> key;
            T.insert(key);
        }
        if(opr == "find") {
            cin >> key;
            if(T.find(key) != nullptr) cout << "yes" << endl;
            else cout << "no" << endl;
        }
        if(opr == "delete") {
            cin >> key;
            T.deleteNode(key);
        }
        if(opr == "print") {
            inOrder(T.root);
            cout << endl;
            preOrder(T.root);
            cout << endl;
        }
    }
}


Measured memory_bytes: 21812
#include <iostream>
#include <algorithm>
using namespace std;

int getPoint() {
	int frames[12][2];
	for (int i = 0; i < 10; i++) {
		cin >> frames[i][0];
		if (frames[i][0] == 10) {
			frames[i][1] = 0;
		}
		else {
			cin >> frames[i][1];
		}
	}
	frames[11][0] = frames[11][1] = 0;
	if (frames[9][0] == 10) {
		cin >> frames[10][0];
		if (frames[10][0] == 10) {
			frames[10][1] = 0;
			cin >> frames[11][0];
		}
		else {
			cin >> frames[10][1];
		}
	}
	else if (frames[9][0] + frames[9][1] == 10) {
		cin >> frames[10][0];
		frames[10][1] = 0;
	}
	
	int result = 0;
	for (int i = 0; i < 10; i++) {
		result += frames[i][0] + frames[i][1];
		if (frames[i][0] + frames[i][1] == 10) {
			result += frames[i + 1][0];
			if (frames[i][0] == 10) {
				if (frames[i + 1][0] == 10) {
					result += frames[i + 2][0];
				}
				else {
					result += frames[i + 1][1];
				}
			}
		}
	}
	return result;
}

int main () {
	int m;
	while (cin >> m, m) {
		pair<int, int> results[m];
		for (int i = 0; i < m; i++) {
			cin >> results[i].second;
			results[i].first = -getPoint();
		}
		sort(results, results + m);
		for (int i = 0; i < m; i++) {
			cout << results[i].second << ' ' << -results[i].first << endl;
		}
	}
	return 0;
}

Measured memory_bytes: 1164
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        if(b < a) {
            int t = b;
            b = a;
            a = t;
        }
        for (int i = 0; i < b; i++) {
            System.out.print(a);
        }
        sc.close();

    }

}


Measured memory_bytes: 21844
#include<bits/stdc++.h>
using namespace std;
int main() {
    string s;
    unsigned long long p = 0;
    cin >> s;
    unsigned long long len = s.size();
    while (true) {
        if (p + 7 <= len) {
            string kmp = s.substr(p,  7);
            if (kmp == "dreamer") {
                if(p+10<=len) {
                    kmp = s.substr(p + 5, 5);
                    if (kmp != "erase") {
                        p += 7;
                        continue;
                    }
                }
                else
                {
                    p+=7;
                    continue;
                }
            }
        }
        if (p + 6 <= len) {
            string rmp = s.substr(p,  6);
            if (rmp == "eraser") {
                p += 6;
                continue;
            }
        }
        if (p + 5 > len)break;
        string tmp = s.substr(p,  5);
        if (tmp == "dream" || tmp == "erase") {
            p += 5;
            continue;
        }
        break;
    }
    if (p == len)cout << "YES" << endl;
    else cout << "NO" << endl;
    return 0;
}

Measured memory_bytes: 764
import java.util.*;
public class Main{
	public static void main(String[] args){
    	Scanner sc = new Scanner(System.in);
      	int a = sc.nextInt();
		int b = sc.nextInt();
      	System.out.println(Math.max(a*b,Math.max(a+b, a-b)));
      	
    }
}

Measured memory_bytes: 35612
#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    pair<int,int>p[n];
    for(int i=0;i<n;i++){
        cin>>p[i].first;
        p[i].second = i+1;
    }
    sort(p,p+n);
    for(int i=0;i<n;i++)cout<<p[i].second<<" ";
    cout<<endl;
    return 0;
}


Measured memory_bytes: 4260
import java.util.*;

class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int M = sc.nextInt();
		int[] a = new int[2*M];
		for(int i = 0; i < 2*M; i++){
			a[i] = sc.nextInt();
		}

		int[] town = new int[N];
		for(int i = 0; i < N; i++){
			town[i] = 0;
		}
		int index = 0;
		for(int i = 0; i < 2*M; i++){
			index = a[i] - 1;
			town[index]++;
			
		}

		for(int i = 0; i < N; i++){
			System.out.println(town[i]);
		}
	}
}

Measured memory_bytes: 21844
#include <iostream>
#include <cmath>
using namespace std;

int hoge(int s, int n) {
    int w = pow(2,n);

    if (n == -1)
        return 0;

    if (w == s) {
        cout << w;
        return 1;
    }

    if (w < s && hoge(s-w, n-1)) {
        cout << " " << w;
        return 1;
    }

    if (hoge(s, n-1)) {
        return 1;
    }

    return 0;
}

int main(void) {
    int s;
    while (cin >> s) {
        hoge(s, 9);
        cout << endl;
    }
    return 0;
}



Measured memory_bytes: 3256
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
typedef long long  ll;
//typedef tree<ld,null_type,less<ld>,rb_tree_tag,tree_order_statistics_node_update> indexed_set
// this for long double
#define press_F_to_pay_respect ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define forn for(int i=0;i<n;i++) 
#define form for(int j=0;j<n;j++) 
#define fore(i,a,b) for(int i = a; i < (b); i++)
#define pb push_back 
#define pob pop_back()
#define mp make_pair 
#define sc second 
#define f first 
#define ld long double
#define kek cout<<endl; 
#define rep(i,a,b) for(int i=a;i<b;i++)
#define all(v) ((v).begin()), ((v).end()) 
#define pob pop_back() 
#define halt {cout<<-1; return 0;}
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const int N = 1010;
const int INF = 1e8;
const ll MOD1=1073741824;
const long double pi=3.1415926535;
using namespace std;
using namespace __gnu_pbds;
typedef tree<ld,null_type,less<ld>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
string bin_rep(int n)
{
          string s="";
      for(int i=31;i>=0;i--)
   {
           if(n&(1<<i)) s+='1';
           else s+='0';
   }
   return s;
}
int main()
{
#if defined(_DEBUG)
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
 press_F_to_pay_respect;
 // cout << fixed << setprecision(12) << ans;
 // string al = "abcdefghijklmnopqrstuvwxyz";
 string s;
 cin>>s;
 if(s=="ARC") cout<<"ABC";
 else cout<<"ARC";
 
 
 
 
 
    
 
 
 
  // cout <<"Runtime is:"<<clock() * 1.0 / CLOCKS_PER_SEC <<endl;
   return 0;
   
   
 
}

Measured memory_bytes: 3636
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T>bool even(T n) { return ! (n & 1); }
template<class T>bool odd(T n) { return n & 1; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
ll intpow(ll a,ll n){ll p=1;while(n){if(n&1)p*=a;a*=a;n>>=1;}return p;}
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;



int main()
{
        string S;
        cin >> S;

        ll N = len(S);

        vllvll dp(N+10, vll(13));

        dp[0][0] = 1;
        rep(i, 0, N) {
                rep(j, 0, 13) {
                        if (S[i] == '?') {
                                rep(cand, 0, 10) {
                                        dp[i+1][(10 * j + cand) % 13] = (dp[i+1][(10 * j + cand) % 13] + dp[i][j]) % mod;
                                }
                        } else {
                                ll num = S[i] - '0';
                                dp[i+1][(10 * j + num) % 13] = (dp[i+1][(10 * j + num) % 13] + dp[i][j]) % mod;
                        }
                }
        }

        cout << dp[N][5] << endl;
}

Measured memory_bytes: 16700
#include<iostream>
#include<stack>
#include<cstdio>
#include<stdlib.h>
#include<string>
using namespace std;
stack<int> st;
int main(){
	string a;
	int e1,e2;
	while(cin>>a){
		if(a[0]=='+'){
			e1=st.top();st.pop();
			e2=st.top();st.pop();
			st.push(e1+e2);
		}
		else if(a[0]=='-'){
			e1=st.top();st.pop();
			e2=st.top();st.pop();
			st.push(e2-e1);
		}
		else if(a[0]=='*'){
			e1=st.top();st.pop();
			e2=st.top();st.pop();
			st.push(e1*e2);
		}
		else{
			st.push(atoi(a.c_str())); //string转为char*使用c_str ;char*直接赋值给string 
		}
	}
	cout<<st.top()<<endl;
}


Measured memory_bytes: 3204
#include <stdio.h>
#include <string.h>
int main(){
    int a,b,i,j,len,k=0;
    char s[1000000],c[1000000];
    scanf("%s %s",s,c);
    len=strlen(s);
    for(i=0;i<len;i++)
    {
        if(s[i]!=c[i]){
            k++;
        }

    }
    printf("%d\n",k);
    return 0;
}

Measured memory_bytes: 2068
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
	int n,m;
	string s;
	
	cin>>n>>s;
	if(n>=3200){
		cout<<s<<endl;
	}else{
		cout<<"red"<<endl;
	}
    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
 
int main() {
  cout << setprecision(15);
  ll a, b, c; 
  cin >> a >> b >> c;
  int mod = a%b;
  for (int i = 1; i <= b; ++i) {
    if (mod == c) {
      cout << "YES" << endl;
      return 0;
    }
    mod = (mod+a)%b;
  }
  cout << "NO" << endl;
  return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define fir first
#define sec second
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, double> pid;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-8;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
inline ull qpow(ull a, ull b)
{
    ull ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a;
        a = a * a;
        b >>= 1;
    }
    return ans;
}
vector<int> a(200005);
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int x;
    for (int i = 1; i < n; i++)
    {
        cin >> x;
        a[x]++;
    }
    for (int i = 1; i <= n; i++)
    {
        cout << a[i] << '\n';
    }
}


Measured memory_bytes: 3904
#define _GLIBCXX_DEBUG
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<string>
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define rep2(i,s,n) for(int i=s;i< (int)n; i++)
#define ll long long 
#define all(v) v.begin(),v.end()
using namespace std;
int main(){
  int n,m; cin >>n>>m;
  vector<int> a(m),b(m);
  rep(i,m) cin >>a[i]>>b[i];
  vector<vector<int>> c(n);
  rep(i,m) c[a[i]-1].push_back(b[i]);
  if(n>1&&c[0].size()==0) c[0].push_back(1);
  if(n==1&&c[0].size()==0) c[0].push_back(0);
  if (n>1) rep2(i,1,n) if(c[i].size()==0) c[i].push_back(0);
  int key=0;
  rep(i,n) rep(j,c[i].size()) if(c[i][j]!=c[i][0]) key=1;
  if(key==1||(n>1&&c[0][0]==0)) cout <<-1<<endl;
  else if(n==3) cout<<100*c[0][0]+10*c[1][0]+c[2][0]<<endl;
  else if(n==2) cout<<10*c[0][0]+c[1][0]<<endl;
  else cout <<c[0][0]<<endl;
}

Measured memory_bytes: 256
def five(x):
    cnt1 = 0
    while x%5==0:
        cnt1+= 1
        x = x//5
    cnt2 = 0
    while x%2==0:
        cnt2+= 1
        x = x//2
    return (min2(cnt1,18), min2(cnt2,18))

def min2(x,y):
    return x if x < y else y

import sys
input = sys.stdin.readline

N = int(input())
F = []
for i in range(N):
    A = input().rstrip()
    if '.' in A:
        a,b = A.split('.')
        n = int(a+b)*10**(9-len(b))
    else:
        n = int(A) * 10 ** 9
    F.append(five(n))

F.sort()
j = 0
temp = 0
dp = [0]*19
k = 0
for i in range(N-1):
    if N-1-j < i:
        dp[min2(F[i][1], 18)] -= 1
    while N-1-j> i and F[i][0]+F[N-1-j][0] >= 18:
        dp[min2(F[N-1-j][1],18)] += 1
        j += 1
    k = sum(dp[:18-F[i][1]])
    temp += min2(j, N-i-1) - k

print(temp)


Measured memory_bytes: 87244