akhauriyash/Code-Regression huggingface dataset:
#include <stdio.h>

#define MAX 1000

int A[MAX];

int main(void) {
  int n, q, b, e, tmp, j, i=0;

  scanf("%d", &n);
  while(i<n) scanf("%d", &A[i++]);
  scanf("%d", &q);

  while(q--) {
    j=0;
    scanf("%d %d", &b, &e);
    for(i=b; i<(b+e)/2; ++i) {
      tmp = A[i];
      A[i] = A[e-1-j];
      A[e-1-j] = tmp;
      ++j;
    }
  }

  for(i=0; i<n; ++i) {
    if(i != n-1) printf("%d ", A[i]);
    else printf("%d\n", A[i]);
  }

  return 0;
}



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

int main(){
	int n,ans = 0;
	int h[25];
	cin >> n;
	for(int i = 1;i<=n;i++){
		cin >> h[i];
	}
	
	int largest = 0;
	for(int i = 1;i<=n;i++){
		if(h[i]>=largest){largest = h[i]; ans++;}
	}
	cout <<ans << endl;
return 0;
}

Measured memory_bytes: 256
"use strict";
function main(input) {
    var line = input.split("\n");
    let digits = line[0];
    if(digits[0]=== "7" || digits[1] === "7" || digits[2] === "7") console.log("Yes");
    else console.log("No");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));

Measured memory_bytes: 30100
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
//#define _0219nice 
using namespace std;

bool ispalindrome(string& s) {
    int n = s.size();
    for (int i = 0, j = n - 1; i < j; i++, j--) {
        if (s[i] != s[j]) {
            return false;
        }
    }
    return true;
}

int main() {
#ifdef _0219nice
    freopen("1.in", "r", stdin);
#endif
    string s;
    while (cin >> s) {
        int n = s.size();
        if (n % 2 == 0) {
            cout << "No" << endl;
            continue;
        }
        string left = s.substr(0, (n - 1) / 2);
        string right = s.substr((n + 3) / 2 - 1);
        bool ok = ispalindrome(s) && ispalindrome(left) && ispalindrome(right);
        cout << (ok ? "Yes" : "No") << endl;
    }
    return 0;
}


Measured memory_bytes: 256
#include <iostream>

using namespace std;

int main(){
	int a, b, c, result = 0;
	cin >> a >> b >> c;
	if(a > b){
		if(c <= a && c >= b) result = 1;
	}
	else{
		if(c >= a && c <= b) result = 1;
	}
	cout << ((result == 1) ? "Yes" : "No") << endl;
	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <map>
#include <cstring>
using namespace std;

int c = 0;

map<string,int> pos;

string x[100],y[100];

int dp[110][110] = {};
int N;
int dfs(int x,int t){
	if( t == 105 ) return 1e9;
	if( x == N ) return 0;
	if( dp[x][t] != -1 ) return dp[x][t];
	int ans = dfs(x+1,t+1) + (::x[x]=="goto");
	if( ::x[x]=="goto") ans=min(ans,dfs(pos[y[x]],t+1));
	return dp[x][t] = ans;
}
int main(){
	memset(dp,-1,sizeof(dp));
	cin >> N;
	for(int i = 0; i < N; i++){
		string a,b;
		cin >> a;
		if( a == "goto" ) cin >> b , b = b.substr(0,b.size()-1);
		else pos[a.substr(0,a.size()-1)] = i;
		x[i] = a;
		y[i] = b;
	}
	cout << dfs(0,0) << endl;
	
	
}

Measured memory_bytes: 1300
#include<iostream>
using namespace std;
 
int main(){
	long long N, K;
	cin>>N>>K;
	long long cnt1=0, cnt2=0;
	cnt1 = N/K;
	if (K % 2 == 0){
		cnt2 = N / K;
                if (N % K >= (K / 2)) cnt2++;
}
	cout<<cnt1*cnt1*cnt1 + cnt2*cnt2*cnt2<< endl;
	return 0;
}

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

int main()
{
  int x, a, b, r;
  cin >> x >> a >> b;
  r = b - a;
  if (r <= 0)
    cout << "delicious" << endl;
  else if(r <= x)
    cout << "safe" << endl;
  else
    cout << "dangerous" << endl;
  return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
using namespace std;

int32_t main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n;
    cin >> n;
    vector<int> a(n);
    for(int i = 0; i < n; ++i) cin >> a[i];
    int ans = 0;
    sort(all(a));
    for(int i = 2; i < n; ++i) {
        for(int j = 1; j < i; ++j) {
            auto k = upper_bound(a.begin(), a.begin() + j, a[i] - a[j]) - a.begin();
            ans += j - k; 
        }
    }
    cout << ans << '\n';
}


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

using ll= unsigned long long;
#define double long double
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define _set(x) __builtin_popcount(x)
#define _setl(x) __builtin_popcountll(x)
#define PI  3.14159265358979323846264338327950L
#define mod 1000000007LL

void debug(){
	cerr<<"]\n";
}
template<class H,class ... T> void debug(H h,T... t){
	cerr<<h;
	if(sizeof... (t)){
		cerr<<", ";
	}
	debug(t...);
}
#ifdef DEBUG
	#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", debug(__VA_ARGS__)
	#define dpv(...) cerr<< "["#__VA_ARGS__ " : ";for(int i: (__VA_ARGS__)){cerr<<i<<" ";}cerr<<"]\n"
#else
	#define dbg(...) 0
	#define dpv(...) 0
#endif


void solve(){
	ll n,q;
	cin>>n>>q;
	vector<ll> a1(n+1),a2(n+1);
	ll h= n,w =n;
	ll ans = 0;
	while(q--){
		ll x,y;
		cin>>x>>y;
		if(x==1){
			if(y< w){
				ans += h-2;
				for(int i=y;i<w;i++){
					a1[i]= h;
				}
				w=y;
			}else{
				ans += a1[y]-2;
			}
			a1[y]=2;
		}else{
			x=y,y=1;
			if(x< h){
				ans += w-2;
				for(int i=x;i<h;i++){
					a2[i]= w;
				}
				h= x;
			}else{
				ans += a2[x]-2;
			}
			a2[x]=2;
		}
	}
	cout<<(n-2)*(n-2)-ans<<"\n";
}


int32_t main(){
	IOS
	// freopen("input.txt","r",stdin);
	int _;
	// cin>>_;
	_=1;
	for(int i=1;i<=_;i++){
		// cout<<"Case #"<<i<<": ";
		solve();
	}
	return 0;
}

/*
   check for overflows int long long
   correct mize of array
*/


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

int main() {
	// your code goes here
  	int n;
  	cin>>n;
  	string s;
  	cin>>s;
  	int r=0,b=0;
  	for(int i=0;i<s.size();i++){
    	if(s[i]=='B')
          	b++;
      	if(s[i]=='R')
          	r++;
    }
  	if(r>b)
    	cout<<"Yes";
  	else
      	cout<<"No";
	return 0;
}

Measured memory_bytes: 256
package main

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

var sc = bufio.NewScanner(os.Stdin)

func Scanner() string {
	sc.Scan()
	return sc.Text()
}

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

var mod int

func main() {
	mod = 1000000007
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	k := intScanner()
	s := Scanner()
	if len(s) <= k {
		fmt.Println(s)
	} else {
		fmt.Print(s[:k])
		fmt.Println("...")
	}
}


Measured memory_bytes: 1752
#include <bits/stdc++.h>
 
#define f(i,a,b) for( ll i = a; i < (ll) b ; i++ ) 
#define af(i,a,b) for( ll i = a; i >= (ll) b ; i--)
#define rep(i,a,b,k) for(ll i = a; i < b ; i+= k )
#define arep(i,a,b,k) for( ll i = a; i >= b ; i-= k)
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define sz(a) (ll) a.size()
#define all(a) a.begin(), a.end()
#define sor(a) sort( a.begin(), a.end() )
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL)
#define inter ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr)
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> ii ;
typedef vector<ll>  vi ;
typedef vector<ii> vii ;
 
