akhauriyash/Code-Regression huggingface dataset:
#include<bits/stdc++.h>
using namespace std ;
 
#define int long long
#define endl '\n'

#define IOS ios::sync_with_stdio(0) ; cin.tie(0) ; cout.tie(0) ;
 
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define vp vector<pii>
#define vs vector<string>
#define all(v) v.begin(),v.end()

#define lb  lower_bound
#define ub  upper_bound
#define bs  binary_search
#define ff  first
#define ss  second
#define sz(x) ((int)(x).size())
#define rep(i,l,r) for(int i=(l);i<(r);++i)
 
#define gcd(a,b)    __gcd((a),(b))
#define lcm(a,b)    ((a)*(b)) / gcd((a),(b))
     
#define pi 3.14159265358979323846264338327950L
#define MOD 1000000007

int32_t main(){

   
     IOS
    int a,b;
    cin>>a>>b;
    cout<<a*b;
    
  return 0;
}


//8 6 4 2 2 
//5 4 4 3 1

Measured memory_bytes: 3652
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)

int main(){
    string s;
    cin >> s;
    if(s == "ABC"){
        cout << "ARC" << endl;
    }else{
        cout << "ABC" << endl;
    }
    return 0;
}

Measured memory_bytes: 3628
#include <iostream>
#include <math.h>
#include <algorithm>
#include <string>
#include <map>
#include <vector>

using namespace std;

void b_echo(void) {
	int n;
	string s;
	cin >> n >> s;

	if (n % 2 == 1) {
		cout << "No" << endl;
		return;
	}

	string s_upper = s.substr(0, n / 2);
	string s_lower = s.substr(n / 2, n / 2);

	//cout << s_upper << " " << s_lower << endl;

	if (s_upper == s_lower) {
		cout << "Yes" << endl;
	}
	else {
		cout << "No" << endl;
	}
}

int main()
{
    b_echo();

    return 0;
}

Measured memory_bytes: 3620
/*
　　　  ∧＿∧　やあ
　　 （´・ω・｀)　　　　　/　　　　　ようこそ、バーボンハウスへ。
　　 ／∇y:::::＼　　　 [￣]　　　　　このテキーラはサービスだから、まず飲んで落ち着いて欲しい。
　　 |:⊃:|:::::|　　　|──|
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣|　うん、「また」なんだ。済まない。
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣|￣　  仏の顔もって言うしね、謝って許してもらおうとも思っていない。
￣￣￣￣￣￣￣￣￣￣￣￣￣￣／|
　　　　∇　∇　∇　∇　　　／.／|　　　でも、この提出を見たとき、君は、きっと言葉では言い表せない
　　　　┴　┴　┴　┴　／ ／　  |　　　「ときめき」みたいなものを感じてくれたと思う。
￣￣￣￣￣￣￣￣￣￣|／　　  |　　　殺伐としたコンテストの中で、そういう気持ちを忘れないで欲しい
￣￣￣￣￣￣￣￣￣￣　　　　 |　　　そう思って、この提出を投げたんだ。
　　　(⊆⊇)　(⊆⊇)　(⊆⊇)　　|
　    ||　　 ||　　||　　|　　　 じゃあ、判定を聞こうか。
　　.／|＼　／|＼ ／|＼
*/

#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <array>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define fst first
#define snd second
#define ALL(obj) (obj).begin(),(obj).end()
#define debug(x) cerr << #x << " -> " << x << " (line:" << __LINE__ << ")" << '\n';
#define debugpair(x, y) cerr << "(" << #x << ", " << #y << ") -> (" << x << ", " << y << ") (line:" << __LINE__ << ")" << '\n';
typedef long long lint;
typedef priority_queue<int> p_que;
typedef priority_queue<int, vector<int>, greater<int>()> p_que_rev;
// const int INF = INT_MAX;
const lint LINF = LLONG_MAX;
// const lint MOD = 1000000000 + 7;
const double EPS = 1e-9;
const double PI = acos(-1);
const int di[]{0, -1, 0, 1, -1, -1, 1, 1};
const int dj[]{1, 0, -1, 0, 1, -1, -1, 1};


int main()
{
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    string s;
    cin >> s;
    string ans = "";
    for (int i=0; i<(int)s.length(); ++i){
        if(s[i] != ','){
            ans = ans + s[i];
        }
        else {
            ans = ans + ' ';
        }
    }
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define ALL(v) v.begin(), v.end()
#define PRINT(V) for (auto v : (V)) cout << v << " "
const long long INF = 1LL << 60;
using namespace std;
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cout << H << " ";
  debug_out(T...);
}
#ifdef _DEBUG
#define debug(...) debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif

int main() {
long int x;
int cnt = 0;
cin >> x;
long int y = 100;

while(y-x < 0){
  y = y*1.01;
  cnt++;
}

cout << cnt;
return 0;
}

Measured memory_bytes: 3624
#include<bits/stdc++.h>
#define INF 1e18
#define int long long
using namespace std;
typedef pair<int,int> P;

struct Graph{
  Graph(int n):E(n),d(n){};
  vector<vector<P>>E;
  vector<int>d;
  void add_edge(int a,int b,int c){
    E[a].emplace_back(b,c);
  }
  bool bellmanFord(int s,int t){
    int N=d.size();
    fill(d.begin(),d.end(),INF);
    d[s]=0;
    for(int i=0;i<N;++i)
      for(int j=0;j<N;++j)
        for(P& p:E[j])
          if(d[j]!=INF&&d[j]+p.second<d[p.first]){
            d[p.first]=d[j]+p.second;
            if(i==N-1&&p.first==t)return false;
            //if check after destination route
            // if(i==N-1)return false;
          }
    return true;
  }
  int get_cost(int n){
    return d[n];
  }
};

main(){
  int n,m,a,b,c;
  cin>>n>>m;
  Graph G(n);
  for(int i=0;i<m;++i){
    cin>>a>>b>>c;
    G.add_edge(a-1,b-1,-c);
  }
  if(G.bellmanFord(0,n-1))cout<<-G.get_cost(n-1)<<endl;
  else cout<<"inf"<<endl;
}


/***************************

ABC061_D
http://abc061.contest.atcoder.jp/tasks/abc061_d

****************************/


Measured memory_bytes: 384
#include<stdio.h>
#include<stdlib.h>

struct node {
  int id;
  struct node *next;
};
struct pair {
  int x;
  int y;
};
struct node **list;
struct pair *art;
int *seq, counter,sp;

