akhauriyash/Code-Regression huggingface dataset:
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
// #define int long long
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000               // 2e9
#define LLINF 2000000000000000000ll  // 2e18 (llmax:9e18)
#define fi first
#define sec second
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define dmp(x) cerr << #x << ": " << x << endl;

template <class T>
void chmin(T &a, const T &b) {
  if (a > b) a = b;
}
template <class T>
void chmax(T &a, const T &b) {
  if (a < b) a = b;
}

template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
vector<T> vect(int len, T elem) {
  return vector<T>(len, elem);
}

template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << p.fi << ',' << p.sec;
  return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.fi >> p.sec;
  return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
  for (int i = 0; i < vec.size(); i++) {
    os << vec[i];
    if (i + 1 < vec.size()) os << ' ';
  }
  return os;
}
template <class T>
istream &operator>>(istream &is, vector<T> &vec) {
  for (int i = 0; i < vec.size(); i++) is >> vec[i];
  return is;
}
void fastio() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(20);
}

#define endl "\n"

void solve() {
  string s;
  cin >> s;
  for(int i=0;i<s.size();i++){
    for(int j=i+1;j<s.size();j++){
      if(s[i]=='C'&&s[j]=='F'){
        cout << "Yes" << endl;
        return;
      }
    }
  }
  cout << "No" << endl;
  return;
}

signed main() {
  fastio();
  solve();
  // int t; cin >> t; while(t--)solve();
  return 0;
}


Measured memory_bytes: 256
// Copyright [2020] <unknown>
#include <bits/stdc++.h>
using namespace std;
// #define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
#define dbg(x...) { cerr << "\033[32;1m" << #x << " -> "; err(x); }
void err() { cerr << "\033[39;0m" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cerr << a << ' '; err(x...); }
#else
#define dbg(...)
#endif

#define sz(x) ((int)x.size())

typedef long long LL;


int main(int argc, char const *argv[]) {
    // code
    LL n, k;
    cin >> n >> k;
    n %= k;
    printf("%lld\n", min(n, k-n));
    return 0;
}


Measured memory_bytes: 256
import java.util.*;

public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int a,b=0;
		
		a=sc.nextInt();
		b=sc.nextInt();
		
		if(b%a==0)System.out.println(a+b);
		else System.out.println(b-a);
		
	}

}


Measured memory_bytes: 24020
N, K = gets.split.map &:to_i
P = gets.split.map &:to_i

cusum = [sum = 0] + P.map{|n| sum += n }

p (0..N-K).map{|l|
  r = l + K
  (cusum[r] - cusum[l] + K) / 2.0
}.max

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

int main() {
  string S; cin >> S;
  long long ans = 0;
  for (int b = 0; b < 1 << S.size() - 1; b++) {
    string s;
    int start = 0, S_len = S.size();
    for (int i = 0; i < S.size() - 1; i++) {
      if (b & 1 << i) {
        S_len = i - start + 1;
        ans += stoll(S.substr(start, S_len));
        start += S_len, S_len = 1;
      }
    }
    ans += stoll(S.substr(start, S.size() - start));
  }
  cout << ans << endl;
  return 0;
}

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

using namespace std;

using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using P = pair<ll, ll>;
template<typename T> using pq = priority_queue<T>;
template<typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template<typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);

#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = ll(n - 1); i >= 0; i--)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()

template<class T>
ostream &operator<<(ostream &out, const vector<T> &list) {
    ll n = list.size();
    rep(i, n) out << list[i] << ' ';
    return out;
}

template<class T>
istream &operator>>(istream &in, vector<T> &list) {
    ll n = list.size();
    rep(i, n) in >> list[i];
    return in;
}

template<class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &list) {
    ll n = list.size();
    rep(i, n) out << list[i] << '\n';
    return out;
}

/* ------------- ANSWER ------------- */
/* ---------------------------------- */

void solve() {
    ll x, y;
    cin >> x >> y;
    rep(i, x + 1) {
        ll kame = i;
        ll tsuru = x - i;
        if (i * 4 + (x - i) * 2 == y) {
            cout << "Yes" << '\n';
            return;
        }
    }
    cout << "No" << '\n';
}

int main() {
#ifdef MY_DEBUG
    while (true) {
#endif
        solve();
#ifdef MY_DEBUG
    }
#endif
    return 0;
}


Measured memory_bytes: 3632
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)

template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}

template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;

// -------------------------------------------------------
int N;
bool is_prime[101010];
bool is_1_mod5[101010];

int main() {
  cin >> N;
  rep(i, 0, 100000) { is_prime[i] = true; }
  rep(i, 2, 60000) {
    if (i % 5 == 1) is_1_mod5[i] = true;
    if (!is_prime[i]) continue;

    for (int j = 2 * i; j <= 60000; j += i) {
      is_prime[j] = false;
    }
  }

  int cnt = 0;
  rep(i, 2, 60000) {
    if (cnt == N) return 0;

    if (is_prime[i] && is_1_mod5[i]) {
      if (cnt != 0) cout << " ";

      cout << i;
      cnt++;
    }
  }
}


Measured memory_bytes: 384
package main

import (
  "fmt"
)

var n,x,y,ans int

func main() {
  fmt.Scan(&n)
  fmt.Scan(&x)
  fmt.Scan(&y)
  x--
  y--

  res := make([]int, n)

  for i:=0; i<n; i++ {
    cost := make([]int, n)
    for j:=0; j<n; j++ {
      cost[j] = -1
    }
    cost[i] = 0
    var q Queue
    q.push(i)

    for !q.empty() {
      current, _ := q.pop()

      if current-1 >= 0 && cost[current-1] == -1 {
        q.push(current-1)
        cost[current-1] = cost[current]+1
      }
      if current+1 < n && cost[current+1] == -1 {
        q.push(current+1)
        cost[current+1] = cost[current]+1
      }
      if current == x && cost[y] == -1 {
        q.push(y)
        cost[y] = cost[current]+1
      }
      if current == y && cost[x] == -1 {
        q.push(x)
        cost[x] = cost[current]+1
      }
    }
    for _, c := range cost {
      res[c]++
    }
  }

  // print ans
  for r:=1; r<n; r++ {
    fmt.Println(res[r]/2)
  }
}