const int MAX= 1e6+100;


int main(){
	fastio;
	ll tc,n,m;
	cin>>n>>m;
	if(n>m) cout<<"safe\n";
	else cout<<"unsafe\n";

	return 0;
}

Measured memory_bytes: 3652
#define _USE_MATH_DEFINES
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#include <deque>
#include <climits>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
//#include <tuple>

#define INF INT_MAX>>1 
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for(int i=0; i<(int)(n); i++)
#define rep2(i, from, to) for(int i=(from); i<(int)(to); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define LLPair pair<ll, ll>
#define vint vector<int>
#define vll vector<ll>
typedef long long ll;

using namespace std;


int main(void){
	int a, b; cin >> a >> b;
	b*=2;
	cout << max(0, a-b) << endl;
	return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
const int INF = 2147483647;//int max
const int MOD = 1000000007;
using namespace std;
using ll = long long;
using P = pair<int,int>;


int main() {
    int a,b;
    cin >> a >> b;
    cout << max({a+b,a-b,a*b})  << endl;
    return 0;
}

/*
やっほい！
　　　　　　　やほほい！
　　　　+　　 　*
　　　 ∧∧　　. ∧∞∧　*
*　ヽ(=´ω｀)人(´ω｀*)ﾉ
　.～（ O x.） （ 　 O)～　+
。*　 　∪　　　　∪
*/

Measured memory_bytes: 256
#include <iostream>
#include <algorithm>
#include <map>
#include <string>
using namespace std;

int main() {
  map<string, int> si;
  int n; cin >> n;
  string s[n];
  for(int i = 0; i < n; i++) {
    cin >> s[i];
    si[s[i]]++;
  }
  int m; cin >> m;
  string t[m];
  for(int i = 0; i < m; i++) {
    cin >> t[i];
    si[t[i]]--;
  }
  //--- maxv = si[s[i]] だと、青も赤も同じ言葉しか書いていない場合で負になることがある ---//
  int maxv = 0;
  for(int i = 0; i < n; i++) maxv = max(maxv, si[s[i]]);
  cout << maxv << endl;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>

using namespace std;
using namespace boost;
using namespace boost::adaptors;

int main() {
    int64_t n, x, y;
    cin >> n >> x >> y;
    --x;
    --y;

    vector<int64_t> ans(n);
    for (auto i : irange(0L, n)) {
        for (auto j : irange(i + 1, n)) {
            int64_t k = min({j - i, abs(i - x) + abs(j - y) + 1,
                             abs(i - y) + abs(j - x) + 1});
            ++ans[k];
        }
    }

    for (auto i : irange(1L, n)) {
        cout << ans[i] << endl;
    }
}

Measured memory_bytes: 256
n=int(input())
s=list(map(int,input().split()))
max=1
for i in range(n):
    if s[i]==1:
        count=2
        for j in range(i+1,n):
            if s[j]==1:
                count+=1
                continue
            else:
                break
        if count>max:
            max=count
print(max)

                
    


Measured memory_bytes: 5596
N, M = map(int, input().split())
g = [[False]*N for _ in range(N)]
for _ in range(M):
	a, b = map(int, input().split())
	g[a-1][b-1] = True
	g[b-1][a-1] = True

stack = [[0,[1]+[0]*(N-1)]]
ans = 0
while stack:
	cur, passed = stack.pop()
	if passed == [1]*N:
		ans += 1
	else:
		for i, j in enumerate(g[cur]):
			if j and not passed[i]:
				t = passed.copy()
				t[i] = 1
				stack.append([i, t])
print(ans)

Measured memory_bytes: 3064
import itertools
# 入力もらう
D,G = list(map(int,input().split()))
PC = []
for i in range(D):
    PC.append(list(map(int,input().split())))

#[0,0,0,0,0,0,0,0,0,0]という形で、どのボーナスをもらうかを管理したい
#例えば[1,0,0,0,1,0,0,0,0,0]は100点問題と500点問題のボーナスをもらうということ
#2^D通り(D<=10)だから全探索できる(もちろん全部0というのはありえないけど)
#itertools使って2^D通りのケースを用意
a = [0,1]
Ls = list(itertools.product(a, repeat=D))

#pは100以下、Dは10以下だから解く問題数は多くて1000
#最大値を初期値として設定して、小さい値が実現できたら更新していく
out = 1000

#戦略としては、「ボーナスをもらう問題」を先に決めて計算し、
#その後「中途半端に解く問題」を合計得点がGに足るまで計算する、というもの。

for L in Ls: #どの問題でボーナスをもらうか、2^D通りのシナリオを逐一チェック
    #Lには「ボーナスをもらう問題」をどれにするか決めた結果が格納されている
    num = 0 #このシナリオにおける解いた問題の数
    point = 0 #このシナリオにおける得点

    #このシナリオにおいて「ボーナスをもらう問題」をまずは計算
    for i in range(D):
        if L[i]==1: #ボーナスをもらう問題では
            num+=PC[i][0] #解いた問題の数にプラス
            point+=PC[i][1] #特典もプラス
            point+=(i+1)*100*PC[i][0] #ボーナスもプラス

    #ここから、「中途半端に解く問題」の計算を行う
    #1問あたりの得点が高い方を選んだ方が得。D*100点問題から埋めていく。
    #ただしその問題でボーナスをもらっていた場合はすでに計算に入れているので、スキップする必要がある
    #さらに、重要なこととして、「ボーナスをもらわない問題」は1種類で十分である
    #なぜなら、「ボーナスをもらわない問題」を2問作るくらいなら、その2問のうち1問あたりの得点が高い方に集中させた方がいいからである。

    #「中途半端に解く問題」をどれにするか決めて、そのインデックスをhampaに格納する
    hampa = D-1 #D*100点問題
    while (L[hampa]==1)and(hampa>=0): #もし「ボーナスをもらう問題」に入れていたら
        hampa+=-1 #次に得点が高い問題を候補とする
        #ただし、[1,1,1,1,1,1,1,1,1,1]の時はそもそも「中途半端に解く問題」は作らない
        #hampaが負になったら抜ける、という方法でそれを実装している

    if hampa==-1: #先述のように、hampaが負の時は「中途半端に解く問題」は作らない
        cnt = 0
    else:
        cnt = 0 #「中途半端に解く問題」を解いた数を格納
        #「中途半端に解く問題」を解き進める条件は「今まだ得点がGに達していないこと」及び「あと一問解いてもまだ中途半端であること」
        while (point<G)and(cnt<PC[hampa][0]):
            cnt+=1
            num+=1
            point+=(hampa+1)*100

    #以上でこのシナリオにおける計算はおしまい、
    #「中途半端に解く問題」が1種類ではGに届いていないケースもある。
    #その場合はこの時点でpointはG未満であり、outの候補としては不適切。除くことが必要。
    if (point>=G)and(num<out): #問題数の最小値を更新したら、outに格納
        out=num
print(out)

Measured memory_bytes: 40944
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0, i##_len=(n); i<i##_len; ++i)
#define REPR(i,n) for(ll i = n;i >= 0;--i)
#define FOR(i,m,n) for(ll i = m, i##_len=(n);i <i##_len; ++i)
#define all(x) (x).begin(),(x).end()
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; }
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
const int INF = 1e9;
const ll LLINF = 1e16;
 
ll modinv(ll a, ll m) {
    ll b = m, u = 1, v = 0;
    while (b) {
        ll t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}

int main(void)
{
    int a, b, c, d, e, f;
    cin >> a >> b >> c >> d >> e >> f;
    int answ = 0;
    int anss = 0;
    for (int aw = 0; aw <= f; aw += 100 * a)
    {
        for (int bw = 0; aw + bw <= f; bw += 100*b){
            for (int cw = 0; cw <= (aw + bw)/100 * e;cw += c){
                for (int dw = 0;cw + dw <= (aw + bw)/100 * e;dw += d){
                    if(cw + dw + aw + bw == 0 || cw + dw + aw + bw > f){
                        continue;
                    }
                    if((cw + dw) * (answ + anss) >= (anss) * (cw + dw + aw + bw)){
                        answ = aw + bw;
                        anss = cw + dw;
                    }
                }
            }
        }
    }

    cout << answ + anss << " " << anss << endl;

    return 0;
}

Measured memory_bytes: 256
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl

using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
template<class T> using vv=vector<vector<T>>;
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"{"; rep(i,t.size()) {os<<t[i]<<",";} os<<"}"<<endl; return os;}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
#define out(args...){vector<string> a_r_g_s=s_p_l_i_t(#args, ','); e_r_r(a_r_g_s.begin(), args); }
vector<string> s_p_l_i_t(const string& s, char c) { vector<string> v; stringstream ss(s); string x; while(getline(ss,x,c)) v.emplace_back(x); return move(v);}
void e_r_r(vector<string>::iterator it) {}
template<typename T, typename... Args> void e_r_r(vector<string>::iterator it, T a, Args... args){ if(*it==" 1"||*it=="1") cerr<<endl; else cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; e_r_r(++it, args...);}
const ll MOD=1e9+7;

int main(){
  ios_base::sync_with_stdio(false);
  cout<<fixed<<setprecision(0);
  ll n,m;
  cin>>n>>m;
  ll l=0,r=n+m;
  while(r-l>1){
    ll med=(l+r)/2;
    ll x=max(0ll,med-n);
    if(m>=(med+x)*2) l=med;
    else r=med;
  }
  cout<<l<<endl;
  return 0;
}


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

int main() {
  int N;
  cin >> N;
  vector<int> A(N + 1);
  for (int i = 0; i < N + 1; i++) cin >> A.at(i);
  vector<int> B(N);
  for (int i = 0; i < N; i++) cin >> B.at(i);

  long long ans = 0;

  for (int i = 0; i < N; i++) {
    int X = min (A.at(i), B.at(i));
    A.at(i) -= X;
    B.at(i) -= X;
    ans += X;
    if (B.at(i) > 0) {
      int Y = min (B.at(i), A.at(i + 1));
      B.at(i) -= Y;
      A.at(i + 1) -= Y;
      ans += Y;
    }
  }
  cout << ans << endl;
}

Measured memory_bytes: 1024
# include <iostream>


int main(){
 int a,b,c;
 std::cin >> a >> b >> c;
 if( a < b){
  if( b < c) 
   std::cout << "Yes" << std::endl;  
  else
   std::cout << "No" << std::endl;
 }
else
 std::cout << "No" << std::endl;

 return 0;
}

Measured memory_bytes: 1156
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define PI acos(-1)
typedef  long long ll;
ll gcd(ll x,ll y){
   if(y==0) return x;
   else return gcd(y,x%y);
}
ll lcm(ll x,ll y){
   return x/gcd(x,y)*y;
}

int main(){
   ll x,y;
   cin>>x>>y;
   int ans=0;
   while(1){
      ll z=pow(2,ans)*x;
      if(z>y){
         break;
      }
      ans++;
   }
   cout<<ans;
   return 0;
}


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

typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, a, b) for(ll i = a; i < b; i++)
#define out(x) std::cout << x << '\n'
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define sz(x) ((int)(x).size())
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { ll g = gcd(a, b); return a / g * b; }
const int dx[4] = { 1, 0, -1,  0 };
const int dy[4] = { 0, 1,  0, -1 };
const int INF = INT_MAX / 2;
const ll  inf = LLONG_MAX / 2;
const int mod = 1000000007;
const int MAX_N = 101010;
const long double PI = acos(-1);