void Insert(int, int);
int Biconnected(int, int);
void qsort1(int, int);
int main(void)
{
  int i, j, v, e, s, t;
  scanf("%d %d", &v, &e);
  list = (struct node**)malloc(sizeof(struct node*) * v);
  art = (struct pair*)malloc(sizeof(struct pair) * e);
  seq = (int*)calloc(v, sizeof(int));
  for (i = 0; i < v; i++) {
    list[i] = NULL;

  }
  for (i = 0; i < e; i++) {
    scanf("%d %d", &s, &t);
    Insert(s,t);
  }
  Biconnected(0, -1);
  qsort1(0, sp - 1);
  for (i = 0; i < sp; i++) printf("%d %d\n", art[i].x, art[i].y);
  for (i = 0; i < v; i++) {
    free(list[i]);
  }
  free(list);
  free(seq);
  free(art);
}
void Insert(int a, int b)
{
  struct node *p = (struct node*)malloc(sizeof(struct node));
  p->id = b;
  p->next = list[a];
  list[a] = p;
  p = (struct node*)malloc(sizeof(struct node));
  p->id = a;
  p->next = list[b];
  list[b] = p;
}
int Biconnected(int point, int pre)
{
  int min;
  struct node *n;
  counter++;
  seq[point] = counter;
  min = counter;
  for(n = list[point]; n != NULL; n = n->next) {
    if (!seq[n->id]) {
      int m;
      m = Biconnected(n->id, point);
      if (m < min) min = m;
      if (m > seq[point]) {
        if (point < n->id) {
          art[sp].x = point;
          art[sp].y = n->id;
        } else {
          art[sp].x = n->id;
          art[sp].y = point;
        }
        sp++;
      }
    } else if (n->id != pre) {
      if (seq[n->id] < min) {
        min = seq[n->id];
      }
    }
  }
  return min;
}
void qsort1(int left, int right) {
  struct pair pivot = art[(left + right) / 2];
  int i = left, j = right;
  if (left >= right) return;
  do{
    while (1) {
      if (art[i].x > pivot.x || (art[i].x == pivot.x && art[i].y >= pivot.y)) break;
      i++;
    }
    while (1) {
      if (art[j].x < pivot.x || (art[j].x == pivot.x && art[j].y <= pivot.y)) break;
      j--;
    }
    if (i <= j) {
      struct pair temp = art[i];
      art[i] = art[j];
      art[j] = temp;
      i++;
      j--;
    }
  }while(i <= j);
  qsort1(left, j);
  qsort1(i, right);
}


Measured memory_bytes: 5308
#include <bits/stdc++.h>
using namespace std;
using ll=long long int;
using ld=long double;
using VI=vector<ll>;
using VD=vector<ld>;
using VVI=vector<VI>;
using VC=vector<char>;
using VVC=vector<VC>;
using VS=vector<string>;
using PLL =pair<ll,ll>;
using PLD=pair<ld,ld>;
using VPLL=vector<PLL>;
#define print(x) std::cout<<x<<"\n"
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define repd(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define SZ(x) ((ll)(x).size())
#define MAX(x) *max_element((x).begin(),(x).end())
#define MIN(x) *min_element((x).begin(),(x).end())
#define SORTR(x) sort((x).rbegin(),(x).rend())
#define SORT(x) sort((x).begin(),(x).end())
#define SUM(x) accumulate((x).begin(),(x).end(), 0)
#define FILL(x,a) fill(x.begin(),x.end(),a)
#define EACH(i,x) for(typeof((x).begin()) i=(x).begin(); i!=(x).end(); ++i)
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())

const ll INF = 1e18;
const ld EPS   = 1e-10;
const int MOD  = int(1e9)+7;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template <class BidirectionalIterator>
bool next_partial_permutation(BidirectionalIterator first, BidirectionalIterator middle,BidirectionalIterator last){reverse(middle, last); return next_permutation(first , last);}
ll gcd(ll x, ll y) { return (x % y)? gcd(y, x % y): y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll GCD(VI v){ll a = v[0]; for (ll i = 1; i<SZ(v); i++) {a = gcd(a, v[i]);} return a;}
ll LCM(VI v){ll a = v[0]; for (ll i = 1; i<SZ(v); i++) {a = lcm(a, v[i]);} return a;}
VI Bit2Vector(const ll bit, ll n) {	VI s;	rep(i,n) if (bit & (1 << i)) s.push_back(i); return s;}

//https://atcoder.jp/contests/dp/tasks/dp_a
void Main()
{
	ll n,m,l,k; ll res=0;
	string s,t,u; string sres="No or NO";

	cin>>n>>k;
	VI h(n+1,0),dp(n+1,0);
	rep(i, n) cin >> h[i];
	dp[0]=0;
	for (ll i = 1; i < n; ++i) {
		ll cost = INF;
		ll j=1;
		while(i-j>=0&&j<=k) {
			ll diff=i-j;
			cost = min(cost,dp[diff]+abs(h[i]-h[diff]));
			j++;
		}
		dp[i] = cost;
	}

	res=dp[n-1];
	cout << res << "\n";
	return;
}

int main()
{
	std::cin.tie(0);
	std::ios_base::sync_with_stdio(false);
	std::cout << std::fixed << std::setprecision(15);
	Main();
}


Measured memory_bytes: 1792
n = gets.chomp("").to_i
a = gets.split(" ").map(&:to_i)

ans = Hash.new
n.times do |i|
  ans[a[i]] = i+1
end

ans = ans.sort

ans.each_with_index do |value, s|
  if s != 0
    print " "
  end
  print value[1]
end


Measured memory_bytes: 24688
import java.util.Scanner;
import java.lang.Math;
class Main{
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    int a[]=new int[num];
    int b[]=new int[num];
    for(int x=0; x<num;x++){
      a[x]=scan.nextInt();
    }
    for(int x=0; x<num; x++){
      b[x]=scan.nextInt();
    }
    System.out.println(Math.abs(count(a,num)-count(b,num)));
  }
  public static int count(int array[], int num){
    int count=0, Ans=0;
    for(int x=0; x<array.length-1; x++){
      count=0;
      for(int y=x+1; y<array.length; y++){
        if(array[x]>array[y]){
          count++;
        }
      }
      //System.out.println(count);
      Ans+=count*stair(num-x-1);
    }
    return Ans;
  }
  
  public static int stair(int in){
    int count=1;
    for(int x=in; x>1; x--){
      count*=x;
    }
    return count;
  }
}

Measured memory_bytes: 22996
#include "stdio.h"
int main(void)
{
	/* code */
	int W,H,x,y,r,tmp;
	scanf("%d",&W);	
	scanf("%d",&H);
	scanf("%d",&x);
	scanf("%d",&y);
	scanf("%d",&r);
	if(x-r < 0 || x+r >W || y-r<0 || y+r >H)
		printf("No\n");
	else
		printf("Yes\n");
	return 0;
}


Measured memory_bytes: 584
#include <bits/stdc++.h>
using namespace std;
 
