akhauriyash/Code-Regression huggingface dataset:
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(V) (V).begin(),(V).end()
#define MOD 1000000007
#define mod 998244353

const ll bas = 1222122211;
const ll rmod = 2111211121;

bool rolling_hash(string S, int L, ll b, ll h) {
	ll hash = 0, pw = 1;
	for (int i = 0;i < L;i++) {
		hash *= b;
		hash += S[i];
		hash %= h;
		pw *= b;
		pw %= h;
	}
	multimap<ll, ll> hass = { {hash,L - 1} };
	for (int i = L;i < S.size();i++) {
		hash *= b;
		hash += S[i];
		hash -= S[i - L] * pw;
		hash %= h;if (hash < 0)hash += h;
		auto it1 = hass.lower_bound(hash);
		while ((*it1).first == hash) {
			if ((*it1).second <= i - L) {
				return true;
			}
			it1++;
		}
		hass.insert({ hash,i });
	}
	return false;
}

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

	int l = 0, r = N, m;
	while (r - l > 1) {
		m = (l + r) / 2;
		if (rolling_hash(S, m, bas, rmod) && rolling_hash(S, m, mod, MOD)) {
			l = m;
		}
		else {
			r = m;
		}
	}
	cout << l << endl;
}

Measured memory_bytes: 512
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;

public class Test152_b
{

        /// <summary>
        /// https://atcoder.jp/contests/abc152/tasks/abc152_b
        /// </summary>
        public static void Main()
        {
            string[] ss = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            int a = int.Parse(ss[0]);
            int b = int.Parse(ss[1]);

            //整数 a を b 回繰り返してできる文字列と
            StringBuilder sbA = new StringBuilder();
            for(int i=0;i<b;i++)
            {
                sbA.Append(a.ToString());
            }
            StringBuilder sbB = new StringBuilder();

            //整数 b を a 回繰り返してできる文字列と
            for (int i = 0; i < a; i++)
            {
                sbB.Append(b.ToString());
            }

            // 辞書順で小さい方を答えてください。
            if (string.Compare(sbA.ToString(), sbB.ToString()) < 0)
            {
                Console.WriteLine(sbA.ToString());
            }
            else
            {
                Console.WriteLine(sbB.ToString());
            }
        }
}


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

#include <boost/multiprecision/cpp_int.hpp>

// increment
#define rep_n(_1, _2, _3, NAME, ...) NAME
#define rep_2(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rep_3(i, initial, n) \
  for (int(i) = (int)(initial); (i) < (int)(n); ++(i))
#define rep(...) rep_n(__VA_ARGS__, rep_3, rep_2, rep_1)(__VA_ARGS__)
// decrement
#define rep_r_n(_1, _2, _3, NAME, ...) NAME
#define rep_r_2(i, n) for (int(i) = (int)(n); (i) > 0; (i)--)
#define rep_r_3(i, initial, n) \
  for (int(i) = (int)(initial); (i) > (int)(n); (i)--)
#define rep_r(...) rep_r_n(__VA_ARGS__, rep_r_3, rep_r_2)(__VA_ARGS__)
// define type definition
using namespace std;
typedef long long ll;
using mpint = boost::multiprecision::cpp_int;  // 多倍長整数（任意精度）
typedef pair<int, int> P;

// define construct variable
const double EPS = numeric_limits<double>::epsilon();
// 10^9 + 7
const ll MOD = ll(1e9) + 7;
const ll INF = ll(1e10);
const string ALPHABET = "abcdefghijklmnopqrstuvwxyz";
const double PI = acos(-1);

// define methods
// 最大公約数
ll gcd(const ll a, const ll b) { return b ? gcd(b, a % b) : a; }
// 最小公倍数
ll lcm(const ll a, const ll b) { return a / gcd(a, b) * b; }
// char -> int
int ctoi(char c) { return (int)(c - '0'); }
// 素因数分解
vector<pair<ll, ll>> prime_factorize(ll n) {
  vector<pair<ll, ll>> p;
  for (ll i = 2; i * i <= n; i++) {
    if ((n % i) != 0) continue;
    pair<ll, ll> a = make_pair(i, 0);
    while ((n % i) == 0) {
      n /= i;
      a.second += 1;
    }
    p.push_back(a);
  }

  if (n != 1) p.push_back(make_pair(n, 1));
  return p;
}
// 組み合わせの整合性を保つ（後ほど解析する）
ll modinv(ll a) {
  ll b = MOD, u = 1, v = 0;
  while (b) {
    ll t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  u %= MOD;
  if (u < 0) {
    u += MOD;
  }
  return u;
}
// 順列
ll permutation(const ll n, const ll m) {
  ll result = 1;
  for (ll i = n; i > n - m; i--) {
    result = (result * i) % MOD;
  }
  return result;
}

// 繰り返し n 乗法
ll repeat_square(const ll n, const ll x) {
  if (x == 0) return 1;
  ll res = repeat_square(n, x / 2);
  res = res * res % MOD;
  if ((x % 2) == 1) res = res * n % MOD;
  return res;
}
// 組み合わせ nCm
ll combination(ll n, ll m) {
  ll p = permutation(n, m);
  ll div = 1;
  for (ll i = 2; i <= m; i++) {
    div = (div * i) % MOD;
  }
  return (p * modinv(div)) % MOD;
}

// アルファベットの取得
string get_alphabet(ll n) {
  n--;
  return string(1, 'a' + (n % 26));
}

int main() {
  int N;
  cin >> N;
  ll start = 1;
  rep(i, N) {
    start *= (i+1);
    start %= MOD;
  }

  cout << start << endl;
  return 0;
}


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

#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)

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 (a>b) { a=b; return 1; } return 0; }

#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>

#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ins insert

using namespace std;

/* Some Libraries */

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