std::map<ll, ll> prime_factor(ll n) {
	std::map<ll, ll> res;
	for (ll i = 2; i * i <= n; i++) {
		while (n % i == 0) {
			++res[i];
			n /= i;
		}
	}
	if (n != 1) res[n] = 1;
	return res;
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout << fixed << setprecision(10);
	/*------------------------------*/

	ll n;
	cin >> n;
	
	auto pf = prime_factor(n);
	ll ans = 0;

	for (auto p : pf) {
		ll e = p.second;
		ll tmp = 0, cur = 1;
		while (e >= cur) {
			e -= cur++;
			tmp++;
		}
		ans += tmp;
	}

	out(ans);

	return 0;
}

Measured memory_bytes: 3664
//khodaya khodet komak kon
#include <bits/stdc++.h>

#define F first
#define S second
#define pb push_back
#define all(x) x.begin(), x.end()
#pragma GCC optimise ("ofast")
#pragma GCC optimise("unroll-loops")

using namespace std;

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

const int N = 200000 + 10;
const ll MOD = 1000000000 + 7;
const ll INF = 1000000000000000000;
const ll LOG = 25;

int n, a[N];

int32_t main(){
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	cin >> n;
	int ans = 0;
	for (int i = 1; i <= n; i++) {cin >> a[i]; ans += abs(a[i] - a[i - 1]);}
  	ans += abs(a[n]);
	for (int i = 1; i <= n; i++){
		ll res = ans;
		res -= abs(a[i] - a[i - 1]) + abs(a[i + 1] - a[i]);
		res += abs(a[i - 1] - a[i + 1]);
		cout << res << '\n';
	}










	return 0;
}