#define REP(i, a, b) for(int i = (a); i <= (b); i++)
#define PER(i, a, b) for(int i = (a); i >= (b); i--)
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define all(S) (S).begin(), (S).end()
#define pb push_back
#define mk make_pair
#define S second
#define F first
typedef long long ll;
typedef long double lf;
typedef pair<int, int> ii;
const int MAX = 3e3+3;
ll pd[MAX][MAX][4];
int m[MAX][MAX];
int N, M, K;


ll solve(int i, int j, int k) {
	if(i > N || j > M) return -(1LL<<50);
	if(i == N && j == M) {
		if(k < 3) return m[i][j];
		return 0;
	}
	ll &ans = pd[i][j][k];
	if(ans != -1) return ans;
	if(k < 3) {
		ans = solve(i+1, j, 0) + m[i][j];
		ans = max(ans, max(solve(i, j+1, k+1) + m[i][j], 
			solve(i, j+1, k)));
	} else
		ans = max(solve(i+1, j, 0), solve(i, j+1, k));	
	return ans;
}

int main(int argc, char * * argv) {
	int a, b, v;
	memset(pd, -1, sizeof pd);
	scanf("%d%d%d", &N, &M, &K);
	rep(i, 0, K) {
		scanf("%d%d%d", &a, &b, &v);
		m[a][b] = v;
	}
	printf("%lld\n", solve(1, 1, 0));
	return 0;
}


Measured memory_bytes: 321168
import bisect
import sys

sys.setrecursionlimit(200000)


def input():
    return sys.stdin.readline()[:-1]


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def imi(N: int, t: type = int):
    return [ii(t) for _ in range(N)]


def iml(N: int, t: type = int):
    return [il(t) for _ in range(N)]


def solve():
    N = ii()
    A = ii(str)
    B = ii(str)
    C = ii(str)
    ans = 0
    for i in range(N):
        t = A[i] != B[i]
        t += B[i] != C[i]
        t += C[i] != A[i]
        ans += max(t - 1, 0)
    return ans


if __name__ == "__main__":
    print(solve())


Measured memory_bytes: 3064
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;

#define MAX 256

int main(void){

	for (int i = 1; i <= 9; i++){
		for (int j = 1; j <= 9; j++){
			printf("%dx%d=%d\n", i, j, i*j);
		}
	}

	return 0;
}

Measured memory_bytes: 3212
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<int,int> P;
const LL mod=1000000007;
const LL LINF=1LL<<60;
const int INF=1<<30;






int main(){
    string s;cin >> s;
    if(s[0]=='S') puts("Cloudy");
    else if(s[0]=='C') puts("Rainy");
    else puts("Sunny");
    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
#define vcout(v) rep(i,v.size()) cout << v[i] << " "; cout << endl
#define mcout(m) rep(j,m.size()){vcout(m[j]);}
const ll MOD = 1e9 + 7;

int mainsolve(){

	const ll mod = 2019;
	string s;
	cin >> s;
	ll n = s.size();

	vector<ll> cum(n+1), count(mod);
	ll tmp = 10;
	rep(i,n){
		cum[i+1] = (cum[i] + (s[n-1-i] - '0') * tmp) % mod;
		(tmp *= 10) %= mod;
	}

	rep(i,n+1) count[cum[i]]++;

	ll res = 0;
	rep(i,mod){
		if(count[i] == 0 || count[i] == 1) continue;
		res += count[i] * (count[i] - 1) /2;
	}

	cout << res << endl;
	return 0;
}

int main(){

	return mainsolve();
}

Measured memory_bytes: 5160
#7_A
while 1:
    m, f, r = map(int, input().split())
    if m==-1 and f==-1 and r==-1:
        break
    if m==-1 or f==-1:
        grade = "F"
    else:
        mpf = m + f
        if 80<=mpf<=100:
            grade = "A"
        elif 65<=mpf<80:
            grade = "B"
        elif 50<=mpf<65:
            grade = "C"
        elif 30<=mpf<50:
            if r>=50:
                grade = "C"
            else:
                grade = "D"
        elif 30>mpf:
            grade = "F"
    print(grade)


Measured memory_bytes: 5592
# -*- coding: utf-8 -*-
import math

K = int(input())

S = 0
for a in range(1,K+1):
  for b in range(1,K+1):
    m = math.gcd(a,b)
    for c in range(1,K+1):
      S += math.gcd(m,c)
print(S)

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

#define ln '\n'
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for(int i = (a); i <= (int)(b); ++i)
#define FORR(i, a, b) for(int i = (a); i >= (int)(b); --i)
#define ALL(c) (c).begin(), (c).end()

typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
typedef vector<P> VP;
typedef vector<PL> VPL;
typedef vector<string> VS;


int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int a, b, q;
    cin >> a >> b >> q;
    VL s(a), t(b);
    REP(i, a) cin >> s[i];
    REP(i, b) cin >> t[i];
    
    REP(i, q) {
        ll x;
        cin >> x;
        VL::iterator s_it = lower_bound(ALL(s), x);
        VL::iterator t_it = lower_bound(ALL(t), x);
        vector<VL::iterator> s_itv;
        vector<VL::iterator> t_itv;
        if(s_it != s.begin()) s_itv.push_back(s_it - 1);
        if(s_it != s.end()) s_itv.push_back(s_it);
        if(t_it != t.begin()) t_itv.push_back(t_it - 1);
        if(t_it != t.end()) t_itv.push_back(t_it);
        
        ll ans = LONG_MAX;
        for(auto s_it : s_itv)for(auto t_it : t_itv) {
            ans = min(ans, abs(*s_it - x) + abs(*t_it - *s_it));
            ans = min(ans, abs(*t_it - x) + abs(*s_it - *t_it));
        }
        cout << ans << ln;
    }
    return 0;
}


Measured memory_bytes: 2944
#if 0