// Queue ...
type Queue []int

// empty ...
func (q *Queue) empty() bool {
	return len(*q) == 0
}

// push ...
func (q *Queue) push(i int) {
	*q = append(*q, i)
}

// pop ...
func (q *Queue) pop() (int, bool) {
	if q.empty() {
		return 0, false
	} else {
		res := (*q)[0]
		*q = (*q)[1:]
		return res, true
	}
}


Measured memory_bytes: 6656
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

// x ** n % mods を求める
pub fn mod_pow(x: i64, n: i64, mods: i64) -> i64 {
    if n == 0 {
        return 1;
    }
    let mut res = mod_pow(x * x % mods, n / 2, mods);
    if n % 2 == 1 {
        res = res * x % mods;
    }
    return res;
}

// (1/n) % mods を求める
pub fn mod_inv(n: i64, mods: i64) -> i64 {
    return mod_pow(n, mods-2, mods);
}

// nCk % mods を求める
pub fn mod_comb(n: i64, k: i64, mods: i64) -> i64 {
    let sum1 = (n-k+1..n+1).fold(1, |ac, x| ac * x % mods);
    let sum2 = (1..k+1).fold(1, |ac, x| ac * x % mods);
    return sum1 * mod_inv(sum2, mods) % mods;
}


fn main() {
    input!{
        r: f64,
    }
    println!("{}", 2.0 * 3.14159 * r);
}


Measured memory_bytes: 2220
#include<iostream>
#include<sstream>
#include<vector>
#include<algorithm>
#include<string>
#include<stdexcept>
#include<stdio.h>
#include<queue>
#include<stack>
#include <cmath>
#include<bits/stdc++.h>
#include<math.h>
#include<iomanip>
#define cinf(n,x) for(int i=0;i<n;i++) cin >> x[i];
#define pi pair<int,int> 
using namespace std;
using ll = long long;

int main(){
    int h,w; cin >> h >> w;
    char s[h][w];
    for(int i=0;i<h;i++){
         for(int j=0;j<w;j++){
          cin >> s[i][j];
         }
    }
 
    int u[h][w]={},d[h][w]={},r[h][w]={},l[h][w]={};
  
    for(int i=0;i<h;i++){
        r[i][w-1]=0; l[i][0]=0;
        for(int j=1;j<w;j++){
            if(s[i][j] == '#'||s[i][j-1] == '#') l[i][j] = 0;
            else l[i][j] = l[i][j-1] + 1;
        }
        for(int j=w-2;j>=0;j--){
            if(s[i][j] == '#'||s[i][j+1] == '#') r[i][j] = 0;
            else r[i][j] = r[i][j+1] + 1;
        }
    }
    for(int j=0;j<w;j++){
        u[0][j] = 0; d[h][j] = 0;
        for(int i=1;i<h;i++){
            if(s[i][j] == '#'||s[i-1][j] == '#') u[i][j] = 0;
            else u[i][j] = u[i-1][j] + 1;
        }
        for(int i=h-2;i>=0;i--){
            if(s[i][j] == '#'||s[i+1][j] == '#') d[i][j] = 0;
            else d[i][j] = d[i+1][j] + 1;
        }
    }
    int ans = 0;
    for(int i=0;i<h;i++){
        for(int j=0;j<w;j++){
            ans = max(ans, u[i][j] + r[i][j] + l[i][j] + d[i][j] +1 );
        }
    }
    cout << ans;
    return 0;
}

Measured memory_bytes: 66688
n=int(input())
l=list(map(int,input().split()))
print(" ".join(map(str,l)))
for i in  range(1,n):
    v = l[i]
    j = i - 1
    while j >= 0 and l[j] > v:
        l[j+1] = l[j]
        j-=1
    l[j+1] = v
    print(" ".join(map(str,l)))


Measured memory_bytes: 5592
// In the name of God

#include <bits/stdc++.h>

using namespace std;

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	int n, m;
	cin >> n >> m;

	priority_queue<int> pq;

	for(int i = 0; i < n; i++) {
		int x;
		cin >> x;
		pq.push(x);
	}

	long long ans = 0;

	while(m--) {
		int now = pq.top();
		pq.pop();
		pq.push(now / 2);
	}

	while(pq.size()) {
		ans += pq.top();
		pq.pop();
	}

	cout << ans;



	return 0;
}


Measured memory_bytes: 892
// 2020.4.15

#include <iostream>
#include <algorithm>
#include <numeric>
using namespace std;