Measured memory_bytes: 1664
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
//　ceil(a/b)   (a + (b - 1))/ b
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const int mod=1000000007;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};

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


// ll memo[2020][2020];
// int pascal_triangle(){
//   for(int i = 0; i < 2020; i++){
//     for(int j = 0; j < i+1; j++){
//       if(j == 0 || j == i) memo[i][j] = 1;
//       else{
// 	memo[i][j] = (memo[i-1][j-1]+memo[i-1][j]);
//       }
//     }
//   }
//   return 0;
// }


// int factrial(int n){
//   if(n == 0) return 1;
//   return n*factrial(n-1);
// }

// int divisor(int a){
//   int cnt = 0;
//   for(int i=1; i <= a; i++) if(a%i == 0) cnt++;
//   return cnt;
// }

// int comb(int n, int k){
//   return fact(n) / (fact(n-k)*fact(k));
// }

int answer(bool f){
  if(f) cout << "Yes" << endl;
  else cout << "No" << endl;
  return 0;
}

ll b[200010];
int main(){
  int N,K;
  cin >> N >> K;
  int a[N];
  int id;
  rep(i,N){
    cin >> a[i];
  }
  int ans = 1;
  N -= K;
  ans += (N+(K-2))/(K-1);
  
  cout << ans << endl;
}
  





Measured memory_bytes: 640
import std;

ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "number", long, "cost");
alias PQueue(T, alias less = "a>b") = BinaryHeap!(Array!T, less);

void main()
{
    auto n = lread();
    auto t = new long[][](n, n);
    foreach (ref e; t)
        e = aryread();

    bool check = true;
    long s;
    WF: foreach (k; iota(n))
    {
        foreach (i; iota(n))
        {
            foreach (j; iota(n))
            {
                if (t[i][j] > t[i][k] + t[k][j])
                {
                    check = false;
                    break WF;
                }
            }
        }
    }

    foreach (i; iota(n))
    {
        foreach (j; iota(i + 1, n))
        {
            bool direct = true;
            foreach (k; iota(n))
            {
                if (i != k && j != k && t[i][j] >= t[i][k] + t[k][j])
                {
                    direct = false;
                }
            }
            if(direct)
            {
                s += t[i][j];
            }
        }
    }


    if (check)
        writeln(s);
    else
        writeln(-1);
}

void scan(TList...)(ref TList Args)
{
    auto line = readln.split();
    foreach (i, T; TList)
    {
        T val = line[i].to!(T);
        Args[i] = val;
    }
}


Measured memory_bytes: 8516
#include<bits/stdc++.h>
using namespace std;
int main(){
int fv = 0, svn = 0;
  vector<int> a(3);
  for(int i = 0; i < 3; i++)
	cin >> a[i];
  for(int i = 0; i < 3; i++){
  if(a[i] == 5)
    fv++;
    else if(a[i] == 7)
      svn++;
    else {}
  }
  if(fv == 2 && svn == 1)
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
}


Measured memory_bytes: 256
#include<bits/stdc++.h>
using namespace std;
long long n,a[100005],b[100005];
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        if(i&1) b[1]+=a[i];
        else b[1]-=a[i];
    }
    for(int i=2;i<=n;i++)
        b[i]=2*a[i-1]-b[i-1];
    for(int i=1;i<=n;i++){
        if(i==1) cout<<b[i];
        else cout<<" "<<b[i];
    }
	return 0;
}

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

int main() {
  int a,b,c,d;
  cin >> a >> b >> c >> d;
  if (a + b < c + d){
    cout << "Right" << endl;
  }else if (a + b == c + d){
    cout << "Balanced" << endl;
  }else {
    cout << "Left" << endl;}
}


Measured memory_bytes: 256
#include<set>
#include<iostream>
#include<ctime>
#include<string>
#include<cstdlib>
#include<algorithm>
#include<random>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<vector>
#include<list>
#include<queue>
#include<stack>
#include<functional>
#include<string.h>
#include<limits.h>
using namespace std;