#endif
#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
#include <complex>
#include <queue>
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
using namespace std;
using ll = long long;
ll ll_max = numeric_limits<ll>::max();
ll ll_min = numeric_limits<ll>::min();
int int_max = numeric_limits<int>::max();
int int_min = numeric_limits<int>::min();
int W, H;
int lab[20][20];
string tmp;
queue<pair<int, int> > now;
int dirs[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
bool check_point(pair<int, int> point) {
    bool ret = true;
    ret &= point.first > -1;
    ret &= point.second > -1;
    ret &= point.first < H;
    ret &= point.second < W;
    ret &= lab[point.first][point.second] == int_max;
    return ret;
}
int bfs() {
    int cnt = 1;
    while (!now.empty()) {
        pair<int, int> start = now.front();
        now.pop();
        for (auto dir : dirs) {
            auto next = make_pair(start.first + dir[0], start.second + dir[1]);
            if (check_point(next)) {
                now.push(next);
                lab[next.first][next.second] = lab[start.first][start.second] + 1;
                ++cnt;
            }
        }
    }
    return cnt;
}
int main(void){
    cin.tie(0);
    ios::sync_with_stdio(false);

    while (cin >> W >> H && W && H) {
        rep(h, H) {
            cin >> tmp;
            rep(w, W) {
                switch (tmp[w]) {
                    case '.':
                        lab[h][w] = int_max;
                        break;
                    case '#':
                        lab[h][w] = int_min;
                        break;
                    case '@':
                        lab[h][w] = 0;
                        now.push(make_pair(h, w));
                        break;
                }
            }
        }
        cout << bfs() << endl;
    }    

    return 0;
}


Measured memory_bytes: 3132
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL,LL> PII;

class UF{
public:
	vector<int> parent;
	UF(int N){
		parent.resize(N);
		for(int i=0; i<N; i++)
			parent[i] = i;
	}
	int find(int v) {
		if(v == parent[v]) return v;
		return parent[v] = find(parent[v]);
	}
	
	void uni(int u, int v) {
		u = find(u);
		v = find(v);
		parent[v] = u;
		
	}
	
	vector<int> fin() {
		int N = parent.size();
		vector<int> ret(N, -1);
		vector<int> prev(N, -1);
		for(int i=0; i<N; i++) {
			int pos = find(i);
			if(prev[pos] != -1) {
				ret[prev[pos]] = i;
			}
			prev[pos] = i;
			
		}
		return ret;
	}
	
	
	
};



int main() {
	string s;
	cin >> s;
	int M;
	cin >> M;
	int N = s.size();
	vector<int> diff(N, 0);
	for(int i=0; i<N/2; i++) {
		diff[i] = (s[N-1-i] - s[i]);
		diff[i] += 26*5;
		diff[i] %= 26;
	}
	
//	priority_queue<PII, vector<PII>, greater<PII> > Q;
//	vector<PII> Q;
	UF uf(N);
	for(int i=0; i<M; i++) {
		int l,r;
		cin >> l >> r;
		l--; r--;
		if(N-r-1 <= l) {
			int ll = l;
			l = N-1-r;
			r = N-1-ll;
		}
//		cout << l << " " << r << endl;
		if(r >= N/2) r = N-1-r-1;
		//assert(l <= r);
//		cout << l << " " << r+1 << endl;
		if(l <= r) {
			r++;
			//Q.push(PII(l,r));
			uf.uni(l, r);
		}
	}
	vector<int> next = uf.fin();
	
	/*
	for(int i=0; i<next.size(); i++)
		cout << next[i] << " ";
		
	cout << endl;
	*/
	for(int i=0; i<N/2; i++) {
	//cout << i << endl;
	/*
		for(int j=0; j<N; j++) {
			cout << diff[j] << " ";
		}
		cout << endl;
		*/
		int nx = next[i];
		if(nx == -1) continue;
		int adder = -diff[i];
		for(int j=i; j<nx; j++) {
			diff[j] += adder;
			diff[j] %= 26;
		}
		
	}
	for(int i=0; i<N/2; i++) {
		if(diff[i] != 0) {
			cout << "NO" << endl;
			return 0;
		}
	}
	
	cout << "YES" << endl;
	
	
	//vector<PII> res;
	
	
	
	
	
	/*
	PII prev = PII(-1, -1); 
	while(!Q.empty() ) {
		PII cur = Q.top(); Q.pop();
		if(cur.first == prev.first) {
			PII next = cur;
			next.first = prev.second+1l
			Q.push(cur.prev, );
		}
		
		
	}
	*/
	
	
	
	
	return 0;
}

Measured memory_bytes: 2176
//Name : Rupa Dey
  //Date : 24 August 2020
//joi sri gour hori gobindo...
//gobindo ja hobe vlor jonnoi hobe..
#include<bits/stdc++.h>
#define ll long long
#define d double
#define ld long double
#define vi vector<int>
#define vul vector<ull>
#define vl vector<ll>
#define pb push_back
#define si set<int>
#define sl set<ll>
#define yes cout<<"YES\n"<<endl
#define no cout<<"NO\n"<<endl
#define ys cout<<"Yes\n"<<endl
#define n cout<<"No\n"<<endl
#define test cin>>t; while(t--)
//#define for(i,a,n) for(i=a;i<n;i++)
#define mp make_pair
#define ft first
#define sc second
#define gap " ";
#define MAX 9999999
#define MOD 1000000007
#define nd endl
using namespace std;
int main()
{
   ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int x,i,j,k,cnt=0,a;
    cin>>x;
    vi vec;
    vec.clear();
    for(i=0;i<x;i++) {
            cin>>a;
            vec.pb(a);}

    sort (vec.begin(),vec.end());
   // for(i=0;i<x;i++) cout<<vec[i];
   //fully dull headed.....

    for(i=0;i<vec.size();i++)
    {
        for(j=i+1;j<vec.size();j++)
        {
            for(k=j+1;k<vec.size();k++)
            {
                if(((vec[i]+vec[j])>vec[k])&&(vec[i]!=vec[j]) && (vec[j]!=vec[k]) && (vec[k]!=vec[i]))
                {

                        cnt++;
                }
            }
        }
    }

    cout<<cnt<<nd;



}
//hare krishna...
//hey gobindo kripa koro......
//only gobindo exists..^..


Measured memory_bytes: 3620
n,m,x,y=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))

def check():
    for z in range(x+1, y+1):
        if max(a)<z and min(b)>=z:
            print("No War")
            return
    print("War")
    return

check()

Measured memory_bytes: 2940
use std::io::{BufRead, Write};
use std::io;

fn solve<R: BufRead, W: Write>(mut input: R, mut output: W) {
    let mut buf = String::new();
    input.read_line(&mut buf).unwrap();
    let n: usize = buf.trim_right().parse().unwrap();
    buf.clear();
    input.read_line(&mut buf).unwrap();
    let k: usize = buf.trim_right().parse().unwrap();
    let mut result=1;
    for _ in 0..n {
        if result<k {
            result*=2;
        }else{result+=k;}
    }
    writeln!(output, "{}", result).unwrap();
}

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();
    solve(stdin.lock(), stdout.lock());
}

#[cfg(test)]
mod tests {
    fn test(input: &str, output: &str) {
        let mut v: Vec<u8> = Vec::new();
        ::solve(input.as_bytes(), &mut v);
        assert_eq!(String::from_utf8(v).unwrap(), output);
    }

    #[test]
    fn case1() {
        test(
            "4
3\n",
            "10\n",
        );
    }

    #[test]
    fn case2() {
        test(
            "10
10\n",
            "76\n",
        );
    }
}