int main() {
    int K, S;
    int ans = 0;

    cin >> K >> S;

    for (int i = 0; i <= K; i++) {
        for (int j = i; j <= K; j++) {
            for (int k = j; k <= K; k++) {
                if (i + j + k == S) {
                    if (i == j and j == k) {
                        ans += 1;
                    } else if (i == j or j == k) {
                        ans += 3;
                    } else {
                        ans += 6;
                    }                    
                }
            }
        }
    }

    cout << ans << endl;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define int long long
#define INF 1000000000000000
using namespace std;

typedef pair<int, int> Pii;

template<typename T>
void readvec(vector<T> &a);
void readindex(vector<int> &a);



signed main(){

    int N; cin >> N;
    int t = 1, a = 1, T, A;
    REP(i, N){
        cin >> T >> A;
        int it = (t / T) + min(t % T, (int)1);
        int ia = (a / A) + min(a % A, (int)1);
        t = T * max(it, ia);
        a = A * max(it, ia);
    }

    cout << t + a << endl;
    
    return 0;
}


template<typename T>
void readvec(vector<T> &a){
    REP(i, a.size()){
        cin >> a[i];
    }
}
void readindex(vector<int> &a){
    REP(i, a.size()){
        cin >> a[i];
        a[i]--;
    }
}

Measured memory_bytes: 256
#include<iostream>
#include<algorithm>
#include<string>
#include<map>
#include<iomanip>
#include<vector>
#define rep(i,a,b) for(int i=a;i<b;i++)
using namespace std;
using ll = long long;
const int M = 100010;



int main() {
	int ans=0,r,l,rc=0,lc=0,c=0;
	string s;

	cin>>s;
	l=s[0]-'a';
	r=s[s.size()-1]-'a';
	if(s.size()%2){
		if(r==l)cout<<"Second"<<endl;
		else cout<<"First"<<endl;
	}
	else {
		if(r==l)cout<<"First"<<endl;
		else cout<<"Second"<<endl;
	}

}

Measured memory_bytes: 512
#import math
#import numpy as np

N, K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
#for i in range(len(P)): #Pの中身は次の動く先の位置なのでデクリメントする
#    P[i] -= 1

ans = -99999999999999

for i in range(N):
    x = i
    total = 0
    s=[]
    while(1):#サイクルごとに長さをまず求める，
        x = P[x]-1
        s.append(C[x])
        total += C[x]
        if x == i:
            break
    l = len(s)#サイクルの長さ
    t = 0
    for i in range(l):#サイクルの中でどこで終わるのがベストか探す
        t += s[i]
        if i+1> K:#Kがサイクルより短かったらそこで終わる
            break
        now = t
        if total > 0:
            cycle = int((K-i-1)/l)
            now += total*cycle

        ans = max(ans, now)

print(ans)


Measured memory_bytes: 81072
n=int(input())
a=list(input().split())
if n%2==0:  
  b=a[::2]
  a.pop(0)
  c=a[::2]
  c.reverse()
  print(' '.join(c+b))
else:
  b=a[::2]
  a.pop(0)
  c=a[::2]
  b.reverse()
  print(' '.join(b+c))

Measured memory_bytes: 30052
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdlib>
#include <map>
#include <iomanip>
#include <set>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define int long long
#define pie 3.141592653589793238462643383279
#define mod 1000000007
#define INF 1145141919364364
#define all(vec) vec.begin(),vec.end()
#define ggr getchar(); getchar();return 0;
#define ll long long
#define P pair<int,int>
#define S second
#define F first
int gcd(int x, int y) {
	if (y == 0)return x;
	return gcd(y, x%y);
}
int lcm(int x, int y) {
	return x / gcd(x, y)*y;
}
bool prime(int x) {
	for (int i = 2; i <= sqrt(x); i++) {
		if (x%i == 0)return false;
	}
	return true;
}

int kai(int x) {
	if (x == 1)return 1;
	return kai(x - 1)*x%mod;
}

int mod_pow(int x, int y, int moder) {
	int res = 1;
	while (y > 0) {
		if (y & 1)res = res * x%moder;
		x = x * x%moder;
		y >>= 1;
	}
	return res;
}

int comb(int x, int y) {
	if (y > x)return 0;
	if (x == y)return 1;
	return kai(x)* mod_pow(kai(x - y), mod - 2, mod) % mod * mod_pow(kai(y), mod - 2, mod) % mod;
}

int n, m, v[55];
int cnt;
priority_queue<int, vector<int>, greater<int>> que;
int ans;

signed main() {
	cin >> n >> m;
	rep(i, n)cin >> v[i];
	rep(i, min(n, m) + 1) {
		rep(j, min(n, m) + 1 - i) {
			rep(k, i) {
				cnt += v[k];
				if (v[k] < 0)que.push(v[k]);
			}
			for (int k = n - 1; k >= n - j; k--) {
				cnt += v[k];
				if (v[k] < 0)que.push(v[k]);
			}
			rep(k, m - (i + j)) {
				if (que.size()) {
					cnt -= que.top();
					que.pop();
				}
			}
			while(que.size())que.pop();
			ans = max(ans, cnt);
			cnt = 0;
		}
	}
	cout << ans << endl;
}

Measured memory_bytes: 256
#include<iostream>
#include<cmath>
#include<cstdio>

using namespace std;

int main(int argc, char const *argv[])
{
    double data,sum,mean,std;
    int n;

    while(1){
        cin >> n;
        if(n==0) break;
        sum = 0;
        mean = 0;
        for (int i = 0; i < n; ++i)
        {
            cin >> data;
            sum += data*data/n;
            mean += data/n;
        }
        std = sqrt(sum - mean*mean);

        printf("%lf\n", std);

    }
    return 0;
}

Measured memory_bytes: 1240
s;main(c){double*q=&s,b;for(;~scanf("%s%c",&s,&c);c&2&&printf("%f\n",*q))s&4112?*++q=atoi(&s):(b=*q--,*q=s&1?s&2?s&4?*q/b:*q+b:*q-b:*q*b);}

Measured memory_bytes: 0
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
 
int main() {
  int n, m;
  cin >> n >> m;
  vector<P> p(m);
  rep(i,m) cin >> p[i].first >> p[i].second;
  rep(x,1000) {
    int keta = 1;
    int nx = x/10;
    vector<int> d(1,x%10);
    while (nx) {
      keta++;
      d.push_back(nx%10);
      nx /= 10;
    }
    if (keta != n) continue;
    bool ok = true;
    reverse(d.begin(), d.end());
    rep(i,m) {
      if (d[p[i].first-1] != p[i].second) ok = false;
    }
    if (ok) {
      cout << x << endl;
      return 0;
    }
  }
  cout << -1 << endl;
  return 0;
}

Measured memory_bytes: 256
import itertools
import math


def gcd(a: int, b: int, c: int) -> int:
    return math.gcd(math.gcd(a, b), c)


def main() -> None:
    k = int(input())

    one_to_k = range(1, k + 1)
    s1 = sum(one_to_k)
    s2 = sum(math.gcd(a, b) for a, b in itertools.combinations(one_to_k, 2))
    s3 = sum(gcd(a, b, c) for a, b, c in itertools.combinations(one_to_k, 3))
    print(s1 + 6 * s2 + 6 * s3)


if __name__ == "__main__":
    main()


Measured memory_bytes: 9228
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
#define endl '\n'
using namespace std;

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll n, m;
    ll ans = 0;
    cin >> n >> m;
    ans += min(n, m / 2);
    n -= ans;
    m -= ans * 2;
    ans += max((ll)0, m / 4);
    cout << ans << endl;
    return 0;
}

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