string b[7] = {
	"thu","fri","sat","sun","mon","tue","wed"
};
signed main() {
	int a; cin >> a;
	cout << b[a % 7] << endl;
}

Measured memory_bytes: 3160
import java.util.*;

// ABC 79-D
// https://beta.atcoder.jp/contests/abc079/tasks/abc079_d

public class Main {

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

		int N = in.nextInt();
		int A = in.nextInt();
		int B = in.nextInt();
		System.out.println(Math.min(N * A, B));
	}
}


Measured memory_bytes: 22996
import java.util.*;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int ans = 0;
        boolean[] ok = new boolean[x+1];
        ok[1] = true;
        for(int i = 2;i <= x;i++){
            int v = i*i;
            while(v<=x){
                ok[v] = true;
                v *= i;
            }
        }

        for(int i = x;i >= 1;i--){
            if(ok[i]){
                System.out.println(i);
                break;
            }
        }
    }
}

Measured memory_bytes: 21844
//長くなりそうなので保留
//ダイクストラみたいな感じでやるといいかも


#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<utility>
using namespace std;


int main(){
  int N;
  cin >> N;
  int X,Y;
  int vl;
  for(int i=0;i<N;i++){
    cin >> X >> Y;
    cin >> vl;
    vector<vector<int>> v1(vl,vector<int>(4,0));
    queue<vector<int>> q2;
    vector<vector<int>> va(X+1,vector<int>(Y+1,0));
    for(int j=0;j<vl;j++){
      int a,b,c,d;
      cin >> a >> b >> c >> d;
      if((a+b)<(c+d)){
        v1[j][0]=a;v1[j][1]=b;v1[j][2]=c;v1[j][3]=d;
      }else{
        v1[j][0]=c;v1[j][1]=d;v1[j][2]=a;v1[j][3]=b;
      }
    }
    sort(v1.begin(),v1.end());
    for(int j=0;j<vl;j++){q2.push(v1[j]);}

    //数え上げ
    for(int j=0;j<X+1;j++){
      for(int k=0;k<Y+1;k++){
        if(j==0 && k==0){va[0][0]=1;}
        vector<pair<int,int>> v;
        if(k<Y){v.push_back(make_pair(j,k+1));}
        if(j<X){v.push_back(make_pair(j+1,k));}
        for(int l=0;l<v.size();l++){
          if(q2.size()!=0){
            if(q2.front()[0]==j && q2.front()[1]==k && q2.front()[2]==v[l].first && q2.front()[3]==v[l].second){
              q2.pop();
            }else{
              va[v[l].first][v[l].second]+=va[j][k];
            }
          }else{
            va[v[l].first][v[l].second]+=va[j][k];
          }
        }
      }
    }
    if(va[X][Y]==0){
      cout << "Miserable Hokusai!" << endl;
    }else{
      cout << va[X][Y] << endl;
    }




  }
}



Measured memory_bytes: 3024
#include "bits/stdc++.h"
#define ll long long
#define rep2(i,a,b) for(int i=(a);i<=(b);++i)
#define rep(i,n) for(int i=0;i<n;i++)
#define pii pair<int,int>
#define ti3 tuple<int,int,int>
ll int MOD=998244353;
#define N 110000
 
using namespace std;
string alphabet("abcdefghijklmnopqrstuvwxyz");

main(){
    ll int n,m,a[N],count[N]={};
    cin>>n>>m;
    rep(i,n) cin>>a[i];
    ll int temp=0;
    rep(i,n-1){
        if(a[i]>a[i+1]) temp+=a[i+1];
        else temp+=-a[i]+a[i+1];
    }
    rep2(i,1,n-1){
        count[a[i]]+=(m+a[i]-a[i-1])%m;
    }
    ll int r[N]={};
    rep(i,n-1){
        if(a[i]>a[i+1]){
            r[a[i]+1]++;
            r[0]++;
            r[a[i+1]+1]--;
        }
        else{
            r[a[i]+1]++; r[a[i+1]+1]--;
        }
    }
    rep2(i,1,m){
        r[i]=r[i]+r[i-1];
    }
    rep2(i,1,m){
        r[i]=count[i]-r[i];
    }
    ll int ans=temp;
    rep2(i,1,m-1){
        temp+=r[i];
        ans=min(ans,temp);
    }
    cout<<ans;
    return 0;
}

Measured memory_bytes: 2816
module DoublyChainedTree = struct
  let nil = -1

  type t = {
    mutable parent : int;
    mutable child : int;
    mutable bro : int;
    mutable depth : int;
  }

  let make () = { parent = nil; child = nil; bro = nil; depth = nil }
end

module T = DoublyChainedTree

let () =
  let n = Scanf.scanf "%d " (fun i -> i) in
  let t = Array.init n (fun _ -> T.make ()) in
  Array.iteri (fun i _ ->
    let id, k = Scanf.scanf "%d %d " (fun id k -> id, k) in
    let rec read_node j left_child =
      if j < k then begin
        let c = Scanf.scanf "%d " (fun c -> c) in
        t.(c).T.parent <- id;
        if j = 0 then t.(id).T.child <- c else t.(left_child).T.bro <- c;
        read_node (j + 1) c
      end
    in
    read_node 0 0
  ) t;
  let rec search_root i =
    if i = n then T.nil
    else if t.(i).T.parent = T.nil then i
    else search_root (i + 1)
  in
  let root = search_root 0 in
  let rec set_depth i d =
    t.(i).T.depth <- d;
    if t.(i).T.bro <> T.nil then set_depth t.(i).T.bro d;
    if t.(i).T.child <> T.nil then set_depth t.(i).T.child (d + 1);
  in
  set_depth root 0;
  let print_node i =
    print_string "node "; print_int i;
    print_string ": parent = "; print_int t.(i).T.parent;
    print_string ", depth = "; print_int t.(i).T.depth;
    print_string (if t.(i).T.parent = T.nil then ", root, " else if t.(i).T.child = T.nil then ", leaf, " else ", internal node, ");
    print_string "[";
    let rec print_children c =
      if c <> T.nil then begin
        if c <> t.(i).T.child then print_string ", ";
        print_int c;
        print_children t.(c).T.bro
      end
    in
    print_children t.(i).T.child;
    print_endline "]"
  in
  let rec print i =
    if i < n then (print_node i; print (i + 1))
  in
  print 0