int main(void)
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N; cin>>N;
    string S; cin>>S;
    int ans=0;
    FOR(i,0,999){
        int a=i%10;
        int b=i/10%10;
        int c=i/100%10;
        int vec[]={a,b,c};
        int idx=0;
        rep(j,N){
            if (idx<3 && S[j]-'0'==vec[idx]){
                idx++;
            }
        }
        if (idx==3) ans++;
    }
    cout<<ans<<"\n";
    return 0;
}


Measured memory_bytes: 384
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))

m=0

for i in range(n):
    m+=b[a[i]-1]
    if i>0:
      if a[i-1]+1==a[i]:
        m+=c[a[i-1]-1]
    
print(m)

Measured memory_bytes: 3060
#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i=0; i<n; ++i){
        cin >> a[i];
    }
    // -- solve --
    int ans = 0;
    for (int i=0; i<n-1; ++i){
        if(a[i] == a[i+1]){
            ans++;
            a[i+1] = 10001;
        }
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 504
#include <iostream>
#include <vector>

int main()
{
    // input
    int N, K;
    std::cin >> N >> K;
    std::vector<long long> a(N);
    for(int i=0; i<N; i++) scanf(" %lld", &a[i]);

    std::vector<long long> sum_l(N), sum_r(N);
    sum_l[0] = a[0] > 0 ? a[0] : 0;
    sum_r[N-1] = a[N-1] > 0 ? a[N-1] : 0;
    for(int i=1; i<N; i++){
        sum_l[i] = sum_l[i-1];
        sum_r[N-1-i] = sum_r[N-i];
        if(a[i] > 0) sum_l[i] += a[i];
        if(a[N-1-i] > 0) sum_r[N-1-i] += a[N-1-i];
    }
    std::vector<long long> sum_K(N, 0);
    for(int i=0; i<K; i++) sum_K[0] += a[i];
    for(int i=1; i+K-1<N; i++) sum_K[i] = sum_K[i-1] - a[i-1] + a[i+K-1];

    long long max = 0;
    for(int i=0; i+K+1<N; i++){
        long long tmp = sum_l[i] + sum_r[i+K+1];
        if(sum_K[i+1] > 0) tmp += sum_K[i+1];
        if(max < tmp) max = tmp;
    }
    if(K<N && max < sum_r[K]) max = sum_r[K];
    if(K<N && max < sum_K[0] + sum_r[K]) max = sum_K[0] + sum_r[K];
    if(K<N && max < sum_l[N-1-K]) max = sum_l[N-1-K];
    if(K<N && max < sum_l[N-1-K] + sum_K[N-K]) max = sum_l[N-1-K] + sum_K[N-K];
    if(K==N && max < sum_K[0]) max = sum_K[0]; 

    // output
    std::cout << max << std::endl;
}

Measured memory_bytes: 3328
#include<cstdio>
#include<queue>
#include<cstring>
#define maxn 805
#define INF 0x3f3f3f3f
using namespace std;
typedef pair<int,int> PII;
int h,w,k,dist[maxn][maxn],sx,sy,d[5]={0,1,0,-1,0},ans=INF;
char s[maxn][maxn];
queue<PII> q;
int Get(int i,int j)
{
	int tmp=(i+k-2)/k;
	tmp=min(tmp,(j+k-2)/k);
	tmp=min(tmp,(h-i+k-1)/k);
	tmp=min(tmp,(w-j+k-1)/k);
	return tmp;
}
int main()
{
	scanf("%d%d%d",&h,&w,&k);
	for(int i=1;i<=h;i++) scanf("%s",s[i]+1);
	for(int i=1;i<=h&&!sx;i++)
		for(int j=1;j<=w&&!sx;j++)
			if(s[i][j]=='S') sx=i,sy=j;
	memset(dist,0x3f,sizeof(dist));
	dist[sx][sy]=0;
	q.push(PII(sx,sy));
	while(!q.empty())
	{
		int x=q.front().first,y=q.front().second;
		q.pop();
		if(dist[x][y]==k) continue;
		for(int i=1;i<=4;i++)
		{
			int cx=x+d[i-1],cy=y+d[i];
			if(cx<1||cy<1||cx>h||cy>w||dist[x][y]+1>=dist[cx][cy]||s[cx][cy]=='#') continue;
			dist[cx][cy]=dist[x][y]+1; q.push(PII(cx,cy));
		}
	}
	for(int i=1;i<=h;i++)
		for(int j=1;j<=w;j++)
			if(dist[i][j]<INF)
				ans=min(ans,Get(i,j)+1);
	printf("%d\n",ans);
}

Measured memory_bytes: 3456
#include <stdio.h>
#include <vector>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <cstring>
using namespace std;
using ll = long long;

int main(){
  int w,h,n;
  cin >> w >> h >> n;
  vector<int> x(100),y(100),a(100);
  vector<vector<bool>> rec(w,vector<bool>(h,false));
  for (int i = 0; i < n; i++) {
    cin >> x[i] >> y[i] >> a[i];
  }
  for (int k = 0; k < n; k++) {
    if (a[k] == 1) {
      for (int i = 0; i < x[k]; i++) {
        for (int j = 0; j < h; j++) {
          rec[i][j] = true;
        }
      }
    } else if (a[k] == 2) {
      for (int i = x[k]; i < w; i++) {
        for (int j = 0; j < h; j++) {
          rec[i][j] = true;
        }
      }
    } else if (a[k] == 3) {
      for (int i = 0; i < y[k]; i++) {
        for (int j = 0; j < w; j++) {
          rec[j][i] = true;
        }
      }
    } else {
      for (int i = y[k]; i < h; i++) {
        for (int j = 0; j < w; j++) {
          rec[j][i] = true;
        }
      }
    }
  }
  int counter = 0;
  for (int i = 0; i < w; i++) {
    counter += count(rec[i].begin(),rec[i].end(),false);
  }
  cout << counter << endl;
  return 0;
}


Measured memory_bytes: 256
#a,b=(int(x) for x in input().split()) #数値の時




#a,b=(x for x in input().split()) 
a,b,c,k=(int(x) for x in input().split())

if(k<=a):
  print(k)
else:
  sum=a
  t=k-a
  if(t<=b):
    print(sum)
    
  else:
    t-=b
    
    
    print(sum-t)


Measured memory_bytes: 9156
(defun letter-check (string)
  (string= (string-downcase string) string)
  )

(defun solve (string)
  ;(princ string)
  ;(princ (string-upcase string))
  (if (letter-check string)
      (princ "a")
      (princ "A")
  )
)

(solve (read-line))

Measured memory_bytes: 23708
import java.util.Scanner;

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

        if(num%10 == 9 || num/10 == 9) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
        //System.out.println()

        //System.out.println(count);

    }
}