using namespace std;

//#define FILE_IO

int N;
vector <int> v;

int main()
{
    #ifdef FILE_IO
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
    #endif

    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
    {
        int x;
        scanf("%d", &x);
        v.push_back(x);
    }
    sort(v.rbegin(), v.rend());

    int ans = N - 1;
    for(int i = 0; i < N; i++)
        if(v[i] <= i)
        {
            ans = i - 1;
            break;
        }

    int l1 = v[ans] - ans;
    int l2 = 1;
    while(v[ans + l2] > ans)
        l2++;

    if(l1 % 2 == 1 && l2 % 2 == 1)
        printf("Second\n");
    else
        printf("First\n");

    return 0;
}


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

const int MN = 200012;

int n, m, k;
int a[MN], b[MN];

int main (void) {
  ios::sync_with_stdio(false);cin.tie(0);
  cin >> n >> m >> k;
  for (int i = 0; i < n; i++)
    cin >> a[i];
  for (int i = 0; i < m; i++)
    cin >> b[i];
  int sum = 0;
  int ans = 0;
  int p = 0;
  for (; p < n; p++) {
    if (sum + a[p] <= k) {
      sum += a[p];
      ans++;
    } else break;
  }
  for (int i = 0; i < m; i++) {
    while (p > 0 and sum + b[i] > k) {
      sum -= a[--p];
    }
    if (sum + b[i] <= k) {
      sum += b[i];
      ans = max(ans, p + i + 1);
    } else break;
  }
  cout << ans << '\n';
  return 0;
}



Measured memory_bytes: 5216
#include<bits/stdc++.h>
#define ll                      long long int
#define pb                      push_back
#define mp                      make_pair
#define in                      insert
#define all(x)                  (x).begin(),(x).end() 
#define rep(i,a,n)              for(int i=0;i<n;++i)
#define per(i,a,n)              for(int i=n-1;i>=0;--i)
#define mod                     1000000007
using namespace std;

int main(int argc, char const *argv[])
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    double l;
    cin>>l;
    double x=(l/3);
    cout<<fixed<<setprecision(12)<<x*x*x<<'\n';
    
    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main()
{
    ll x, y;
    int res = 0;
    cin >> x >> y;

    ll i = x;
    while(i <= y)
    {
        i = i * 2;
        res++;
    }

    cout << res << "\n";
}


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

using ll = long long;
using ull = unsigned long long;
using ld = long double;

#define MOD 1000000007

#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))

template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
    cout << "(" << m.first << ", " << m.second << ")";
    return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
    ll c = 0;
    cout << "{ ";
    iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
    cout << "{ ";
    rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}

int main(void) {
    ll N;
    ll current = 0;
    vector<pair<ll, ll>> A;
    cin >> N;
    A.resize(N);
    rep(i, N) {
        ll a, b;
        cin >> a >> b;
        A[i] = pair<ll, ll>{b, a};
    }
    sort(A.begin(), A.end());
    iter(i, A) {
        current += i.second;
        if(current > i.first) {
            cout << "No" << endl;
            return 0;
        }
    }
    cout << "Yes" << endl;
    return 0;
}


Measured memory_bytes: 3328
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);
 string s;
 cin>>s;
 int c=0;
 int ans=0;
 for(int i=0;i<s.size();i++){
  if(s[i]=='R')c++;
  else{
   ans = max(ans,c);
   c=0;
  }
 }
 cout<<max(ans,c)<<"\n";
}