Measured memory_bytes: 13224
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <vector>
#include <sstream>
#include <set>
using namespace std;
using ll = long long;

class range {private: struct I{int x;int operator*(){return x;}bool operator!=(I& lhs){return x<lhs.x;}void operator++(){++x;}};I i,n;
public:range(int n):i({0}),n({n}){}range(int i,int n):i({i}),n({n}){}I& begin(){return i;}I& end(){return n;}};

int main() {
  ll A, B, C;
  while (cin >> A >> B >> C) {
    ll cand = 1LL << 60;
    cand = min(cand, abs(A / 2 - (A - A / 2)) * B * C);
    cand = min(cand, abs(B / 2 - (B - B / 2)) * C * A);
    cand = min(cand, abs(C / 2 - (C - C / 2)) * A * B);
    cout << cand << endl;
  }
}


Measured memory_bytes: 764
#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 ALL(a)     (a).begin(),(a).end()
#define MOD 1000000007

typedef long long int ll;

const ll INF=(ll)1e18;
//const int INF=(1<<30);


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

  vector<vector<int>> A(N,vector<int>(N));

  REP(i,N)REP(j,N){
    cin >> A[i][j];
  }

  vector<vector<bool>> e(N,vector<bool>(N,true));

  ll ans=0;
  REP(k,N)REP(i,N)REP(j,N){
    if(A[i][j] > A[i][k] + A[k][j]){
      cout << -1 << endl;
      exit(0);
    }

    if(A[i][j] == A[i][k] + A[k][j] && i != k && j != k){
      e[i][j] = false;
    }
  }

  REP(i,N)REP(j,N){
//    cout << i << " " << j << " " << e[i][j] << endl;
    if(i==j)continue;
    if(e[i][j])ans+=A[i][j];
  }


  cout << ans/2 << endl;
}




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

int main() {
  static const double PI = 3.141592653589793;
  int a, b, h, m;
  cin >> a >> b >> h >> m;

  cout << std::fixed << std::setprecision(20) << sqrt(a*a + b*b - 2*a*b*cos(2*PI*abs((double)(h*60+m)/(12*60) - (double)m/60))) << endl;

  return 0;
}

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

int n;
int main(){
    cin>>n;
    n = n%1000;
    if(n!=0)cout<<1000-n;
    else cout<<n;

    return 0;
}

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

void turn(int &a, int &b){
  int tmp=a; a=b; b=7-tmp;
}

int main(){
  int n, sum;
  string s;
  int top, front, right, tmp;
  while( cin>>n && n ){
    sum=1;
    top=1; front=2; right=3;
    while( n-- ){
      cin >> s;
      switch( s[0] ){
      case 'N': turn( top, front ); break;
      case 'S': turn( front, top ); break;
      case 'W': turn( top, right ); break;
      case 'E': turn( right, top ); break;
      case 'R': turn( front, right ); break;
      case 'L': turn( right, front ); break;
      }
      sum += top;
    }
    cout << sum << endl;
  }
  return 0;
}

Measured memory_bytes: 1200
#include <bits/stdc++.h>
#define loop2(i, s, n, a) for (int i = int(s); i < int(n); i += a)
#define loop(i, s, n) loop2(i, s, n, 1)
#define rep(i, n) loop(i, 0, n)

#define pb push_back
#define all(in) in.begin(),in.end()

using ll = long long;
using ull = unsigned long long;
using namespace std;


int main(){
    int n, m, q; cin >> n >> m >> q;
    vector<vector<int>> map(n+1,vector<int>(n+1,0));
    rep(i,m){
        int l, r; cin >> l >> r;
        map[l][r]++;
    }
    rep(i,n) rep(j,n+1) map[i+1][j] += map[i][j];
    rep(i,n) rep(j,n+1) map[j][i+1] += map[j][i];
    rep(i,q){
        int p, q; cin >> p >> q;
        int ans = map[q][q] - map[q][p-1] - map[p-1][q] + map[p-1][p-1];
        cout << ans << endl;
    }
}

Measured memory_bytes: 4616
#from math import sqrt
#from heapq import heappush, heappop
#from collections import deque
#s, t = [int(v) for v in int(input())]

s, t = input().split()
a, b = [int(v) for v in input().split()]
u = input()

if s == u:
    a -= 1
else:
    b -= 1

print("%d %d" % (a, b))


Measured memory_bytes: 2940
#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;

int main(){
    int n, a, b;
    cin >> n >> a >> b;

    int ans = 0;

    for(int i = 1; i <= n; ++i){
        string s = to_string(i); 

        int sum = 0;
        for(int j = 0; j < s.size(); ++j){
            sum += s[j] - '0';
        }

        if(a <= sum && sum <= b) ans += i;
    }

    cout << ans << endl;
    return EXIT_SUCCESS;
}


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

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

  int n, r;
  cin >> n >> r;

  if (n >= 10) cout << r << '\n';
  else cout << r + (1000 - 100 * n) << '\n';

  return (0);
}


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

int main() {
  int k;
  string s;
  cin >> k >> s;
  if(s.size()>k){
    int i;
    for(i=0;i<k;i++){
      cout << s.at(i);
    }
    cout << "..." << endl;
  }
  else {
    cout << s << endl;
  }
}

Measured memory_bytes: 3632
process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});

process.on('SIGINT', function(){
    input_stdin_array = input_stdin.split("\n");
    main();
    process.exit();
});

process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function abs(x){
	if (x < 0) return -x;
	return x;
}

function calc_min(x,y,c,d,M){
	var idx=1, dis=abs(x-c[1])+abs(y-d[1]);
	for (var i=2; i <= M; i++){
		if (dis > abs(x-c[i]) + abs(y-d[i])){
			dis = abs(x-c[i]) + abs(y-d[i]);
			idx = i;
		}
	}
	return idx;
}

function main() {
	var N, M, s;
	var a=[0], b=[0], c=[0], d=[0];
	s = readLine().split(" ");
	N = parseInt(s[0]); M = parseInt(s[1]);
	for (var i=1; i <= N; i++){
		s = readLine().split(" ");
		x = parseInt(s[0]); y = parseInt(s[1]);
		a.push(x);
		b.push(y);
	}
	for (var i=1; i <= M; i++){
		s = readLine().split(" ");
		x = parseInt(s[0]); y = parseInt(s[1]);
		c.push(x);
		d.push(y);
	}
	for (var i=1; i <= N; i++){
		console.log(calc_min(a[i],b[i],c,d,M).toString());
	}
}


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