Measured memory_bytes: 4352
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;
#define REP(i, n) for(int (i)=0; (i)<(n); (i)++)
#define OUT(a) cout << (a) << "\n"
#define ll long long
ll MOD = 10e9 + 7;

int main() {
    int m,n;
    cin >> n >> m;
    vector<long long> a;
    vector<pair<long long, long long> > bc;
 	long long tmp;
    REP(i, n) {
      scanf("%lld", &tmp);
      a.push_back(tmp);
    }
    int b,c;
    REP(i, m) {
        scanf("%lld %lld", &b, &c);
        bc.push_back(make_pair(c,b));
    }
    sort(bc.begin(), bc.end());
    sort(a.begin(), a.end());
    int index = m-1;
    for(int i=0; i<n; i++) {
        //printf("%d %d\n", a[i], bc[index].first);
        if (a[i] < bc[index].first) {
            a[i] = bc[index].first;
            bc[index].second--;
            if (bc[index].second == 0) index--;
        }
    }
    long long ans = 0;
    REP(i, n) {
        ans += a[i];
    }
    printf("%lld\n", ans);
    return 0;
}

Measured memory_bytes: 3188
#include<iostream>
#include<string>
using namespace std;
int main()
{
	ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    string s, t;
    cin>>s>>t;
    int x=0, i;
    for(i=0; i<s.length(); i++)
    {
    	if(s[i]!=t[i])
    		x++;
    }
    cout<<x;
}

Measured memory_bytes: 3800
#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <list>

auto& in = std::cin;
auto& out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;

int32_t N;
bool deleted[200010];
std::pair<int32_t, int32_t> V[200010];

int main()
{
	using std::endl;
	in.sync_with_stdio(false);
	out.sync_with_stdio(false);
	in.tie(nullptr);
	out.tie(nullptr);

	int32_t M;
	in >> N>>M;
	for (size_t i = 0; i < M; i++)
	{
		int a,b;
		in >> a >> b;
		V[i * 2] = { a,i };
		V[i * 2 + 1] = { -b,i };
	}
	std::sort(V, V + 2 * M, [](auto& l, auto& r) {
		using std::abs;
		if (abs(l.first)==abs(r.first)) {
			if (l.first < 0 && r.first>0) { return true; }
			if (r.first < 0 && l.first>0) { return false; }
			return l.second < r.second;
		}
		return abs(l.first) < abs(r.first);
	});
	int32_t res = 0;
	std::vector<int32_t> stack;
	for (size_t i = 0; i < 2*M; i++)
	{
		if (V[i].first > 0) {
			stack.push_back(V[i].second);
		}
		else if(deleted[V[i].second]==false){

			++res;
			for (auto& i : stack) {
				deleted[i] = true;
			}
			stack.clear();
		}
	}

	out << res << endl;

	return 0;
}
#endif


Measured memory_bytes: 2304
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>

using namespace std;
typedef long long ll;
ll mod = 1e9+7;
//ll mod = 998244353;
#define rep(i,n) for(int i = 0; i < (n); ++i)

int main() {
    int n, x, t;
    cin >> n >> x >> t;
    cout << (n + x - 1) / x * t << endl;
    return 0;
}


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

int main(){
 
  int A, B, C, D;
  cin >> A >> B >> C >> D;
  
  while(true){
    
    C -= B;
    
    if(C <= 0){
       cout << "Yes" << endl;
      return 0;
    }
    
    A -= D;
    
    if(A <= 0){
       cout << "No" << endl;
      return 0;
    }
  }
  
  return -1;
}

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

int main() {
  int a, b, n; cin >> a >> b >> n;  //yoyaku
  vector<int> v(1001);
  for (int i = 0; i < n; i++) {
    int s, f; cin >> s >> f;
    for (int j = s; j <= f; j++) {
      v.at(j) = 1;
    }
  }
  int ans = 0;
  if (b - a == 1) {
    if (!(v.at(a) == 1 && v.at(b) == 1)) {
      ans = 0;
    } else {
      ans = 1;
    }
  } else {
    for (int i = a + 1; i < b; i++) {
      if (v.at(i) != 0) {
        ans = 1;
      }
    }
  }
  cout << ans << endl;
}


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

vector<int> v[100005];
int c[100005];

int main(){
    int n,m;
    cin >> n >> m;
    queue<pair<int,int>> q;
    int a,b;
    for(int i=0;i<m;i++){
        cin >> a >> b;
        v[b].push_back(a);
        v[a].push_back(b);
    }
    for(int u:v[1])q.push(make_pair(u,1));
    while(!q.empty()){
        if(c[q.front().first]==0){
            c[q.front().first]=q.front().second;
            for(int u:v[q.front().first]){
                if(u!=q.front().second && c[u]==0){
                q.push(make_pair(u,q.front().first));
                }
            }
        }
        q.pop();
    }
    cout << "Yes" << endl;
    for(int i=2;i<n+1;i++)cout << c[i] << endl;
}

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

typedef long long ll;
const ll MOD = 1e9 + 7;

//O(logb)
ll mod_pow(ll a, ll b, ll mod){
    if(b == 0) return 1;
    if(b % 2 == 0){
        ll d = mod_pow(a,b/2,mod);
        return d%mod*d%mod;
    }else return a%mod*mod_pow(a,b-1,mod)%mod;
}

ll mod_combination(ll n,ll r,ll mod){
    if(r > n) return 0;
    if(n == r || r == 0) return 1;
    ll ans = 1,fact = 1;
    for(ll i = n; i >= n-r+1; i--) ans = ans*i%mod;
    for(ll i = r; i >= 1; i--) fact = fact*i%mod;
    return ans*mod_pow(fact,mod-2,mod)%mod;
}

void solve(ll i, ll n, ll k){
    cout << mod_combination(n-k+1,i,MOD)%MOD*mod_combination(k-1,i-1,MOD)%MOD << endl;
}

int main(){
    ll n,k; cin >> n >> k;
    for(ll i = 0; i < k; i++) solve(i+1,n,k);
}

Measured memory_bytes: 256
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define debug(x) cerr << #x << ": " << x << endl
#define debug2(x, y) debug(x), debug(y)
#define repn(i, a, b) for(int i = (int)(a); i < (int)(b); i++)
#define rep(i, a) for(int i = 0; i < (int)(a); i++)
#define all(v) v.begin(), v.end() 
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define sq(x) ((x) * (x))

template<class T> T gcd(T a, T b){ return ((b == 0) ? a : gcd(b, a % b)); }

int bl = 0;

bool cmp(pair<pi, int> a1, pair<pi, int> b1){
	pi a = a1.fi, b = b1.fi;
	if(a.fi / bl != b.fi / bl){
		return (a.fi / bl) < (b.fi / bl);
	}
	return a.se < b.se;
}