Measured memory_bytes: 3632
#include<bits/stdc++.h>
using namespace std;
string to_string(const string& s) {
	return '"' + s + '"';
}
string to_string(const bool b) {
	return (b ? "true" : "false");
}
string to_string(const char* s) {
	return to_string((string)s);
}
string to_string(const char c) {
	string s = "'";
	s += c;
	s += "'";
	return s;
}
template<class T, class U>
string to_string(const pair<T, U>& p) {
	string s = "(";
	s += to_string(p.first);
	s += ", ";
	s += to_string(p.second);
	s += ")";
	return s;
}
template<class T>
string to_string(const T& a) {
	bool first = true;
	string s = "{";
	for (const auto& x : a) {
		if(!first){
			s += ", ";
		}
		first = false;
		s += to_string(x);
	}
	s += "}";
	return s;
}
void debug_out() {cerr << '\n';}
template<class Head, class... Tail>
void debug_out(Head head, Tail... tail) {
	cerr << ' ' << to_string(head);
	debug_out(tail...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "] = ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = 1e9 + 100;
const ll inf64 = 7e18l;
int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(20);
	int n;
	cin >> n;
	vector<int> a(n);
	for (int i = 0; i < n; ++i) {
		cin >> a[i];
	}
	for (int i = 0; i < n; ++i) {
		if (a[i] % 2 == 0) {
			if (a[i] % 3 != 0 && a[i] % 5 != 0) {
				cout << "DENIED\n";
				return 0;
			}
		}
	}
	cout << "APPROVED\n";
 	return 0; 
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
vector <int> a[200];

int main() {
    cin >> s; n = s.size();
    for (int i = 0; i < s.size(); i++) a[s[i]].push_back(i);
    for (int i = 'A'; i <= 'z'; i++) {
        if (a[i].size() >= 2)
        for (int j = 0; j < a[i].size() - 1; j++) {
            if (a[i][j+1] - a[i][j] <= 2) {
                cout << a[i][j] + 1 << " " << a[i][j+1] + 1 << endl;
                return 0;
            }
        }
    }
    cout << "-1 -1" << endl;
}


Measured memory_bytes: 1144
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;

struct UFTree(T)
{
    struct Node
    {
        T parent;
        T rank = 1;
    }

    ///
    T min_size, max_size;

    ///
    this(T n)
    {
        nodes.length = n;
        sizes.length = n;
        foreach (i, ref node; nodes) {
            node = Node(i.to!T);
            sizes[i] = 1;
        }

        min_sizes.length = n + 1;
        min_sizes[1] = n;
        min_size = 1;
        max_size = 1;
    }

    ///
    bool unite(T a, T b)
    {
        a = root(a);
        b = root(b);

        if (a == b) return false;

        auto a_size = sizes[a];
        auto b_size = sizes[b];
        --min_sizes[a_size];
        --min_sizes[b_size];
        ++min_sizes[a_size + b_size];
        foreach (nxt_size; min(a_size, b_size)..min_sizes.length) if (min_sizes[nxt_size] != 0) {
            min_size = nxt_size.to!T;
            break;
        }
        max_size = max(max_size, a_size + b_size);

        if (nodes[a].rank < nodes[b].rank) {
            sizes[a] += sizes[b];
            nodes[b].parent = a;
        } else {
            sizes[b] += sizes[a];
            nodes[a].parent = b;
            if (nodes[a].rank == nodes[b].rank) ++nodes[b].rank;
        }

        return true;
    }

    ///
    bool is_same(T a, T b)
    {
        return root(a) == root(b);
    }

    ///
    T size(T i)
    {
        return sizes[root(i)];
    }

private:
    Node[] nodes;
    T[] sizes;
    T[] min_sizes;

    T root(T i)
    {
        if (nodes[i].parent == i) return i;

        return nodes[i].parent = root(nodes[i].parent);
    }
}

///
UFTree!T uftree(T)(T n)
{
    return UFTree!T(n);
}

void main()
{
    auto nm = readln.split.to!(int[]);
    auto N = nm[0];
    auto M = nm[1];
    auto ps = readln.split.to!(int[]);
    auto uft = uftree(N);
    foreach (_; 0..M) {
        auto xy = readln.split.to!(int[]);
        uft.unite(xy[0]-1, xy[1]-1);
    }
    int r;
    foreach (i, p; ps) {
        if (uft.is_same(i.to!int, p-1)) ++r;
    }
    writeln(r);
}

Measured memory_bytes: 7356
#include <iostream> 
#include <cstdio> 
#include <cstdlib> 
#include <cstring> 
#include <cmath> 
#include <algorithm> 
using namespace std; 

long long S; 
int main () { 
	cin >> S;
	int A = 1e9, B = ceil((double)S / A), C = 1, D = 1ll * A * B - S; 
	cout << 0 << " " << 0 << " "; 
	cout << A << " " << D << " "; 
	cout << C << " " << B << " "; 
    return 0; 
} 

Measured memory_bytes: 384
#include<bits/stdc++.h>
using namespace std;
int a[100010];

int main()
{
    int n,m,L=-1;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        if(a[i]+a[i-1]>=m) L=i;
    }

    if(L==-1) cout<<"Impossible\n";
    else{
    cout<<"Possible\n";
    for(int i=1;i<L-1;i++) cout<<i<<'\n';
    for(int i=n-1;i>=L;i--) cout<<i<<'\n';
    cout<<L-1;
}
}



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

int main()
{
    int n;
    cin >> n;
    vector<int> R(n);
    for (int i = 0; i < n; i++)
    {
        cin >> R[i];
    }

    int ans = -2000000000;
    int minv = R[0];
    for (int i = 1; i < n; i++)
    {
        ans = max(ans, R[i] - minv);
        minv = min(minv, R[i]);
    }

    cout << ans << endl;

    return 0;
}


Measured memory_bytes: 3636
#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    int64_t power =1;
    
    cin >> n;
    
    for(int i=1; i<=n; i++){
        power = power*i;
        power = power%1000000007;
    }
    
    cout << power << endl;
    return 0;

   
}

Measured memory_bytes: 256
INF = 10**9
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
H, W = gets.chomp.split.map(&:to_i)
g = []
H.times { g << gets.chomp }
d = Array.new(H).map { Array.new(W, INF) }
p_s = [0, 0]
p_g = [H - 1, W - 1]

que = [p_s]
d[p_s[0]][p_s[-1]] = 0

until que.empty?
  t = que.shift
  # break if t == p_g

  4.times do |i|
    ni = t[0] + dx[i]
    nj = t[1] + dy[i]
    if ni >= 0 && ni < H && nj >= 0 && nj < W && g[ni][nj] != '#' && d[ni][nj] == INF
      que << [ni, nj]
      d[ni][nj] = d[t[0]][t[1]] + 1
    end
  end
end
if d[p_g[0]][p_g[1]] == INF
  puts '-1'
  exit
end

h = Hash.new(0)
d.each do |rd|
  # puts rd.map{|z| z==INF ? '#' : z}.join(" ")
  rd.map{_1!=INF}.each do |rc|
    # next if rc == INF
    h[rc] += 1
  end
end
ans = 0
h.each do |k, v|
  ans += v if v > 1
end

e = g.dup
n_kabe = 0
H.times do |i|
  n_kabe += g[i].count('#')
  W.times do |j|
    next if g[i][j] == '#'

    ans += 1 if d[i][j] == INF
    e[i][j] = '*' if d[i][j] == INF
  end
end
puts H*W - d[p_g[0]][p_g[1]] - n_kabe - 1

Measured memory_bytes: 14196
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

int main(){
  int h[10];
  
    for(int i=0;i<10;i++)cin>>h[i];
    sort(h,h+10);
    cout << h[9]<<"\n"<<h[8]<<"\n"<<h[7]<<endl;
    
  

  return 0;
}

Measured memory_bytes: 1180
NMC = list(map(int,input().strip().split()))
Bs = list(map(int,input().strip().split()))

N = NMC[0]
M = NMC[1]
C = NMC[2]

count = 0
for i in range(0,N):
    As =list(map(int,input().strip().split()))
    summa = 0
    for h in range(0,M):
        summa += As[h] * Bs[h]
    summa += C
    if summa > 0:
        count += 1

print(count)



Measured memory_bytes: 3064
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