using namespace std;
using ll = long long;

int main() {
  string s;
  cin >> s;
  string sl = "", sr = "";
  for (int i = 0; i < (s.size() - 1) / 2; i++) {
    sl += s[i];
    sr += s[i + (s.size() - 1) / 2 + 1];
  }
  string rsl = sl;
  string rsr = sr;
  reverse(sl.begin(), sl.end());
  reverse(sr.begin(), sr.end());
  if (sl == rsr && sl == rsl && sr == rsr) {
    cout << "Yes" << endl;
  } else {
    cout << "No" << endl;
  }
  return 0;
}


Measured memory_bytes: 3632
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

int n,t;

int a[100005];
int maxx[100005];
int minus[100005],ans;

int main()
{
    scanf("%d%d",&n,&t);
    int cnt=0;
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    maxx[n]=a[n];
    for(int i=n-1;i>=1;i--)
        maxx[i]=max(maxx[i+1],a[i]);
    for(int i=1;i<=n-1;i++)
    {
        minus[i]=maxx[i+1]-a[i];
        ans=max(ans,minus[i]);
    }
    for(int i=1;i<=n;i++)
        if(minus[i]==ans)
            cnt++;
    printf("%d\n",cnt);
}

Measured memory_bytes: 1280
#include <bits/stdc++.h>
using namespace std;
int main()
{long long n;
long long b=0;
cin>>n;
if(n%2) cout<<0;
else {
    for(long long i=n/2;i>0;i/=5) 
       b=b+i;
    cout<<b-n/2;
}

    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
using P = pair<int,int>;
template <class T> void chmin(T &a, const T &b) noexcept { if (b < a) a = b; }
template <class T> void chmax(T &a, const T &b) noexcept { if (a < b) a = b; }
void debug_out() { cout << "\n"; }
template <class T, class... Args>
void debug_out(const T &x, const Args &... args) { cout << x << " "; debug_out(args...);}
#ifdef _DEBUG
  #define debug(...) debug_out(__VA_ARGS__)
#else
  #define debug(...) 
#endif

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);
  std::cout << std::fixed << std::setprecision(15);
  int n;
  cin >> n;
  vector<int> a(n);
  const int M = 1000005;
  vector<int> div(M, 0); //割り切る数の個数
  rep(i,n) {
    cin >> a[i];
    if (div[a[i]] > 1) continue;
    for (int j = a[i]; j < M; j+=a[i]) {
      div[j]++;
    }
  }
  int ans = 0;
  rep(i,n) {
    if (div[a[i]] == 1) ans++;
  }
  cout << ans << endl;
  return 0;
}

Measured memory_bytes: 7900
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    
    if (a <= b) {
        cout << a << endl;
    }
    else {
        cout << max(1, a-1) << endl;
    }

}


Measured memory_bytes: 256
# -*- coding: utf-8 -*-
"""
Created on Sat Dec  8 20:50:49 2018

@author: Owner
"""


import collections
import scipy.misc
import sys
import numpy as np
import math
from operator import itemgetter

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []

"""
N, X = map(int, input().split())

x = [0]*N
x[:] = map(int, input().split())

P = [0]*M
Y = [0]*M
for m in range(M):
    P[m], Y[m] = map(int, input().split())
    
all(nstr.count(c) for c in '753')
"""

D = int(input())

if D == 25:
    print('Christmas')
elif D == 24:
    print('Christmas Eve')
elif D == 23:
    print('Christmas Eve Eve')
elif D == 22:
    print('Christmas Eve Eve Eve')
        




Measured memory_bytes: 25220
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int MOD = 1e9+7;
using ll = long long;
using vi = vector<int>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(x) x.begin(), x.end()
int main() {
  ll a,b,c,d,ans;
  cin >> a >> b >> c >> d;
  ans = a*c;
  ans = max(ans,a*d);
  ans = max(ans,b*c);
  ans = max(ans,b*d);
  cout << ans;
  
}

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

int main()
{
    int n,x;
    cin >> n >> x;
    int arr[n];
    int sum=0;
    int min=10e4;
    for (auto &value: arr) {
        cin>>value; 
        sum+=value;
        if(value<min)
        min=value;
        }
    x-=sum;
    n+=x/min;
    cout << n;
}


Measured memory_bytes: 256
#include <iostream>

#define N_MAX 300

using namespace std;

int main(){
    int N;
    char s[N_MAX][N_MAX];
    cin >> N;
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            cin >> s[i][j];
        }
    }
    int cnt = 0;
    for(int i = 0; i < N; i++){
        bool flag = true;
        for(int j = 0; j < N; j++){
            for(int k = 0; k < N; k++){
                int J, K;
                int J_, K_;
                J = j;
                K = (k+i)%N;
                J_ = (j+i)%N;
                K_ = k;
                //cout << s[J][K];
                if(s[J_][K_] != s[K][J]){
                    flag = false;
                }
            }
            
        }
        if(flag){
            cnt += N;
        }
    }
    cout << cnt << endl;
}

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

using namespace std;

template <class T> bool minimize(T &x, const T &y) {
    if (x > y) x = y; else return false; return true;
}

typedef long long ll;

const int N = 5e3 + 10;

int n;
ll A, B;
int a[N];
ll f[N][N];

int main() {
    if (fopen("B.inp", "r"))
        freopen("B.inp", "r", stdin),
        freopen("B.out", "w", stdout);
    cin >> n >> A >> B;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    memset(f, 60, sizeof(f));
    f[0][0] = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= n; j++) {
            if (f[i][j] > (ll)(1e14)) continue;
            if (a[i + 1] > j) {
                /// not move
                minimize(f[i + 1][a[i + 1]], f[i][j]);
                /// move a[i + 1]
                minimize(f[i + 1][j], f[i][j] + A);
            } else
                minimize(f[i + 1][j], f[i][j] + B);
        }
    ll ret = f[0][1];
    for (int j = 0; j <= n; j++)
        minimize(ret, f[n][j]);
    cout << ret;
}


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