int main(){
	//freopen("input.in", "r", stdin);
	//freopen("output.out", "w", stdout);
	int n, q;
	scanf("%d%d", &n, &q);
	vi c(n + 1);
	repn(i, 1, n + 1) scanf("%d", &c[i]);
	vector<pair<pi, int>> p(q);
	bl = (int)sqrt(n);
	rep(i, q) cin >> p[i].fi.fi >> p[i].fi.se, p[i].se = i;
	vi ans(q);
	sort(all(p), cmp);
	int curL = 0, curR = 0;
	int un = 0;
	vi cnt(6e5 + 5, 0);
	rep(i, q){
		int l = p[i].fi.fi, r = p[i].fi.se;
		while(curR <= r){
			if(!cnt[c[curR]]) un++;
			cnt[c[curR]]++;
			curR++;
		}
		while(curR > (r + 1)){
			if(cnt[c[curR - 1]]){
				cnt[c[curR - 1]]--;
				if(!cnt[c[curR - 1]]) un--;
			}
			curR--;
		}
		while(curL < l){
			if(cnt[c[curL]]){
				cnt[c[curL]]--;
				if(!cnt[c[curL]]) un--;
			}
        		curL++;
		}
		while(curL > l){
			if(!cnt[c[curL - 1]]) un++;
			cnt[c[curL - 1]]++;
			curL--;
		}
		ans[p[i].se] = un;
	}
	rep(i, q) printf("%d\n", ans[i]);
	return 0;
}
/*
Things to look out for:
	- Integer overflows
	- Array bounds
	- Special cases
Be careful!
*/


Measured memory_bytes: 15836
import std.stdio,std.ascii,std.conv,std.string,std.algorithm,std.range,std.functional,std.math,core.bitop;
 
void main()
{
    int num;
    auto a=readln.chomp.to!int;
    for(int i=0;i<=a;i++){
        if(i%2==0)continue;

        int b;
        for(int j=1;j<=i;j++){
            if(i%j==0)b++;
        }
        if(b==8)num++;
    }
    writeln(num);
}

Measured memory_bytes: 256
n = int(input())
a = list(map(int,input().split()))
m = 0
b = []
for i in range(n):
    if a[i] < 0:
        m += 1
    b.append(abs(a[i]))
b.sort()
sb = sum(b)
if m % 2 == 0:
    print(sb)
else:
    print(sb-b[0]*2)

Measured memory_bytes: 14412
from fractions import gcd

n = int(input())
a = list(map(int, input().split()))

left = [0 for _ in range(n + 1)]
right = [0 for _ in range(n + 1)]
for i in range(n):
    left[i + 1] = gcd(left[i], a[i])

for i in reversed(range(n)):
    right[i] = gcd(right[i + 1], a[i])

ans = 0
for i in range(n):
    l = left[i]
    r = right[i+1]
    ans = max(ans, gcd(l, r))

print(ans)

Measured memory_bytes: 16108
#include<vector>
#include<cmath>
#include<map>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<stack>
#include<bitset>
#include<functional>
#include<ctime>
#include<queue>
#include<deque>
#include<complex>
#include<cassert>
using namespace std;
#define pb push_back
#define pf push_front
typedef long long lint;
typedef complex<double> P;
#define mp make_pair
#define fi first
#define se second
typedef pair<int,int> pint;
#define All(s) s.begin(),s.end()
#define rAll(s) s.rbegin(),s.rend()
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
//問題文および制約はちゃんと確認しよう！
//サイズは10^5じゃなくて2×10^5とかかもしれないし、重要な制約・条件を見落としているかも
//とりあえずサンプルを読んでから解法を考えよう？
lint dp[3010][3010];
int a[3010];
lint mo=998244353;
int main()
{
	int n,s;
	cin>>n>>s;
	rep(i,n) cin>>a[i];
	memset(dp,0,sizeof(dp));dp[0][0]=1;
	rep(i,n) rep(j,s+1){
		dp[i][j]%=mo;
		dp[i+1][j]+=dp[i][j]*2;
		if(j+a[i]<=s) dp[i+1][j+a[i]]+=dp[i][j];
	}
	cout<<dp[n][s]%mo<<endl;
}


Measured memory_bytes: 74420
#include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>

// author:Swastik Banerjee

using namespace std;

typedef long long ll;
#define MOD 1000000007

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



  ll N;
  cin >> N;

  ll arr[N];
  for (ll i = 0; i < N; i++) {
    cin >> arr[i];
  }

  ll minn = LLONG_MAX;
  ll count = 0;
  for (ll i = 0; i < N; i++) {
    if (arr[i] < minn) {
      count++;
      minn = arr[i];
    }
  }

  cout << count << '\n';
}

Measured memory_bytes: 1792
#include <iostream>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
using namespace std;

pair<vector<uint64_t>, vector<uint64_t>> make_two_pattern_striped_tables(size_t length)
{
    pair<vector<uint64_t>, vector<uint64_t>> striped_tables = make_pair(vector<uint64_t>(length, 0),
                                                                        vector<uint64_t>(length, 0));

    bool flag = true;    
    for(size_t i = 0; i < length; ++i)
    {
        if (flag) {
            striped_tables.first[i]  = 0;
            striped_tables.second[i] = 1;
        } else {
            striped_tables.first[i]  = 1;
            striped_tables.second[i] = 0;
        }
        flag = flag ? false : true;
    }

    // for(size_t i = 0; i < length; ++i) { cout << striped_tables.first[i]; }
    // cout << endl;
    // for(size_t i = 0; i < length; ++i) { cout << striped_tables.second[i]; }
    // cout << endl;
    
    return std::move(striped_tables);
}

size_t count_different_values(const vector<uint64_t>& array_a, const vector<uint64_t>& array_b)
{
    assert(array_a.size() == array_b.size());

    size_t count = 0;
    for(size_t i = 0; i < array_a.size(); ++i)
    {
        if (array_a[i] != array_b[i]) {
            ++count;
        }
    }

    return count;
}

size_t count_up_elemnts_to_change_value(pair<vector<uint64_t>, vector<uint64_t>> striped_tables, const vector<uint64_t>& bit_array)
{
    assert(striped_tables.first.size()  == bit_array.size());
    assert(striped_tables.second.size() == bit_array.size());

    size_t count_a = count_different_values(striped_tables.first,  bit_array);
    size_t count_b = count_different_values(striped_tables.second, bit_array);

    return min(count_a, count_b);
}

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

    string bit_str = "";
    cin >> bit_str;
    assert(1 <= bit_str.size() && bit_str.size() <= pow(10, 5));

    auto bit_array = vector<uint64_t>(bit_str.size(), 0);
    for(size_t i = 0; i < bit_str.size(); ++i)
    {
        if (bit_str[i] == '0') {
            bit_array[i] = 0;
        } else if (bit_str[i] == '1') {
            bit_array[i] = 1;
        } else {
            assert(false);
        }
    }

    auto striped_tables = make_two_pattern_striped_tables(bit_array.size());
    size_t count = count_up_elemnts_to_change_value(striped_tables, bit_array);
    cout << count << endl;
}