int main() {
  int r, g, b;
  int k;
  cin >> r >> g >> b;
  cin >> k;

  for (int i = 0; i < k; i++) {
    if (g <= r) g *= 2;
    else if (b <= g) b *= 2;
  }

  if (g > r && b > g) cout << "Yes" << endl;
  else cout << "No" << endl;

  return 0;
}



Measured memory_bytes: 3628
N,M=map(int,input().split())
A=[0]+list(map(int,input().split()))

a=0
m=[0]*(N+1)
for i in range(N+1):
    a+=A[i]%M
    a%=M
    m[i]=a

m.sort()
ans=0
cnt=1
for i in range(N):
    if m[i+1]==m[i]:
        cnt+=1
    else:
        ans+=cnt*(cnt-1)//2
        cnt=1
ans+=cnt*(cnt-1)//2
print(ans)

Measured memory_bytes: 14224
#include <iostream>

using namespace std;

int main() {
  int V, d;
  while(cin >> V >> d) {
    int fib[V+2];
    fib[0] = 1;
    fib[1] = 1;
 
    for(int i = 0; i < V; i++) {
      fib[i+2] = fib[i+1] + fib[i];
      fib[i+2] %= 1001;
    }
    int data[V];
    for(int i = 0; i < V; i++) {
      data[i] = fib[i+2];
    }

    for(int i = V-1; i > 0; i--) {
      for(int j = 0; j < i; j++) {
	if(data[j+1] < data[j]) {
	  int temp = data[j];
	  data[j] = data[j+1];
	  data[j+1] = temp;
	}
      }
    }

    int count = 1;
    for(int i = 0; i < V-1; i++) {
      if(data[i+1] - data[i] >= d) count++;
    }
    cout << count << endl;
  }
  return 0;
}

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

int main()
{
  string str;
  cin >> str;
  string correct = "CODEFESTIVAL2016";
  int ans = 0;
  for (size_t i = 0; i < str.size(); i++)
  {
    if (str[i] != correct[i])
    {
      ans++;
    }
  }

  cout << ans << endl;
  return 0;
}


Measured memory_bytes: 256
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll (i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for(ll (i) = 1; (i) <= (n); (i)++)
#define rrep(i, n) for(ll (i) = (n) - 1; (i) >= 0; (i)--)
#define rrep1(i, n) for(ll (i) = (n); (i) >= 1; (i)--)
const ll INF = 1145141919;
const ll MOD = 1000000007;
template<class T> void chmax(T &a, const T &b){if(a < b){a = b;}}
template<class T> void chmin(T &a, const T &b){if(a > b){a = b;}}

ll N, K;
vector<ll>A, B;

ll calc_cost(ll NUM){
    ll sum = 0;
    rep(i, N){
        if(A[i] * B[i] <= NUM)continue;
        ll tmp = NUM / B[i];
        sum += A[i] - tmp;
    }
    return sum;
}

int main(){

    cin >> N >> K;
    A = vector<ll>(N);
    B = vector<ll>(N);
    rep(i, N)cin >> A[i];
    rep(i, N)cin >> B[i];
    sort(A.begin(), A.end());
    sort(B.begin(), B.end(), greater<ll>());


    ll ng = -1, ok = A[N - 1] * B[0];
    while(ng + 1 < ok){
        ll p = (ng + ok) / 2;
        if(calc_cost(p) <= K)ok = p;
        else ng = p;
    }
    cout << ok << endl;
    
    return 0;
}

Measured memory_bytes: 3328
#include <bits/stdc++.h>
#define int long long
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
using namespace std;

const int N=2e5+5;
int n,a[N],mx[N];

void solve()
{
    cin>>n;
    for(int i=0;i<=n;i++) cin>>a[i];
    if(a[0]==1)
    {
        if(n==0) cout<<1;
        else cout<<-1;
        return ;
    }
    else if(a[0]>1)
    {
        cout<<-1;
        return ;
    }
    int cur=1;
    int res=1;
    mx[n]=a[n];
    for(int i=n-1;i>=0;i--) mx[i]=mx[i+1]+a[i];
    for(int i=1;i<=n;i++)
    {
        cur*=2;
        cur=min(cur,mx[i]);
        res+=cur;
        //cout<<i<<' '<<cur<<' '<<mx[i]<<'\n';
        cur-=a[i];
        if(cur<0)
        {
            cout<<-1;
            return ;
        }
    }
    cout<<res;
}

main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    //int t;
    //cin>>t;
    //while(t--)
        solve();
}


Measured memory_bytes: 5212
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <utility>

#define reps(i,f,n) for(int i=f; i<int(n); ++i)
#define rep(i,n) reps(i,0,n)

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;

const int INF = 1001001001;
const int MOD = 1000000007;

int n;

bool func()
{
    map<int, int> m;
    
    rep(i, n){
        int a;
        cin >> a;
        m[a]++;
    }
    
    if(n%2 == 1){
        if(m[0] != 1) return false;
        rep(i, n/2){
            if(m[(i+1)*2] != 2) return false;
        }
        return true;
    }
    
    rep(i, n/2){
        if(m[i*2+1] != 2) return false;
    }
    
    return true;
}

signed main()
{
    cin >> n;
    bool a = func();
    
    if(!a){
        cout << 0 << endl;
        return 0;
    }
    else{
        int ans = 1;
        rep(i, n/2){
            ans *= 2;
            ans %= MOD;
        }
        cout << ans << endl;
    }
}


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

int main() {
    int n;
    string a, b, c;
    string s;
    int count = 0;
    cin >> n;
    cin >> a;
    cin >> b;
    cin >> c;

    for ( int i = 0; i < n; i++){
        if ( (a[i] == b[i]) && (a[i] == c[i]) ){
            count = count;
        } else if ( (a[i] == b[i]) || (a[i] == c[i]) || b[i] == c[i]){
            count = count + 1;
        } else{
            count = count + 2;
        }
    }

    cout << count << endl;
}

Measured memory_bytes: 256
n = int(input())
w = [input() for i in range(n)]
t = set(w)
q = max([w.count(i) for i in t])
if q > 1:
    print('No')