int main(int argc, char const *argv[])
{
	int n;
	int Members[4][3][10]={0};
	int b,f,r,v=0;
	int i,j,k,l;

	cin >> n;
	for(l=0;l<n;l++)
	{
		cin >> b >> f >> r >> v;

		Members[b-1][f-1][r-1] += v;
	}


	for(i=0;i<4;i++)
	{
		for(j=0;j<3;j++)
		{
			for (k=0;k<10;k++)
			{
				cout << " " << Members[i][j][k];
			}
			cout << endl;
		}
		if (i != 3)
		{
			cout << "####################" << endl;
		}
	}
	return 0;
}


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

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for (auto& a : (x))
#define all(x) x.begin(), x.end() // sort(all(x))
#define sz(x) (int)(x).size()
#define mp(x, y) make_pair((x), (y))

typedef long long ll;

typedef double T;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tiii;

typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<T> vt;
typedef vector<vt> vvt;
typedef vector<pii> vpi;
typedef vector<pii> vpl;
typedef vector<vpi> graph;
typedef complex<T> Pt;
typedef pair<Pt, Pt> Line;

const ll MOD = 1000; // 998244353;
const T EPS = 1e-10;
const int INF = 1e9 + 1;

/* Mod Library */

struct Mod {
    ll x;
    Mod (ll x = 0) : x(x) {}
    Mod operator+(Mod b) { return Mod((x + b.x)%MOD); }
    Mod operator-(Mod b) { return Mod((x - b.x + MOD)%MOD); }
    Mod operator*(Mod b) { return Mod((x * b.x)%MOD); }
    Mod operator/(Mod b) { return *this * inverse(b); }
    Mod operator%(Mod b) { return Mod(x % b.x); }

    ll euclid(ll a, ll b, ll &x, ll &y) {
        if (b) {
            ll d = euclid(b, a%b, y, x);
            y -= a/b*x;
            return d;
        }
        x = 1; 
        y = 0;
        return a;
    }
    
    Mod inverse(Mod a) {
        ll x, y, g = euclid(a.x, MOD, x, y);
        assert(g == 1);
        return Mod((x + MOD)%MOD);
    }

    Mod operator^(ll e) {
        if (!e) return Mod(1);
        Mod r = *this^(e/2);
        r = r*r;
        return e&1 ? *this*r : r;
    }
};

/* Input Library */
template <typename A, typename B>
istream& operator>>(istream &in, pair<A, B> &p) {
    in >> p.first >> p.second;
    return in;
}

template <typename A, typename B>
ostream& operator<<(ostream &out, pair<A, B> &p) {
    out << p.first << " " << p.second;
    return out;
}

template <typename I>
istream& operator>>(istream &in, vector<I> &a) {
    trav(i, a) in >> i;
    return in;
}

template <typename I>
ostream& operator<<(ostream &out, vector<I> &a) {
    rep(i, 0, sz(a)) {
        if (i) out << " ";
        out << a[i];
    }
    return out;
}

void fast_io() {
    cin.sync_with_stdio(0);
    cin.tie(0);
    //cout.tie(0);
    cin.exceptions(cin.failbit);
}

/* Solution */

void solve_test() {
    string s, t;
    cin >> s >> t;
    int ans = 0;
    rep(i, 0, s.size()) {
        if (s[i] == t[i]) ans++;
    }
    cout << ans << endl;
}

void setup() {

}

int main() {
    setup();
    srand(time(0));
    fast_io();
    int t = 1;
    // cin >> t;
    while (t--) {
        solve_test();
    }
}


Measured memory_bytes: 256
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N, M, K = LI()
    A = LI()
    B = LI()

    A_acc = [0] * (N + 1)
    for i in range(N):
        A_acc[i+1] = A_acc[i] + A[i]
    B_acc = [0] * (M + 1)
    for i in range(M):
        B_acc[i+1] = B_acc[i] + B[i]

    ans = 0
    for i in range(N + 1):
        if A_acc[i] > K:
            break
        j = bisect.bisect_right(B_acc, K - A_acc[i]) - 1
        ans = max(i + j, ans)

    print(ans)

if __name__ == '__main__':
    resolve()


Measured memory_bytes: 48360
#include <cstdio>
#include <algorithm>
#define repu(i,x,y) for (int i=x; i<=y; ++i)
using namespace std;

typedef long long LL;
const int p=998244353;
int n,m,fac[1000100],inv[1000100],ans;

int power(int x,int k)
{
    int ret=1;
    for (; k; k>>=1,x=LL(x)*x%p)
        if (k&1)
            ret=LL(ret)*x%p;
    return ret;
}

int c(int n,int m)
{
    return LL(fac[n])*inv[m]%p*inv[n-m]%p;
}

int main()
{
    scanf("%d%d",&n,&m);
    fac[0]=fac[1]=inv[0]=inv[1]=1;
    repu(i,2,n+m)
        inv[i]=LL(p-p/i)*inv[p%i]%p;
    repu(i,2,n+m)
        inv[i]=LL(inv[i-1])*inv[i]%p,fac[i]=LL(fac[i-1])*i%p;
    repu(i,1,min(n,m))
        ans=(ans+LL(c(i*2,i))*c(n+m-i*2,n-i))%p;
    ans=LL(ans)*power(c(n+m,n)*2%p,p-2)%p;
    printf("%d\n",ans+max(n,m));
    return 0;
}

Measured memory_bytes: 7936
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <deque>

#define REP(i,a,b) for(int i=int(a);i<int(b);i++)

using namespace std;

typedef long long int lli;

int main () {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> G(N);
    REP (i, 0, M) {
        int A, B;
        cin >> A >> B;
        A--;
        B--;
        G[A].push_back(B);
        G[B].push_back(A);
    }

    deque<int> nlist;
    nlist.push_back(0);
    nlist.push_back(G[0][0]);
    set<int> s;
    s.insert(0);
    s.insert(G[0][0]);
    REP (_, 0, N) {
        int f = nlist[0];
        for (int v : G[f]) {
            if (s.count(v)) continue;
            s.insert(v);
            nlist.push_front(v);
            break;
        }
    }
    REP (_, 0, N) {
        int f = nlist.back();
        for (int v : G[f]) {
            if (s.count(v)) continue;
            s.insert(v);
            nlist.push_back(v);
            break;
        }
    }

    cout << nlist.size() << endl;
    REP (i, 0, nlist.size()) cout << nlist[i] + 1 << ' ';
    cout << endl;

    return 0;
}


Measured memory_bytes: 11392