Measured memory_bytes: 20820
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
 
int n, ta = 1;
 
int main(){
	cin >> n;
	for (int i = 1; i <= n; i++) {
		if (i / ta == 2) {
			ta = i;
		}
	}
	cout << ta << endl;
	return 0;
}

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

using namespace std;


int main() {
	string s;
	cin >> s;
	set<char> st(s.begin(), s.end());
	if (st.size() == 2) puts("Yes");
	else puts("No");
	return 0;
}


Measured memory_bytes: 256
#include <iostream>
using namespace std;
int main(){
    int n,x,sum;
    sum = 0;
    while (n != 0 || x!= 0) {
      /* code */
      cin >> n >> x;
      if(n == 0 && x == 0){
        break;
      }else{
        for(int i = 1;i<n+1;i++){
          for(int j = i+1;j<n+1;j++){
            for(int k = j+1;k<n+1;k++){
              if((i+j+k) == x){
                sum += 1;
              }
            }
          }
        }
      }
        cout << sum << "\n";
        sum = 0;
    }

    return 0;
}


Measured memory_bytes: 3084
h,w=map(int,input().split())
g=[input() for _ in range(h)]
from collections import *
def bfs(x,y):
  d=[[-1]*w for _ in range(h)]
  d[x][y]=0
  q=deque([(x,y)])
  while q:
    tx,ty=q.popleft()
    for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
      nx,ny=tx+dx,ty+dy
      if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
        r=d[nx][ny]=d[tx][ty]+1
        q.append((nx,ny))
  return r
print(max(bfs(x,y) for x in range(h) for y in range(w) if g[x][y]=='.'))

Measured memory_bytes: 9356
#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1002000007
#define INF LONG_LONG_MAX

typedef pair<int, int> P;
int main(){
    int ab,bc,ca;
    cin>>ab>>bc>>ca;
    cout<<ab*bc/2<<endl;
}





Measured memory_bytes: 256
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
#define REP(i, limit) for(int i=0; i< limit; ++i)
#define LINT long long

const int MAX_N = 100000;
int par[MAX_N]; //親の番号
int height[MAX_N]; //木の高さ(ランク)



//xの親番号を返す、再帰処理あり
int root(int x){
  return par[x] == x ? x : par[x] = root(par[x]);
}

//xとyの親番号が同一か判定する
bool same(int x, int y){
  return root(x) == root(y);
}

//xとyのある木を結合する
void unite(int x, int y){
  x = root(x);
  y = root(y);
  if(x == y) return; //親が同一なら結合済み。

  if(height[x] < height[y]) par[x] = y;
  else {
    par[y] = x;
    if(height[x] == height[y]) height[x]++;
  }
}

int main(){
  int N, M, count=0;
  cin >> N >> M;
  int p[N], x[M], y[M];
  REP(i, N) cin >> p[i];
  REP(i, M) cin >> x[i] >> y[i];


  REP(i, N){
    par[i] = i;
    height[i] = 0;
  }

  REP(i, M) unite(x[i], y[i]);

  REP(i, N) if( same(i+1, p[i]) ) ++count;

  cout << count << endl;


  return 0;
}


Measured memory_bytes: 2176
#include <stdio.h>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef vector<vector<int>> v2int;
typedef vector<ll> vll;
typedef vector<vector<ll>> v2ll;
typedef list<int> liint;
typedef pair<int, int> pint;
const int INF = int(2e9);
const ll LINF = ll(2e9) * ll(2e9);
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T, class C> void chmax(T& a, C b) { a > b ? : a = b; }
template<class T, class C> void chmin(T& a, C b) { a < b ? : a = b; }
const int max_N = 2000000 + 1;

class seg_tree {
private:

    vector<ll> dat;
    int n;
public:
    seg_tree(int _n) : dat(2 * max_N - 1) {
        n = 1;
        while (n < _n) n *= 2;
    }
    void init_fill(ll v) {
        for (int i = 0; i < 2 * n - 1; i++) {
            dat[i] = v;
        }
    }
    void updata(int k, ll a) {
        k += n - 1;
        dat[k] = a;
        while (k > 0) {
            k = (k - 1) / 2;
            dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
        }
    }
    ll query(int a, int b, int k, int l, int r) {
        if (a == b) {
            return dat[a + n - 1];
        }
        if (r <= a || b <= l) return 0;
        if (a <= l && r <= b) return dat[k];
        else {
            ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
            ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
            return max(vl, vr);
        }
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int N;
    ll D, A;

    cin >> N >> D >> A;
    vll X(N), H(N);
    vector<pair<ll, ll>> XH(N);
    rep(i, N) {
        cin >> X[i] >> H[i];
        XH[i] = make_pair(X[i], H[i]);
    }


    sort(XH.begin(), XH.end());
    sort(X.begin(), X.end());

    ll ans = 0;
    map<int, int> first_damage_map;
    vll damageS(N + 1);
    rep(i, N) {
        auto h = XH[i].second;
        if (first_damage_map.lower_bound(i) != first_damage_map.end()) {
            h =max(0LL, h - (damageS[i] - damageS[(*first_damage_map.lower_bound(i)).second]));
        }
        ll cnt = h / A;
        if (h % A != 0) cnt++;
        ans += cnt;
        damageS[i + 1] = damageS[i] + cnt * A;

        ll range = XH[i].first + 2 * D;
        int it;
        if (upper_bound(X.begin(), X.end(), range) == X.end())
            it = N - 1;
        else
            it = distance(X.begin(), upper_bound(X.begin(), X.end(), range)) - 1;
        if(first_damage_map.find(it) == first_damage_map.end())
            first_damage_map[it] = i;

    }

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

Measured memory_bytes: 17408
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <string>
#include <cmath>
#include <complex>
#include <numeric>
#include <cassert>

#include <vector>
#include <array>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>

#define PI 3.14159265358979323846
#define int64 long long
#define uint64 unsigned long long
#define coutfix(i) cout << fixed << setprecision(i)		//coutの浮動小数出力の桁数設定
using namespace std;

int main()
{
	string ss;
	cin >> ss;
	if(ss[ss.length() - 1] == 's')
	{
		cout << ss << "es" << endl;
	}
	else
	{
		cout << ss << 's' << 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 o= 0 ,p = 0,q = 0;
		int a = 0, b = 0;
		char ch;
		String str;
		

        String s1 = sc.next();

//      int s = Integer.parseInt(sc.next());
//	    int[] test  = new int[100000];
        char[] c = s1.toCharArray();
        
        if(c[0]!='C')b++;
        if(c[1]!='O')b++;
        if(c[2]!='D')b++;
        if(c[3]!='E')b++;
        if(c[4]!='F')b++;
        if(c[5]!='E')b++;
        if(c[6]!='S')b++;
        if(c[7]!='T')b++;
        if(c[8]!='I')b++;
        if(c[9]!='V')b++;
        if(c[10]!='A')b++;
        if(c[11]!='L')b++;
        if(c[12]!='2')b++;
        if(c[13]!='0')b++;
        if(c[14]!='1')b++;
        if(c[15]!='6')b++;



        System.out.print(b);
        System.out.println();
	}
}

Measured memory_bytes: 9684
n = int(input())
l = list(map(int,input().split()))
ans = []
i = 0
while l != [0]*n:
  for s in range(n):
    if l[s] != 0:
      start = s
      break
  mini = 101
  flag = True
  i = start
  while flag:
    if l[i] != 0:
      mini = min(mini,l[i])
      if i == n-1:
        for k in range(start,n):
          l[k] -= mini
        ans.append(mini)
        flag = False
        i = -1
    else:
      for j in range(start,i):
        l[j] -= mini
      ans.append(mini)
      flag = False
    i += 1 
print(sum(ans))

Measured memory_bytes: 38896
#include <iostream>
using namespace std;
int main(){
	int a,b;
  cin >> a >> b;
  
	if(a>=13){
    	cout << b << endl;
    }
  else if(a>=6 && a<=12){
  	cout << b/2 << endl;
  }
  else if(a<=5){
  	cout << 0 << endl;
  }
}

Measured memory_bytes: 256
#include <stdio.h>
 

int main()
{ 
	int i,j;
	char s,t;
	s='x';
	t='=';
	for(i=1;i<=9;i++)
	{
		for(j=1;j<=9;j++)
		{
		printf("%d%c%d%c%d\n",i,s,j,t,i*j);
		}
	}
	 	return 0;
}

Measured memory_bytes: 924
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <queue>

using namespace std;

typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<n;++i)
#define mod (ll)(1e9+7)
#define FIX(a) ((a)%mod+mod)%mod
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define fi first
#define se second
#define pb push_back
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    vector<string> s(3);
    REP(i,3) cin >> s[i];
    vint cnt(3,0);
    string abc = "abc";
    string ans = "ABC";
    int t = 0;
    while(true){
        if(cnt[t]==(int)s[t].size()){
            cout << ans[t] << endl;
            return 0;
        }
        int next;
        REP(i,3){
            if(s[t][cnt[t]]==abc[i]){
                next = i;
            }
        }
        cnt[t]++;
        t = next;
    }

    return 0;
}

Measured memory_bytes: 256
h,w=map(int,input().split())
if h%3==0 or w%3==0:
    print(0)