else:
    cnt = n - 1
    tail = w[0][-1]
    for i in w[1:]:
        if tail == i[0]:
            cnt -= 1
        tail = i[-1]
    print('Yes' if cnt == 0 else 'No')

Measured memory_bytes: 3064
# D
import math
N, A, B = map(int, input().split())
H = []
for _ in range(N):
    H.append(int(input()))

def can_clear(n):
    res = 0
    for i in range(N):
        res += max(0, math.ceil((H[i] - B*n) / (A - B)))
    if res > n:
        return False
    else:
        return True


# search
# 0:False
# NR:True
NR = math.ceil(max(H) / B)
NL = 0
while True:
    NM = math.ceil((NR + NL) / 2)
    if NM == NR:
        break
    if can_clear(NM):
        NR = NM
    else:
        NL = NM
print(NM)

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

using namespace std;

int x[110];

int main(){
	int n;

	cin >> n;

	for(int i = 0 ; i < n ; i++){
		cin >> x[i];
	}

	int best = int(1e9);

	for(int d = 1 ; d <= 100 ; d++){
		int tmp = 0;

		for(int k = 0 ; k < n ; k++){
			tmp += (x[k] - d) * (x[k] - d);
		}

		best = min(best, tmp);
	}

	cout << best << endl;

	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <math.h>
#include <stdio.h>
#include <ctype.h>
#include <ios> 
#include <iomanip>
using namespace std;

#define N_MAX   (100000)
#define LL_MAX_NUM (1LL<<60)
#define INF 1e7

typedef long long ll;
typedef long long int lli;

int main() {
    int N, K;
    ll res, tate, yoko;
    res = tate = yoko = 0;
	cin >> N >> K;
    vector<int> A(N,0);
    for (int i = 0; i < N; i++) {
        int ai;
        cin >> ai;
        A[ai-1]++;
    }
    sort(A.begin(), A.end());
    for (int i = 0; i < N; i++) {
        if (A[i] != 0) {
            A.erase(A.begin() , A.begin()+i);
            break;
        }
    }
    int Asize = A.size();
    for (int i = 0; i < A.size(); i++) {
        if (Asize <= K) {
            break;
        }
        res += A[i];
        Asize--;
    }
    cout << res << endl;
	return 0;
}

Measured memory_bytes: 1024
#include <bits/stdc++.h>
using namespace std;
int a, b, x;
int main (){
	cin >> a >> b >> x;
	if (a+b<x) {
        cout << "NO"; 
    } else if (a>x){
        cout << "NO"; 
    } else {
        cout << "YES";
    } 	
}

Measured memory_bytes: 256
N = int(input())
listA = []
import math
total = 0
for i in range(N):
    listA.append(list(map(int,input().split())))
for i in range(N-1):
    A = listA[i]
    for j in range(N-i-1):
        B = listA[i+1+j]
        total += math.sqrt(abs(A[0] - B[0]) ** 2 + abs(A[1] - B[1]) ** 2)
print(total * 2 / N)

Measured memory_bytes: 3064
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; ++i)
#define rrep(i, n) for(int i = n-1; i >= 0; --i)
#define fi first
#define se second
using namespace std;
using lint = long long;
using uint = unsigned int;
using ulint = unsigned long long;
using ldouble = long double;
using pii = pair<int, int>;
using pli = pair<lint, lint>;
using pdd = pair<double, double>;
using pld = pair<ldouble, ldouble>;
using v1i = vector<int>;
using v1li = vector<lint>;
using v2i = vector<vector<int>>;
using v2li = vector<vector<lint>>;
using v3i = vector<vector<vector<int>>>;
using v3li = vector<vector<vector<lint>>>;
using v1b = vector<bool>;
using v2b = vector<vector<bool>>;
using v3b = vector<vector<vector<bool>>>;
using v1c = vector<char>;
using v2c = vector<vector<char>>;
using v3c = vector<vector<vector<char>>>;
constexpr lint mod1 = 1e9+7;
constexpr lint mod2 = 998244353;

int main(){
  int n; cin >> n; long ans;
  v1li a(n), b(n);
  rep(i, n){
    long x, y; cin >> x >> y;
    a[i] = x + y; b[i] = x - y;
  }
  sort(a.begin(), a.end()); sort(b.begin(), b.end());
  ans = max(a[n-1] - a[0], b[n-1] - b[0]);
  cout << ans;
  return 0;
}

Measured memory_bytes: 6424
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

	public static void main(String[] args) {
		Main main = new Main();
		main.notSubmitterSearch();
		return;
	}
	
	//課題の未提出者を検索する
	private void notSubmitterSearch() {
		
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); //標準入力
		
		try {
			
			boolean[] submitterArray = new boolean[30]; //添字が0になっている箇所が未提出者
			
			for (int i = 0; i < 28; i++) {
				String inputStr = bufferedReader.readLine();
				int index = Integer.parseInt(inputStr) - 1;
				submitterArray[index] = true;
			}
			
			for (int i = 0; i < 30; i++) {
				if (!submitterArray[i]) {
					System.out.println(i + 1);
				}
			}
			
		} catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
		
	}
}

Measured memory_bytes: 17020
#include <iostream>
#include <vector>
#include <string>

using namespace std;

int calc_gcd(int a, int b)
{
  if (b == 0)
    return a;
  return calc_gcd(b, a%b);
}

int main()
{
  int x,a;
  
  cin >> x >> a;
  
  if (x < a) {
    cout << "0" << endl;
  } else {
    cout << "10" << endl;
  }
  
  return 0;
}


Measured memory_bytes: 256
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();
      int c = sc.nextInt();
      int x = sc.nextInt();
      int y = sc.nextInt();
      int sum = 0;
      
      if (a + b < c * 2) {
        sum = a * x + b * y;
      } else { 
        int set = 0;
        int xzan = 0;
        int yzan = 0;
        
        if(x > y) {
           if(c * 2 < a) {
            set = x;
           }
           else {
            set = y;
            xzan = x - y;   
           } 
        } else {
            if(c * 2 < b) {
                set = y;
            } else {
                set = x;
                yzan = y - x;   
            }
        }
        sum = (set * c * 2) + (xzan * a) + (yzan * b);
      }
      
      System.out.println(sum);
      
  }
}