Measured memory_bytes: 4432
// ABC155_C
#include <algorithm>
#include <bitset>  // static_cast<std::bitset<8>>
#include <cctype>  // std::isdigit()
#include <climits>  // INT_MIN
#include <cmath>
#include <cstring>  // std::memset
#include <functional>  // std::greater<T>()
#include <iomanip>
#include <iostream>
#include <iterator>
#include <numeric>  // accumulate(ALL(vec), 0)  0 は初期値
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <set>
#include <sstream>  // std::stringstream
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>  // std::swap()
#include <vector>
using namespace std;

typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> pll;
#define rep(i, n) for (ll i=0; i < n; i++)  // 0 ~ n-1
#define rep1(i, n) for (ll i=1; i <= n; i++)  // 1 ~ n
#define repr(i, n) for (ll i=n-1; i >= 0; i++)  // n-1 ~ 0
#define all(vec) (vec).begin(), (vec).end()
#define sum(vec) accumulate(all(vec), 0LL)  // 0 は初期値
#define min_vec(vec) min_element(all(vec))  // iterator: * を先頭につける
#define max_vec(vec) max_element(all(vec))  // iterator: * を先頭につける
#define idx(vec, element_iter) distance((vec).begin(), element_iter)
const ll INF = 1LL<<60;  // 10^18（const int inf = 1<<29;）
const double PI = acos(-1);

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
    
    // input(sunippets: inpv, inpn, inps)
    ll N;
    cin >> N;
    map<string, ll> mp;
    string str;
    rep(i, N) {
        cin >> str;
        mp[str]++;
    }
    
    // calculation
    auto begin = mp.begin(), end = mp.end();
    vector<pair<ll, string>> vec;
    pair<ll, string> p;
    for (auto itr = begin; itr != end; itr++) {
        // first: key, second: value 
        p = make_pair(itr->second, itr->first);
        vec.push_back(p);
    }
    sort(vec.begin(), vec.end(), greater<>());  // ll big -> small
    ll mx = vec[0].first;
    
    vector<string> v_str;
    rep(i, vec.size()) {
        if (vec[i].first == mx) {
            v_str.push_back(vec[i].second);
        }
    }
    sort(v_str.begin(), v_str.end());
    rep(i, v_str.size()) {
        cout << v_str[i] << "\n";
    }
    
    return 0;
}


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

class Main {
	public static void main(String[] args)throws IOException {
		
		BufferedReader br =
				new BufferedReader(new InputStreamReader(System.in));
		
		String str = br.readLine();
		
		 String[] aaa = str.split(" ");
			
		 int count = aaa.length;
		 int[] bbb = new int[count];
		 
		 for(int i = 0; i < bbb.length;i++) {
			 bbb[i] = Integer.parseInt(aaa[i]);
		 }
		 
		 if(bbb[0]>= (bbb[2]+bbb[4]) && (bbb[2]-bbb[4]) >=0) {
			 if(bbb[1]>=(bbb[3]+bbb[4]) && (bbb[3]-bbb[4])>=0) {
				 System.out.println("Yes");
			 }
			 else {
				 System.out.println("No");
			 }
		 }
		 else {
			 System.out.println("No");
		 }
	}
}

Measured memory_bytes: 24320
#include <iostream>

int main()
{
	int N = 0;
	std::cin >> N;

	int ans = 0;
	if (N / 100 == 7)
	{
		std::cout << "Yes\n";
		return 0;
	}

	ans = (N / 100) * 10;
	if (N / 10 - ans == 7)
	{
		std::cout << "Yes\n";
		return 0;
	}

	ans = (N / 10) * 10;
	if (N - ans == 7)
	{
		std::cout << "Yes\n";
		return 0;
	}

	std::cout << "No\n";
	return 0;
}

Measured memory_bytes: 3600
## coding: UTF-8
from itertools import permutations

N,M = map(int,input().split())

graph = []
for i in range(M):
    graph.append(list(map(int, input().split())))
#print(graph)

point = [i+1 for i in range(1,N)]
root = list(permutations(point, N-1))
#print(root)

counter = 0
for i in range(len(root)):
    pairs = []
    pairs.append([1, root[i][0]])
    #print(root[i])
    for j in range(N-2):
        pairs.append([root[i][j], root[i][j+1]])
    #print('i:{},root[i]:{},pairs:{}'.format(i, root[i], pairs))
    status = True
    for k in range(len(pairs)):
        tester = sorted(pairs[k])
        #print('pairs[k]:{}, tester:{}, in graph?:{}'.format(pairs[k], tester, (tester in graph)))
        if(not(tester in graph)):
            status = False
    #print('status:{}'.format(status))
    if(status):
        counter += 1
print(counter)

'''
counter = 0
for i in range(len(root)):
    print('i:{},root[i]:{}'.format(i, root[i]))
    spot = 1
    for j in range(N-1):
        #勧めるなら進む
        n = root[i][j]
        print('spot:{}, n:{}'.format(spot, n))
        if(spot < n):
            if([spot, n] in graph):
                spot = n
            else:
                continue
        elif(spot > n):
            if([n, spot] in graph):
                spot = n
            else:
                continue
        else:
            continue
'''        





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

#define whole(f, x, ...)                                 \
  ([&](decltype((x)) whole) {                            \
    return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
  })(x)

using namespace std;
using ll = long long;

void solve() {
  int n, m;
  cin >> n >> m;

  vector<vector<int>> G(n + 1);
  vector<int> prev(n + 1, -1);
  for (int i = 0; i < m; ++i) {
    int a, b;
    cin >> a >> b;
    G[a].push_back(b);
    G[b].push_back(a);
  }

  vector<int> dist(n + 1, -1);
  queue<int> que;
  dist[1] = 0, que.push(1);
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    for (auto nv : G[v]) {
      if (dist[nv] == -1) {
        dist[nv] = dist[v] + 1;
        prev[nv] = v;
        que.push(nv);
      }
    }
  }

  bool ok = true;
  for (int i = 2; i <= n; i++) {
    if (prev[i] == -1) {
      ok = false;
      break;
    }
  }

  if (ok) {
    cout << "Yes" << endl;
    for (int i = 2; i <= n; i++) {
      cout << prev[i] << endl;
    }
  } else {
    cout << "No" << endl;
  }
}

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  std::cout << std::fixed << std::setprecision(15);

  solve();
  return 0;
}