else:
    num1=max((h//3)*w,(h-(h//3))*(w//2),(h-(h//3))*(w-(w//2)))-min((h//3)*w,(h-(h//3))*(w//2),(h-(h//3))*(w-(w//2)))
    num2=max((w//3)*h,(w-(w//3))*(h//2),(w-(w//3))*(h-(h//2)))-min((w//3)*h,(w-(w//3))*(h//2),(w-(w//3))*(h-(h//2)))
    num3=max((h//3+1)*w,(h-(h//3+1))*(w//2),(h-(h//3+1))*(w-(w//2)))-min((h//3+1)*w,(h-(h//3+1))*(w//2),(h-(h//3+1))*(w-(w//2)))
    num4=max((w//3+1)*h,(w-(w//3+1))*(h//2),(w-(w//3+1))*(h-(h//2)))-min((w//3+1)*h,(w-(w//3+1))*(h//2),(w-(w//3+1))*(h-(h//2)))
    print(min(num1,num2,num3,num4,h,w))


Measured memory_bytes: 3444
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    vector<long> v;
    for(int i=0;i<n;i++)
    {
        long x;
        cin>>x;
        v.push_back(x);
    }
    int count=0;
    long d=-1;
    long prev=0;
    for(int i=0;i<n;i++)
    {
        if(prev>v[i])
        {
            if(prev-1>v[i])
            {
                cout<<"No";
                return 0;
            }
            
        }
        else
        {
	         prev=v[i];
	 }	
        
    }
    cout<<"Yes";
    return 0;
}

Measured memory_bytes: 1400
#include <iostream>
#include <stdio.h>
#include <string>
#include <list>
#include <vector>
#include <algorithm>

#define rep(i,n) for(int i = 0;i < n;i++)
#define REP(i,n,k) for(int i = n;i < k;i++)
#define P(p) cout << (p) << endl;//print
typedef long long ll;
using namespace std;


int main(){
    cin.tie(0);
   	ios::sync_with_stdio(false);
    
    string s;
    cin >> s;
    ll i = 0;
    while(i<s.length()){
        cout << s[i];
        i=i+2;
    }
}


Measured memory_bytes: 592
using System;
using System.CodeDom;
using System.Linq;

namespace paizaTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var readLine = Console.ReadLine().Split(' ').Select(int.Parse).ToList();

            var width = readLine[0];
            var height = readLine[1];

            var x = readLine[2];
            var y = readLine[3];
            var r = readLine[4];

            var result = true;
            if (x - r < 0)
            {
                result = false;
            }
            if (y - r < 0)
            {
                result = false;
            }
            if (x + r > width)
            {
                result = false;
            }
            if (y + r > height)
            {
                result = false;
            }

            Console.WriteLine(result ? "Yes" : "No");
        }
    }
}

Measured memory_bytes: 9340
n = int(input())
res = 0
list_ = [[0 for j in range(10)] for i in range(10)]
for i in range(1, n + 1):
    s = list(str(i))
    initl = int(s[0])
    end = int(s[-1])
    list_[initl][end] += 1
for i in range(1, 10):
    for j in range(1, 10):
        res += list_[i][j] * list_[j][i]
print(res)


Measured memory_bytes: 3060
#include<iostream>
#include<bits/stdc++.h>
#define endl "\n"
using namespace std;
typedef long long int ll;
int main(){

    ll n;
    cin>>n;
    ll h[n+1];
    for(ll i=0;i<n;i++){
        cin>>h[i];
    }

    ll dp[n];
    
    dp[0]=0;
    dp[1]= abs(h[1]-h[0]);

    for(ll i=2;i<n;i++){
        dp[i] = min(dp[i-1] + abs(h[i]-h[i-1]),dp[i-2]+ abs(h[i]-h[i-2]));
    }

    //for(ll i=0;i<n;i++)
    //cout<<dp[i]<<" ";

    //cout<<endl;
    cout<<dp[n-1]<<endl;
    
}

Measured memory_bytes: 1792
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = int(a); i < int(b); i++)
#define rer(i, a, b) for(int i = int(a) - 1; i >= int(b); i--)

using namespace std;
typedef long long int ll;
typedef pair<int, ll> P;
const ll INF=1e16;
int N;
vector<P> E[100000];
ll dp[100000];
void dfs(int x){
    rep(i,0,E[x].size()){
        if(dp[E[x][i].first]==INF){
            dp[E[x][i].first]=dp[x]+E[x][i].second;
            dfs(E[x][i].first);
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>N;
    rep(i,0,N-1){
        ll a,b, c;
        cin>>a>>b>>c;
        E[a-1].push_back(P(b-1,c));
        E[b-1].push_back(P(a-1,c));
    }
    int Q,K;
    cin>>Q>>K;
    fill(dp,dp+N,INF);
    dp[K-1]=0;
    dfs(K-1);
    rep(i,0,Q){
        int x,y;
        cin>>x>>y;
        cout <<dp[x-1]+dp[y-1]<<"\n";
    }
}

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

vector<long long> a, b;
long long n, sum, k;
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n;
	a.resize(n);
	b.resize(n);
	for(int i = 0; i < n; i++) cin >> a[i], sum += a[i];
	if(sum % (n*(n+1)/2)) cout << "NO", exit(0);
	k = sum / (n*(n+1)/2);
	for(int i = 0; i < n-1; i++) b[i] = a[i+1] - a[i];
	b[n-1] = a[0] - a[n-1];
	for(int i = 0; i < n; i++) if((k-b[i])%n || k-b[i] < 0) cout << "NO",exit(0);
	cout << "YES";
}


Measured memory_bytes: 1792
#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define m 1000000007 
#define MAXN 100000
using namespace std;
int main(){
    ll n;
    cin>>n;
    ll sum=0;
    for(ll i=1;i<=n;i++){
        if(i%3==0 || i%5==0 || (i%3==0 && i%5==0)) continue;
        else{
            sum+=i;
        }
    }
    cout<<sum<<endl;
}

Measured memory_bytes: 3636
#include "bits/stdc++.h"
using namespace std;

// GNU C Compiler
//template<class T> inline string toString(T x) { ostringstream sout; sout << x; return sout.str(); }

// type
using ll = int_fast64_t;
using ull = uint_fast64_t;
using LL = long long;
using ULL = unsigned long long;
using PII = pair<int, int>;
//using pair<T1, T2> = p12;

//container
#define PB emplace_back
#define MP make_pair 
#define SZ(a) int((a).size())
#define ALL(v) v.begin(),v.end()

//repetition
#define REP(n) for(int i=0; i<(n); i++)
#define REPj(n) for(int j=0; j<(n); j++)
#define REPinit(i,a,n) for(int i=(a); i<(n); i++)
#define REPinitj(j,a,n) for(int j=(a); j<(n); j++)

//algorithm
//#define SORT(c) sort((c).begin(),(c).end())

//constant

//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))

//Optimizer
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

/* 
	add utility Algorithm
*/

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

    int x1,y1,x2,y2;
    cin >> x1 >> y1 >> x2 >> y2;

    int dx = (x2 - x1);
    int dy = (y2 - y1);
    printf("%d %d %d %d\n",x2 - dy, y2 + dx, x1 - dy, y1 + dx);

    return 0;
}


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

int main(){

  int y,m,d;
  while(scanf("%d %d %d",&y,&m,&d) != EOF){
    
    if(y>1989 || (y==1989 && (m>1 || (m==1 && d>=8)))){
      printf("heisei %d %d %d\n",y-1989+1,m,d);
    }else if(y>1926 || (y==1926 && (m==12 && d>=25))){
      printf("showa %d %d %d\n",y-1926+1,m,d);
    }else if(y>1912 || (y==1912 && (m>7 || (m==7 && d>=30)))){
      printf("taisho %d %d %d\n",y-1912+1,m,d);
    }else if(y>1868 || (y==1868 && (m>9 || (m==9 && d>=8)))){
      printf("meiji %d %d %d\n",y-1868+1,m,d);
    }else{
      printf("pre-meiji\n");
    }

  }

  return 0;
}

Measured memory_bytes: 1196
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
#include <algorithm>
using std::pair;
using std::make_pair;
#include <vector>
using std::vector;

typedef vector<int> VI;
typedef pair<int, int> PII;
typedef vector<vector<PII> > VP;

int main(void) {
    while (1) {
        int n; // pc
        int m; // person
        cin >> n >> m;
        if (n == 0 && m == 0) {
            break;
        }

        VI pc(m + 1, 0);
        VI start(m + 1, 0);

        VP time(m + 1);

        int r;
        cin >> r;
        for (int i = 0; i < r; i++) {
            int t;
            int n2; // pc
            int m2; // person
            int s;
            cin >> t >> n2 >> m2 >> s;
            if (s == 1) {
                if (pc[m2] == 0) {
                    start[m2] = t;
                }
                pc[m2]++;
            } else {
                pc[m2]--;
                if (pc[m2] == 0) {
                    int end = t;
                    time[m2].push_back(make_pair(start[m2], end));
                }
            }
        }

        int q;
        cin >> q;
        for (int i = 0; i < q; i++) {
            int s;
            int e;
            int m2;
            cin >> s >> e >> m2;
            int count = 0;

            for (int j = 0; j < (int)(time[m2].size()); j++) {
                int first = time[m2][j].first;
                int second = time[m2][j].second;
                int start;
                int end;
                if (s < first) {
                    start = first;
                } else if (s <= second) {
                    start = s;
                } else {
                    continue;
                }
                if (e < first) {
                    break;
                } else if (e <= second) {
                    end = e;
                } else {
                    end = second;
                }
                count += end - start;
            }
            cout << count << endl;
        }

    }
    return 0;
}

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

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

#define MOD 1000000007LL

#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;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
    ll c = 0;
    cout << "{ ";
    iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}

int main(void) {
    ll a, b;
    cin >> a >> b;
    ll temp = b - a;
    cout << temp * (temp + 1) / 2 - b << endl;
    return 0;
}


Measured memory_bytes: 3452
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);
  int N,X;
  cin>>N>>X;
  int m[N];
  FOR(i,0,N)cin>>m[i];
  sort(m,m+N);
  int ans=N;
  FOR(i,0,N)X-=m[i];
  ans+=X/m[0];
  cout<<ans<<endl;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef string str;
static const long long INF = 1LL<<59;
static const long long MOD = (ll)1e9+7;

#define endl "\n"
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
#define REP(i, n) for(ll i=0;i<n;i++)
#define SZ(v) (ll)((v).size())
#define WHOLE(v) (v).begin(), (v).end()
#define ASC(v) sort((v).begin(), (v).end())
#define DESC(v) sort((v).rbegin(), (v).rend())
#define INV(v) reverse((v).begin(), (v).end())
#define FOLDL(src, dst, lambda) partial_sum((src).begin(), (src).end(), (dst).begin(), lambda)
#define FOLDR(src, dst, lambda) INV(src);partial_sum((src).begin(), (src).end(), (dst).begin(), lambda);INV(dst)
#define CUMSUML(src, dst) FOLDL(src, dst, [](auto a, auto b) {return a+b;})
#define CUMSUMR(src, dst) FOLDR(src, dst, [](auto a, auto b) {return a+b;})
#define ACCUM(v, d0, lambda) accumulate((v).begin(), (v).end(), d0, lambda)
#define SUM(v, d0) ACCUM(v, d0, [](auto a, auto b) {return a+b;})
#define ERASE(v, i) v.erase(v.begin() + i)
#define UNIQ(v) ASC(v);v.erase(unique(v.begin(), v.end()), v.end())

template <typename T>void debug(T t) {cerr << t << endl;}
template <typename T, typename ...Args>void debug(T t, Args ...args) {cerr << t << " ";debug(args...);}
template <typename T>void out(T t) {cout << t << endl;}
template <typename T, typename ...Args>void out(T t, Args ...args) {cout << t << " ";out(args...);}

// 
class Graph {
    Graph(){}
public:
    ll N;
    vector<vector<ll> > mat;
    Graph(ll sz) {
        N = sz;
        mat.assign(sz, vector<ll>(sz));
        REP(i, N) {REP(j, N) {mat[i][j] = INF;} mat[i][i] = 0;}
    }
    void warshall_floyd() {
        REP(i,N)REP(j,N)REP(k,N)
            mat[j][k] = min(mat[j][k], mat[j][i]+mat[i][k]);
    }
};

void solve() {
    ll H, W;
    cin >> H >> W;
    Graph g(10);
    vll mincost(10);
    REP(y, 10)REP(x, 10) {
        ll p;
        cin >> p;
        g.mat[y][x] = p;
    }
    g.warshall_floyd();
    for(int i = 0;i<10;i++) {
        mincost[i] = g.mat[i][1];
    }
    ll ans = 0;
    REP(i, H*W) {
        ll p;
        cin >> p;
        ans += (p != -1 ? mincost[p] : 0);
    }
    out(ans);
}

int main() {
    fast_io;
    solve();
    return 0;
}

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

int main() {
  ll n;
  cin >> n;
  string tmp;
  set<string> s;
  rep(i, n) {
    cin >> tmp;
    s.insert(tmp);
  }
  cout << s.size() << endl;
  return 0;
}

Measured memory_bytes: 19228
//abc113_c.cpp
//Sat Nov 10 12:34:36 2018

#include <iostream>
#include <string>
#include <queue>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <math.h>
#define INTINF 2147483647
#define LLINF 9223372036854775807
using namespace std;
using ll=long long;
typedef pair<int,int> P;

int main(){
	int n,m;
	cin >> n >> m;

	int p[m],y[m];
	vector<int> pref[n+1];

	for (int i=0;i<m;i++){
		cin >> p[i] >> y[i];
		pref[p[i]].push_back(y[i]);
	}

	for (int i=0;i<n;i++){
		sort(pref[i+1].begin(),pref[i+1].end());
	}

	for (int i=0;i<m;i++){
		int iter = lower_bound(pref[p[i]].begin(),pref[p[i]].end(),y[i])-pref[p[i]].begin()+1;
		printf("%012lld\n",ll(p[i])*1000000+iter);
	}

//	printf("%.4f\n",ans);
}

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

int X;

int main() {
    cin >> X;

    int ans = 0;
    for (int i = 1; i <= X; i++) {
        ans += i;
        if (ans >= X) {
            cout << i << endl;
            break;
        }
    }

    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h> 
using namespace std;
 
typedef signed long long ll;
const int MX = 1e6 + 5;
vector<int> p;
int pr[MX];

void sieve() {
	for(int i = 3; i * i <= MX; i += 2) {
		if(!pr[i]) {
			for(int j = i * i; j < MX; pr[j] = 1, j += (i + i));
		}
	}

	p.push_back(2);
	for(int i = 3; i < MX; i += 2) {
		if(!pr[i])
			p.push_back(i);
	}
}
 
int main() {
	sieve();
	int x;
	cin >> x;
	int id = lower_bound(p.begin(), p.end(), x) - p.begin();
	cout << p[id] << endl;
    return 0;
}

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

int main()
{
  int n;
  cin >> n;

  vector<string> BubbleCard(n);

  for(int i = 0; i < n; i++) cin >> BubbleCard[i];

  vector<string> SelectCard = BubbleCard;

  for(int i = 0; i < n; i++){
    for(int j = n-1; j>=i+1; j--){
      if(BubbleCard[j][1] < BubbleCard[j-1][1]){
	string dummy;
	dummy = BubbleCard[j];
	BubbleCard[j] = BubbleCard[j-1];
	BubbleCard[j-1] = dummy;
      }
    }
  }

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

    for(int j = i; j < n; j++){
      if(SelectCard[j][1] < SelectCard[minj][1]) minj = j;
    }

    if(i != minj){
      string dummy;
      dummy = SelectCard[i];
      SelectCard[i] = SelectCard[minj];
      SelectCard[minj] = dummy;
    }
  }

  for(int i = 0; i < n; i++){
    if(i) cout << " ";
    cout << BubbleCard[i];
  }

  cout << endl;
  cout << "Stable" << endl;

  bool flag = true;
  
  for(int i = 0; i < n; i++){
    if(i) cout << " ";
    cout << SelectCard[i];
    if(SelectCard[i][0] != BubbleCard[i][0]) flag = false;
  }

  cout << endl;
  
  if(flag) cout << "Stable" << endl;
  else cout << "Not stable" << endl;

  return 0;

}



Measured memory_bytes: 3228
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0;i<((int)(n));i++)
#define reg(i,a,b) for(int i = ((int)(a));i<=((int)(b));i++)
#define irep(i,n) for(int i = ((int)(n)-1);i>=0;i--)
#define ireg(i,a,b) for(int i = ((int)(b));i>=((int)(a));i--)
typedef long long ll;