Measured memory_bytes: 22996
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
	int n,i,count=0;
	ll sum=0,min=1000000000;
	cin >> n;
	for(i=0;i<n;i++){
		ll num;
		cin >> num;
		if(num<0)	count++;
		num = abs(num);
		sum += num;
		if(min>num)	min = num;
	}
	if(count%2==0)	cout << sum << endl;
	else				cout << sum - (2*min) << endl;
	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int main()
{
	vector<string> a(2);
	for (auto &x : a) {
		cin >> x;
	}
	auto b = a;
	reverse(b.begin(), b.end());
	for (auto &x : b) {
		reverse(x.begin(), x.end());
	}
	if (a == b) {
		cout << "YES" << endl;
	}
	else {
		cout << "NO" << endl;
	}
}


Measured memory_bytes: 256
if __name__=='__main__':
    n = int(input())
    c = [[int(i) for i in input().split()] for i in range(n)]
    # print(c)
    a = [[0 for i in range(101)] for i in range(101)]
    # print(a)
    for i in range(101):
        for j in range(101):
            for p in range(n):
                if c[p][2] != 0:
                    a[i][j] = abs(i - c[p][0]) + abs(j - c[p][1]) + c[p][2]
                    break


            for p in range(n):
                if c[p][2] != 0:
                    h = abs(i - c[p][0]) + abs(j - c[p][1]) + c[p][2]
                    if a[i][j] != h:
                        a[i][j] = -1
                        break
                if c[p][2] == 0:
                    h = abs(i - c[p][0]) + abs(j - c[p][1])
                    if a[i][j] > h:
                        a[i][j] = -1
                        break


    for i in range(101):
        for j in range(101):
            flag = True
            if a[i][j] == -1:continue
            # for p in range(n):
            #     h = abs(i-c[p][0])+ abs(j-c[p][1]) + c[p][2]
            #     if h != a[i][j]:
            #         flag = False
            #         break
            # if flag:
            for p in range(n):
                h = max(a[i][j] - abs(i-c[p][0])- abs(j-c[p][1]),0)
                if h!= c[p][2]:
                    flag = False
                    break
            if flag:
                print(i,j,a[i][j])
                quit()


Measured memory_bytes: 3188
from collections import Counter
N = int(input())
D = list(map(int, input().split()))
MOD = 998244353
ans = 1
dep = Counter(D)
if dep[0] != 1 or D[0] != 0:
    print(0)
    exit(0)
if max(D) == 0:
    pass
else:
    for i in range(1, max(D) + 1):
        if dep[i] == 0:
            print(0)
            exit(0)
        else:
            ans *= dep[i-1] ** dep[i]
            ans %= MOD
print(ans)

Measured memory_bytes: 24268
#include <cstdio>
#include <algorithm>

using namespace std;

int main(){
    int n,k=0,d[100],min;
    
    scanf("%d",&n);
    
    for(int i=0;i<n;i++)
        scanf("%d",&d[i]);
    
    for(int i=0;i<n;i++){
        min=i;
        for(int j=i;j<n;j++)
            if(d[j]<d[min]) min=j;
        if(min!=i){
            swap(d[i],d[min]);
            k++;
        }
    }
    
    for(int i=0;i<n;i++)
        printf(i<n-1 ? "%d " : "%d\n",d[i]);
    
    printf("%d\n",k);
    
    return 0;
}

Measured memory_bytes: 1032
import java.util.Scanner;

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

        long X = sc.nextLong();
        int count = 0;
        double money = 100;
        while (money < X) {
            money += money/100;
            money = Math.floor(money);
            count++;
        }
        System.out.println(count);
    }
}

Measured memory_bytes: 35688
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"

using namespace std;

const long long int MOD = 1000000007;
const long double EPS = 1e-8;

long long int N, M, K, H, W, L, R;

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	cin >> N;
	vector<long long int>v(1 << N);
	vector<set<long long int>>mv(1 << N);
	for (int i = 0; i < 1 << N; i++) {
		cin >> v[i];
		v[i] = v[i] * MOD + i;
	}
	for (int i = 0; i < 1 << N; i++) {
		for (int j = 0; j < N; j++) {
			if (i&(1 << j))continue;
			mv[i + (1 << j)].insert(v[i]);
			for (auto k : mv[i]) {
				mv[i + (1 << j)].insert(k);
				while (mv[i + (1 << j)].size() > 2)mv[i + (1 << j)].erase(mv[i + (1 << j)].begin());
			}
		}
	}
	long long int ans = 0;
	for (int i = 1; i < 1 << N; i++) {
		set<long long int>st;
		st.insert({ v[i] });
		for (auto j : mv[i])st.insert(j);
		while (st.size() > 2)st.erase(st.begin());
		ans = max(ans, *st.begin() + *st.rbegin());
		cout << ans / MOD << endl;
	}
	return 0;
}

Measured memory_bytes: 42496
#include <stdlib.h>
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
using ll=long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
inline constexpr ll gcd(ll a,ll b){if(!a||!b)return 0;while(b){ll c=b;b=a%b;a=c;}return a;}
inline constexpr ll lcm(ll a,ll b){if(!a||!b)return 0;return a*b/gcd(a,b);}
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;
}
const long long INF=1LL << 60;
long long a,b;
long long dp[100200][110];
long long w[110],v[110];


int main(){
    int k;
    cin>>k;
    string s;
    cin>>s;
    if(s.size()>k){
        cout<<s.substr(0,k)<<"..."<<endl;
    }
    else{
        cout<<s<<endl;
    }
   
}



Measured memory_bytes: 3624
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n)   FOR(i,0,n)
#define pb emplace_back
#define mp make_pair
typedef long long ll;
typedef pair<int,int> pint;

int main(){
    int n,a,b;
    cin>>n>>a>>b;
    if((a-b)%2==0) cout<<"Alice"<<endl;
    else cout<<"Borys"<<endl;
    return 0;
}

Measured memory_bytes: 764