Measured memory_bytes: 10492
N, C = map(int, input().split())
L = [list(map(int, input().split())) for _ in range(N)]
L.sort(key=lambda x: x[0])
R = [(L[0][1], L[0][2])]
for s, t, c in L[1:]:
    for i, (t_r, c_r) in enumerate(R):
        if c == c_r and t_r <= s:
            R[i] = (t, c)
            break
        if c != c_r and t_r < s:
            R[i] = (t, c)
            break
    else:
        R.append((t, c))
print(len(R))


Measured memory_bytes: 29164
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>

using namespace std;
typedef long long ll;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define DEC(i, s) for (int i = (s); i >= 0; i--)

#define SIZE(v) (int)((v).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define FIND(m, w) ((m).find(w) != (m).end())

int n;
int field[6][6];
char memo[1 << 24];

void printField() {
  REP(y, n) {
    REP(x, n) {
      cout << field[y][x] << " ";
    }
    cout << endl;
  }
}

int encode() {
  int ret = 0;
  REP(y, n) REP(x, n) {
    if (y == 0 && x == 0) { continue; }
    ret |= field[y][x] << ((y * 5) + x - 1);
  }
  return ret;
}

int calc(int y, int x) {
  int state = encode();
  if (memo[state] != -1 && y != 0 && x != 0) { return memo[state]; }
  int ret = 100;
  if (x == n) { ret = calc(y + 1, 0); }
  else if (y == n) { ret = 0; }
  else if (field[y][x] == 0) { ret = calc(y, x + 1); }
  else {
    field[y][x] = 0;
    FOREQ(ny, y + 1, n) {
      FOREQ(nx, x + 1, n) {
        field[ny][x] ^=1;
        field[y][nx] ^=1;
        field[ny][nx] ^=1;
        ret = min(ret, calc(y, x + 1) + 1);
        field[ny][x] ^=1;
        field[y][nx] ^=1;
        field[ny][nx] ^=1;
      }
    }
    field[y][x] = 1;
  }
  if (y == 0 && x == 0) { return ret; }
  return memo[state] = ret;
}

int main() {
  MEMSET(memo, -1);
  while (scanf("%d", &n), n) {
    MEMSET(field, 0);
    REP(y, n) REP(x, n) {
      scanf("%d", &field[y][x]);
    }
    REP(y, n) REP(x, n) {
      if (field[y][x] == 1) {
        FOR(ny, y, n) FOR(nx, x, n) {
          field[ny][nx] ^= 1;
        }
        field[y][x] = 1;
      }
    }
    int ans = calc(0, 0);
    while (ans--) { printf("myon"); }
    puts("");
  }
}

Measured memory_bytes: 16000
#include<stdio.h>
char a[101], b[101], c[101];
int la, lb, lc, na=0, nb=0, nc=0;
char turn;

int len(char *s) {
    int l=0;
    while(s[++l]);
    return l;
}

char go(char turn) {
    switch(turn) {
    case 'a':
        if(na<la) return a[na++];
        else return 'A';
    case 'b':
        if(nb<lb) return b[nb++];
        else return 'B';
    case 'c':
        if(nc<lc) return c[nc++];
        else return 'C';
    }
}

int main() {
    char turn;
	scanf("%s%s%s", a, b, c);

	la=len(a);
	lb=len(b);
	lc=len(c);

	turn='a';

	while(1) {
        turn=go(turn);
        if(turn == 'A') {
            printf("A");
            break;
        }
        else if(turn == 'B') {
            printf("B");
            break;
        }
        else if(turn == 'C') {
            printf("C");
            break;
        }
    }

	return 0;
}


Measured memory_bytes: 128
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
 
#ifdef BTK
#include<dvector.h>
#define DEBUG if(1)
#else
#define CIN_ONLY if(1)
struct cww{cww(){
    CIN_ONLY{
        ios::sync_with_stdio(false);cin.tie(0);
    }
}}star;
#define DEBUG if(0)
#endif
 
#define fin "\n"
#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
#define pb push_back
#define REC(ret, ...) std::function<ret (__VA_ARGS__)>
template <typename T>inline bool chmin(T &l,T r)
{bool a=l>r;if(a)l=r;return a;}
template <typename T>inline bool chmax(T &l,T r)
{bool a=l<r;if(a)l=r;return a;}
template <typename T>
istream& operator>>(istream &is,vector<T> &v){
    for(auto &it:v)is>>it;
    return is;
}
typedef __int128 INT;
 
 
int N;
int a[112345];
int b[112345];
INT c[112345];
INT s[112345];
int sub[112345];
 
typedef vector<int> V;
typedef vector<V> VV;
 
VV g;
 
INT ab(INT a){
    if(a<0)return -a;
    else return a;
}
INT tot ;
int tde = -1;
int cnt;
void dfs(int v,int p){
    sub[v]=1;
    for(auto &e:g[v]){
        int u = a[e]^b[e]^v;
        if(u==p)continue;
        dfs(u,v);
        sub[v]+=sub[u];
    }
    for(auto &e:g[v]){
        int u = a[e]^b[e]^v;
        if(u==p)continue;
        INT cnum = sub[u];
        INT vnum = N-sub[u];
        if(cnum!=vnum){
            c[e] = ab(s[v]-s[u]) / ab(cnum-vnum);
            tot -= c[e]*sub[u];
        }
        else {
            tde=e;
            cnt = sub[u];
        }
    }
}
 
 
 
int main(){
    cin>>N;
    g.resize(N);
    REP(i,N-1){
        cin>>a[i]>>b[i];
        a[i]--;
        b[i]--;
        g[a[i]].pb(i);
        g[b[i]].pb(i);
    }
    REP(i,N){
        LL x;
        cin>>x;
        s[i]=x;
    }
    tot = s[0];
    dfs(0,0);
    if(tde>=0)c[tde] = tot/cnt;
    REP(i,N-1){
        cout<<(LL)c[i]<<endl;
    }
    return 0;
}


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

int f(int a, int b, int n){
	int s = 0;
	a = a % b;
	for(int i = 0; i < n; i++){
		a = a * 10;
		s += a / b;
		a = a % b;
	}
	return s;
}

int main(){
	int a, b, n;
	while(cin >> a >> b >> n){
		cout << f(a, b, n) << endl;
	}
	return 0;
}

Measured memory_bytes: 0
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        String[] words = sc.nextLine().split(",");
        String haiku = words[0] + " " + words[1] + " " + words[2];
        System.out.println(haiku);
    }
}


Measured memory_bytes: 21716
#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
    long long n, k;
    std::cin >> n >> k;

    long long ans = k;
    for (int i = 1; i < n; i++) {
        ans *= (k - 1);
    }

    std::cout << ans << std::endl;
}


Measured memory_bytes: 256