/*
*/

ll INF=1e18;
ll n,m,s,t;
ll d[3][200010];
vector<ll> v[100010];

void dfs(int root){
	queue<pair<ll,ll>> Q;
	rep(j,3)rep(i,n)d[j][i]=INF;
	d[0][root]=0;
	Q.push({root,0});
	while(!Q.empty()){
		pair<ll,ll> pf = Q.front();Q.pop();
		ll p=pf.first, state=pf.second;
		// cerr<<p<<endl;
		for(int i=0;i<v[p].size();i++){
			int q = v[p][i];
			if(d[(state+1)%3][q]>d[state][p]+1){
				d[(state+1)%3][q]=d[state][p]+1;
				Q.push({q,(state+1)%3});
			}
		}
	}
}

void init(){
	cin>>n>>m;
	rep(i,m){
		ll a,b;
		cin>>a>>b;
		a--;b--;
		v[a].push_back(b);
	}
	cin>>s>>t;
	s--;t--;
	dfs(s);
	// rep(j,3){
	// 	rep(i,n)cerr<<d[j][i]<<" ";
	// 	cerr<<endl;
	// }
}

int main(void){
	init();
	if(d[0][t]==INF){
		cout<<-1<<endl;
	}else{
		cout<<d[0][t]/3<<endl;
	}
	return 0;
}

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

#define ll long long int
#define llu unsigned long long int
#define f(n) for(ll i=0;i<n;i++)
#define fr(n) for(ll i=n-1;i>=0;i--)
#define endl "\n"
#define mod 1000000007

using namespace std;

int main()
{
	//#ifdef ONLINE_JUDGE
	//freopen("input.txt","r",stdin);
	//freopen("output.txt","w",stdout);
	//#endif
	std::ios_base::sync_with_stdio(false);

	string s;
	cin>>s;
	for(ll i=0;i<s.length();i++)
	{
		cout<<"x";
	}
	
	return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define per(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define all(x) (x).begin(), (x).end()
#define INF 2e9
#define LINF 1e18
typedef long long ll;
typedef pair<int, int> P;

int main() {
    int n, a, b; cin >> n >> a >> b;
    if (a*n < b) cout << a*n << endl;
    else cout << b << endl;
}

Measured memory_bytes: 256
class queue:
    def __init__(self,queue_size):
        self.size = queue_size
        self.queue = [None] * self.size
        self.head = 0
        self.tail = 0

    def isEmpty(self):
        return self.head == self.tail 
    
    def isFull(self):
        return self.head == (self.tail +1)%self.size

    def enqueue(self, x):
        self.queue[self.tail] = x
        if self.tail + 1 == self.size:
            self.tail = 0
        else:
            self.tail += 1

    def dequeue(self):
        x = self.queue[self.head]
        if self.head + 1 == self.size:
            self.head = 0
        else:
            self.head += 1

        return x

num = 100000
que = queue(num)
time = 0

n, q = map(int, input().split())
for i in range(n):
    p, t = input().split()
    que.enqueue([int(t),p])

while not que.isEmpty():
    pt = que.dequeue()
    if pt[0] > q:
        time += q
        pt[0] -= q
        que.enqueue(pt)
    
    else:
        time += pt[0]
        print(pt[1], time)


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

#define int long long 
const int mxN = 1e5+10;
int a[mxN], n, k;
int dp[mxN];

int jump(int i) {
    if(i == n-1) 
        return 0;

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

    int ans = 1e17;
    for(int j=i+1; j<=min(i+k, n-1); j++)
        ans = min(ans, jump(j) + abs(a[j]-a[i]));

    dp[i] = ans;
    return dp[i];
}

void solve() {
    cin >> n >> k;
    for(int i=0; i<n; i++)
        cin >> a[i];
    memset(dp, -1, sizeof(dp));
    cout << jump(0) << "\n";
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    solve();
}


Measured memory_bytes: 4992
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Input in = new Input(System.in);
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        int N = in.nextInt();
        int M = in.nextInt();
        long K = in.nextInt();
        int[] A = new int[N];
        for (int n = 0; n < N; n++)
            A[n] = in.nextInt();
        int[] B = new int[M];
        for (int m = 0; m < M; m++)
            B[m] = in.nextInt();

        long[] sumA = new long[N];
        sumA[0] = A[0];
        for (int n = 1; n < N; n++)
            sumA[n] = sumA[n - 1] + A[n];
        long[] sumB = new long[M];
        sumB[0] = B[0];
        for (int m = 1; m < M; m++)
            sumB[m] = sumB[m - 1] + B[m];
        int ans = M;
        while (sumB[ans - 1] > K) {
            ans--;
            if (ans == 0) break;
        }
        for (int ia = 0, ib = ans - 1; ia < N; ia++) {
            while (ib >= 0 && sumA[ia] + sumB[ib] > K) {
                ib--;
                if (ib == -1) break;
            }
            if (ib == -1) {
                if (sumA[ia] <= K)
                    ans = Math.max(ans, ia + 1);
            } else {
                ans = Math.max(ans, ia + 1 + ib + 1);
            }
        }
        out.println(ans);
        out.flush();
    }

    static class Input {
        private BufferedReader br;
        private String[] buff;
        private int index = 0;

        Input(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }
        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        String next() {
            while (buff == null || index >= buff.length) {
                buff = nextLine().split(" ");
                index = 0;
            }
            return buff[index++];
        }
        byte nextByte() {
            return Byte.parseByte(next());
        }
        short nextShort() {
            return Short.parseShort(next());
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        float nextFloat() {
            return Float.parseFloat(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        BigInteger nextBigInteger() {
            return new BigInteger(next());
        }
        BigDecimal nextBigDecimal() {
            return new BigDecimal(next());
        }
    }
}



Measured memory_bytes: 81544
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
  
int main()
{
  int N, K;
  cin >> N >> K;

  vector<double> p(N);
  REP(i, N){
    cin >> p[i];
    p[i]=(p[i]+1)/2;
  }
  double sum = 0;
  REP(i,K){
    sum+=p[i];
  }
  double MAX = sum;
  REP(i,N-K){
    sum -=p.at(i);
    sum +=p.at(i+K);
    MAX = max(MAX,sum);
  }

  cout << fixed << setprecision(10) << MAX << endl;
}

Measured memory_bytes: 1792
import sys
input = sys.stdin.readline

Q,H,S,D = map(int, input().split())

H = min(H, 2*Q)
S = min(S, 2*H)
D = min(D, 2*S)

N = int(input())
answer = 0

if N&1:
  answer += S

answer += (N//2)*D
print(answer)

Measured memory_bytes: 3064
#include <bits/stdc++.h>
#define BIT(n) (1LL << (n))
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPB(i, n) for (int i = 0; i < BIT(n); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORA(i, n) for (auto &&i : n)
#define FORS(i, m, n) for (int i = m; i <= n; i++)
#define DEBUG(x) cerr << #x << ": " << x << "\n"
#define PRINTALL(V)    \
  for (auto v : (V)) { \
    cerr << v << " ";  \
  }                    \
  cerr << "\n";
#define ALL(v) v.begin(), v.end()
#define fst first
#define snd second
#define mp make_pair
#define pb push_back
#define epb emplace_back
#define int long long
using namespace std;
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 (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> using vec = std::vector<T>;
template <class T> void print(const T &x) { cout << x << "\n"; }
const int MOD = 1000000007, INF = 1061109567;
const double EPS = 1e-10, PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
#define MAXN 110
int a[2][MAXN];
int aS[2][MAXN];
signed main() {
  cin.tie(0), ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  int N;
  cin >> N;
  REP(i, 2) REP(j, N) cin >> a[i][j];
  REP(j, N) aS[0][j + 1] = aS[0][j] + a[0][j];
  REP(j, N) aS[1][j + 1] = aS[1][j] + a[1][N - 1 - j];
  int maxV = 0;
  REP(i, N) { chmax(maxV, aS[0][i + 1] + aS[1][N + 1 - (i + 1)]); }
  print(maxV);
}

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


int main()
{
    string x;
    int sum;

    do{
        cin>>x;
        sum=0;
        for(int i=0;i<x.size();i++){
            sum+=(int)(x.at(i)-'0');
        }

        if(x!="0")
           cout<<sum<<endl;
    }while(x!="0");

    return 0;
}  


Measured memory_bytes: 3164