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

using ll = long long;
using P = pair<int, int>;
using PP = pair<int, P>;
#define rep1(i,n) for (int i=1; i<=(n); i++)
#define rep0(i,n) for (int i=0; i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#ifdef _DEBUG
string _format(string args) { string r = "", t; istringstream s(args); while (getline(s, t, ',')) r += t+":%d "; return r + "\n"; }
#define debug(...) do{printf(_format(#__VA_ARGS__).c_str(), __VA_ARGS__);}while(0)
#define FAST_IOSTREAM() do{}while(0);
#else
#define debug(...) do{}while(0)
#define FAST_IOSTREAM() do{std::ios::sync_with_stdio(false); std::cin.tie(nullptr);}while(0)
#endif

bool lunlun(ll a) {
    while (a >= 10) {
        if (abs((a % 10) - ((a / 10) % 10)) > 1) return false;
        a /= 10;
    }
    return true;
}

int main() {
    FAST_IOSTREAM();

    int k;
    cin >> k;

    priority_queue<ll, vector<ll>, greater<ll>> q;

    rep1(i,9) q.push(i);
    for (int i=1; i<k; i++) {
        ll a = q.top();
        debug(a);
        q.pop();
        ll d = a % 10;
        if (d != 0) q.push(a*10 + d - 1);
        q.push(a*10 + d);
        if (d != 9) q.push(a*10 + d + 1);
    }

    cout << q.top() << endl;
}


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

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

    vector<int> v;
    int cnt=0;
    for(int i=0;i<9;i++){
        for(int j=0;j<9;j++){
            v.push_back((i+1)*(j+1));
            cnt++;
        }
    }
    string out;
    for(auto ve : v){
        if(ve==n){
            out = "Yes";
        }
    }
    if(out!="Yes"){
        out="No";
    }
    cout << out << endl;

    return 0;
}

Measured memory_bytes: 256
n, m = [int(v) for v in input().split()]

connect_list = [0 for i in range(n)]
for i in range(m):
  a, b = [int(v) for v in input().split()]
  connect_list[a-1] += 1
  connect_list[b-1] += 1
for i in range(n):
  print(connect_list[i])

Measured memory_bytes: 3060
package main
 
import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var N int
var NotFound bool
func main() {
	N := scanInt()
	NotFound = true
	for NotFound {
		isPrime := Prime(N)
		if isPrime {
			fmt.Println(N)
			NotFound = false
		} else {
			N++
		}
	}
}

func Prime(n int) bool {
	for i := 2; i < n; i++ {
		if n % i == 0 {
			return false
		}
	}
	return true
}

 
// --------------- BASE DEFINITIONS ---------------

var sc = bufio.NewScanner(os.Stdin)
 
func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1024*1024), bufio.MaxScanTokenSize)
}

func scanInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}
 
func scanIntSlice(n int) []int {
	is := make([]int, n)
	for i := 0; i < n; i++ {
		is[i] = scanInt()
	}
 
	return is
}


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

int main() {
  llong l, r;
  cin >> l >> r;
  int mod = 2019;
  r = min(r, l + mod);
  int ans = 2020;
  for (llong i = l; i <= r; i++) {
    for (llong j = i + 1; j <= r; j++) {
      int ij = i * j % mod;
      ans = min(ij, ans);
    }
  }
  cout << ans << endl;
  return 0;
}

Measured memory_bytes: 256
import math

def dis(n,x,y):
    distance = 0
    for i in range(len(x)):
        distance += (x[i]-y[i])*(x[i]-y[i])
    # print(distance)
    return math.sqrt(distance)



n,d = [int(i) for i in input().split()]
x = [[int(i) for i in input().split()] for i in range(n)] 
# print(x)
ans = 0
for i in range(n):
    for j in range(i+1,n):
        # print(dis(d,x[i],x[j]))
        # print(dis(d,x[i],x[j]).is_integer())
        if(dis(d,x[i],x[j]).is_integer()):
            ans += 1
print(ans)



Measured memory_bytes: 3064
#!/usr/bin/env python3

import collections


def process_queries(ds, queries):
    table = collections.Counter(ds)
    s = sum(ds)
    for b, c in queries:
        table[c] += table[b]
        s += (c - b) * table[b]
        table[b] = 0
        yield s


def main():
    n = int(input())
    ds = [int(d) for d in input().split()]
    q = int(input())
    queries = [tuple(int(x) for x in input().split()) for _ in range(q)]
    print(*process_queries(ds, queries), sep="\n")


if __name__ == '__main__':
    main()

Measured memory_bytes: 39072
/*
 * Author: .-O_O-.
 */
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include<bits/stdc++.h>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define pb push_back
#define vi vector<int>
#define rep0(a,b) for(int a=0;a<b;a++)
#define rep1(a,b) for(int a=1;a<=b;a++)
#define repp(a,b,c) for(int a=b;a<c;a++)
#define in insert
#define len length()
#define si size()
#define lb lower_bound
#define ub upper_bound
#define beg begin()
#define en end()
#define f first
#define s second
#define pr(a) cout<<a
#define pr2(a,b) cout<<a<<" "<<b<<"\n"
#define nx cout<<"\n"
#define int long long
// void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
                                                     
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]"<<endl;}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
const ll mod = 1000000007;
const ll N = 105;
const ll mm = 1e+18;
void solve()
{
    int n;
    cin>>n;
    int ans=1;
    rep1(i,n){
        ans=(ans*i)%mod;
    }
    pr(ans);
}
signed main()
{
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int t=1;
    //cin>>t;
    rep1(_i,t){
        //cout<<"Case #"<<_i<<": ";
        solve();
        //nx;
    }
    return 0;
}

Measured memory_bytes: 3588
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template<class T>inline bool chmax(T &a, const T &b){if(a < b){a = b; return 1;}return 0;}
template<class T>inline bool chmin(T &a, const T &b){if(a > b){a = b; return 1;}return 0;}
typedef long long ll;
int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  int N; cin >> N;
  vector<ll> a(N, 0); vector<ll> b(N, 0); vector<ll> c(N, 0);
  REP(i, N){
    cin >> a[i] >> b[i] >> c[i];
  } 
  vector<vector<ll> > dp(N, vector<ll>(3, 0));
  dp[0][0] = a[0]; dp[0][1] = b[0]; dp[0][2] = c[0];
  for(int i = 1; i < N; i++){
    dp[i][0] = max(dp[i-1][1], dp[i-1][2]) + a[i];
    dp[i][1] = max(dp[i-1][0], dp[i-1][2]) + b[i];
    dp[i][2] = max(dp[i-1][0], dp[i-1][1]) + c[i];
  }
  cout << max({dp[N-1][0], dp[N-1][1], dp[N-1][2]}) << endl;
  return 0;
}


Measured memory_bytes: 8064
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <iterator>
#include <set>
#include <queue>
#include <bitset>
#include <cassert>

using namespace std;


int main() {

    string S;
    cin >> S;
    if (S[S.size() - 1] == 's') {
        S += "es";
    } else {
        S += 's';
    }

    cout << S << endl;

    return 0;

}

Measured memory_bytes: 3624
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<pair<ll,ll>> primes;
vector<ll> factors;
void dfs(ll ind,ll val){
 if(ind==primes.size()){
  factors.push_back(val);
  return;
 }
 ll lmt=primes[ind].second;
 ll p=1;
 dfs(ind+1,val);
 for(ll i=1;i<=lmt;i++){
  p*=primes[ind].first;
  dfs(ind+1,val*p);
 }
}
int main(){
 ll n,k;
 cin >> n >> k;
 vector<ll> a(n);
 ll sum=0;
 for(ll i=0;i<n;i++) {cin >> a[i];sum+=a[i];}
 for(ll i=2;i*i<=sum;i++){
  if(sum%i) continue;
  ll cnt=0;
  while(sum%i==0){
   sum/=i;
   cnt++;
  }
  primes.push_back({i,cnt});
 }
 if(sum!=1) primes.push_back({sum,1});
 dfs(0,1);
 sort(factors.rbegin(),factors.rend());
 for(ll f:factors){
  vector<ll> b;
  ll s=0;
  for(ll i=0;i<n;i++){
   b.push_back(f-a[i]%f);
   s+=b[i];
  }
  ll x=s/f;
  sort(b.rbegin(),b.rend());
  ll ans=0;
  for(ll i=0;i<x;i++){
   ans+=(f-b[i]);
  }
  if(ans<=k){
   cout << f << endl;
   return 0;
  }
 }
 return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include <tuple>
#include <cstdio>
#include <bitset>
#include <sstream>
#include <iterator>
#include <numeric>
#include <map>
#include <cstring>
#include <set>
#include <functional>
#include <iomanip>

using namespace std;

#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
	#define dump(x)  cerr << #x << " = " << (x) << endl;
#else
	#define dump(x)  ;
#endif

#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back

//#define int long long

typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;

template <typename T>
std::string printVector(const std::vector<T> &data)
{
    std::stringstream ss;
    std::ostream_iterator<T> out_it(ss, ", ");
    ss << "[";
    std::copy(data.begin(), data.end() - 1, out_it);
    ss << data.back() << "]";
    return ss.str();
}

const int MOD = 1e9+7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
int ans = 0;
int cnt[13] = {};
int a[30];

int solve(int mask){
    int n = 0;
    a[n++] = 0;
    for(int i = 0; i < 12; i++){
        if(cnt[i+1] == 0) continue;
        if(cnt[i+1] == 2){
            a[n++] = i+1;
            a[n++] = -(i+1);
            continue;
        }
        if((mask >> i) & 1)
            a[n++] = i+1;
        else
            a[n++] = -(i+1);
    }
    sort(a,a+n);
    a[n++] = a[0] + 24;
    int res = 24;
    for(int i = 0; i < n-1; i++)
        res = min(res, a[i+1]-a[i]);

    return res;

}

signed main(int argc, char const *argv[])
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N; cin >> N;
    VI D(N);
    cnt[0]++;
    REP(i,N) {
        cin >> D[i];
        cnt[D[i]]++;
    }
    FOR(i,1,13){
        if(cnt[i] > 2){
            cout << 0 << endl;
            return 0;
        }
    }
    if(cnt[0] >= 2){
        cout << 0 << endl;
        return 0;
    }

    for(int mask = 0; mask < (1 << 12); mask++){
        ans = max(ans,solve(mask));
    }
    cout << ans << endl;


}


Measured memory_bytes: 256
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AtCoder_067_B
{
    class Program
    {
        static void Main(string[] args)
        {
            var input_stick = Console.ReadLine().Split(' ');
            int N = int.Parse(input_stick[0]);
            int K = int.Parse(input_stick[1]);
            int sum = 0;

            var input_lenght = Console.ReadLine().Split(' ');
            int[] L = new int[N];
            for (int i = 0; i < N; i++)
            {
                L[i] = int.Parse(input_lenght[i]);
            }

            Array.Sort(L);
            Array.Reverse(L);

            for (int i = 0; i < K; i++)
            {
                sum += L[i];
            }

            Console.WriteLine(sum);
        }
    }
}

Measured memory_bytes: 13140
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};

int main() {
  ll a, b, k;
  cin >> a >> b >> k;
  rep(i, k) {
    if(i % 2) {
      b /= 2;
      a += b;
    } else {
      a /= 2;
      b += a;
    }
  }
  cout << a << ' ' << b << endl;
}

Measured memory_bytes: 256
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
int main()
{
    char c;
    cin>>c;
    if(c - 97<0)
    {
        cout<<'A'<<'\n';
    }
    else
    {
        cout<<'a'<<'\n';
    }
    
}

Measured memory_bytes: 3596
#include <stdio.h>

int main(void){
	int n, a, b, c, d, count = 0;
	while(scanf("%d", &n) != EOF){
		for(a = 0; a <= 9; a++)
		{
			for(b = 0; b <= 9; b++)
			{
				for(c = 0; c <= 9; c++)
				{
					for(d = 0; d <=9; d++)
					{
						if(a + b + c + d == n)
							count += 1;
					}
				}
			}
		}
		printf("%d\n", count);
		count = 0;
	}
	return 0;
}

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

#define rep(i, a, n) for (int i = a; i < n; i++)
#define asc(v) sort(v.begin(), v.end())
#define desc(v) sort(v.begin(), v.end(), greater<int>())

using namespace std;

int main() {
  int A, B;
  cin >> A >> B;
  if (A <= 8 && B <= 8)
    cout << "Yay!" << endl;
  else
    cout << ":(" << endl;
  return 0;
}

Measured memory_bytes: 256
class Card:
    def __init__(self):
        self.suit = ""
        self.value = ""

def bubbleSort(C, N):
    flag = 1
    while flag:
        flag = False
        for j in reversed(range(1,N)):
            if C[j][1] < C[j-1][1]:
                C[j],C[j-1] = C[j-1],C[j]
                flag = True

def selectionSort(C, N):
    for i in range(N):
        minj = i
        for j in range(i,N):
            if C[j][1] < C[minj][1]:
                minj = j
        C[i],C[minj] = C[minj],C[i]

def check(L1,L2):
    if L1 == L2:
        return 'Stable'
    else:
        return 'Not stable'

N = int(input())
C = list(input().split())
from copy import deepcopy
L1 = deepcopy(C)
L2 = deepcopy(C)

bubbleSort(L1,N)
selectionSort(L2,N)

print(*L1)
print('Stable')
print(*L2)
print(check(L1,L2))


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

int main(){

	ios::sync_with_stdio(0);
	cin.tie(0);

	#ifndef ONLINE_JUDGE
		freopen("input.txt","r",stdin);
		freopen("output.txt","w",stdout);
	#endif
	string s,t;
	cin>>s>>t;
	int ans = 0;
	for(int i=0;i<s.length();i++){
		if(s[i] != t[i])ans++;
	}
	cout<<ans;
		
	return 0;
}

Measured memory_bytes: 3824
import sys, re
INPUT = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 9)


def main():
    S = INPUT().replace("?", ".")
    T = INPUT()

    for i in range(len(S)-len(T), -1, -1):
        if re.match(S[i: i+len(T)], T):
            S = S.replace(".", "a")
            print(S[:i] + T + S[i+len(T):])
            exit()

    print("UNRESTORABLE")


if __name__ == '__main__':
    main()


Measured memory_bytes: 38512
//
//  main.cpp
//  atCoder
//
//  Created by Lynn Zhou on 10/19/15.
//
//

#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
    int m,f,r;
    while (1) {
    cin>>m>>f>>r;
        if (m==-1 && f==-1 && r==-1)
            break;
    else if(m==-1 || f==-1 || m+f<30)
        cout<<"F"<<endl;
    else if(m+f>=80)
        cout<<"A"<<endl;
    else if(m+f>=65)
        cout<<"B"<<endl;
    else if (m+f>=50)
        cout<<"C"<<endl;
    else if(m+f>=30){
        if(r>=50)
            cout<<"C"<<endl;
        else
            cout<<"D"<<endl;
    }
    }
    return 0;
    
}

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

int main(void) {

int A;
int B;
int C;
int D;
int E;

cin >> A;
cin >> B;
cin >> C;
cin >> D;
cin >> E;

if ( A == 0 ) {
cout << 1 << endl;
}

if ( B == 0 ) {
cout << 2 << endl;
}

if ( C == 0 ) {
cout << 3 << endl;
}

if ( D == 0 ) {
cout << 4 << endl;
}

if ( E == 0 ) {
cout << 5 << endl;
}

return 0;
}


Measured memory_bytes: 3588
#include <stdio.h>
#include <stdbool.h>
#define NUM 10

int main()
{
  int n;
  int left,right;
  int i,j;
  int num;
  bool flag=true;

  scanf("%d",&n);
  for(i=0;i<n;i++){
    left=-1;
    right=-1;
//    flag=true;
    for(j=0;j<NUM;j++){
      scanf("%d",&num);
      if(num<left&&num<right){
        flag=false;
        break;
//      }else if(left<right&&right<num){
//        right=num;
      }else if(left<num){
        left=num;
      }else{
        right=num;
      }
    }
    puts((flag)?"YES":"NO");
  }
  return 0;
}

Measured memory_bytes: 576
/*
  || Shree Ganeshay Namah ||

     || Jai Shree Ram ||
  || Nabh Sparsham Diptam ||
*/
#include<bits/stdc++.h>
using namespace std;
typedef  long long int ll;
#define mod 1000000007
#define block 180
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define f1 first
#define s1 second
#define pb push_back
// to floor a/b you can do a/b and to ceiling a/b you can do (a+b-1)/b
int jai_shree_ram()
{
    return 1;
}
int shree_ganeshay_namah()
{
    return 1;
}
ll power(ll x,ll y)
{
    ll r=1;
    while(y>0)
    {
        if(y%2!=0)
            r=(r*x);
        x=(x*x);
        y=y/2;
    }
    return r;
}
ll ncr(ll n,ll k)
{

    ll c[k+1];
    memset(c,0,sizeof(c));
    c[0]=1;
    for(ll i=1;i<=n;i++)
    {
        for(ll j=min(i,k);j>0;j--)
            c[j]=(c[j]%mod + c[j-1]%mod)%mod;
    }
    return c[k];
}

bool prime[1000001];
void sieve()
{
    ll i,j;
    memset(prime,true,sizeof(prime));
    prime[0]=false;
    prime[1]=false;
    for(i=2;i<=sqrt(100001);i++)
    {
        if(prime[i])
        {
            for(j=i*i;j<=100001;j=j+i)
                prime[j]=false;
        }
    }
}
//Start of Matrix Exponentiation Code
void mat_mul(ll F[2][2],ll M[2][2]) {
   ll a = ((F[0][0]%mod * M[0][0]%mod)%mod + (F[0][1]%mod * M[1][0]%mod)%mod)%mod;
   ll b = ((F[0][0]%mod * M[0][1]%mod)%mod + (F[0][1]%mod * M[1][1]%mod)%mod)%mod;
   ll c = ((F[1][0]%mod * M[0][0]%mod)%mod + (F[1][1]%mod * M[1][0]%mod)%mod)%mod;
   ll d = ((F[1][0]%mod * M[0][1]%mod)%mod + (F[1][1]%mod * M[1][1]%mod)%mod)%mod;
   F[0][0] = a;
   F[0][1] = b;
   F[1][0] = c;
   F[1][1] = d;
}
void mpower(ll F[2][2], ll n) {
   if (n == 0 || n == 1)
      return;
   ll M[2][2] = {{1,1},{1,0}};
   mpower(F, n / 2);
   mat_mul(F, F);
   if (n % 2 != 0)
      mat_mul(F, M);
}
ll fib_mat(ll n) {
   ll F[2][2] = {{1,1},{1,0}};
   if (n == 0)
      return 0;
   mpower(F, n - 1);
   return F[0][0]%mod;
}
//End of Matrix Exponentiation
/*
Segment Tree
ll ar[200005];
ll st[800005];
void build(ll si,ll ss,ll se)
{
    if(ss==se)
    {
        st[si]=ar[ss];
        return ;
    }
    ll mid=(ss+se)/2;
    build(2*si,ss,mid);
    build(2*si+1,mid+1,se);
    st[si]=(st[2*si]+st[2*si+1]);
}
ll query(ll si,ll ss,ll se,ll l,ll r)
{

   if(l<=ss && se<=r)
     return st[si];
   if(l>se || r<ss)
    return 0;
   ll mid=(ss+se)/2;
   ll x=query(2*si,ss,mid,l,r);
   ll y=query(2*si+1,mid+1,se,l,r);
   return x+y;
}
void update(ll si,ll ss,ll se,ll qi)
{
    if(ss==se)
    {
        st[si]=ar[ss];
        return;
    }
    ll mid=(ss+se)/2;
    if(qi<=mid)
        update(2*si,ss,mid,qi);
    else
        update(2*si+1,mid+1,se,qi);
    st[si]=st[2*si]+st[2*si+1];
}
*/

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll n,k,i,j;
    cin>>n>>k;
    vector<ll>v;
    ll a[n];
    for(i=0;i<n;i++)
        cin>>a[i];
    ll f=1;

    for(i=k;i<n;i++)
    {
        if(a[i]>a[i-k])
            cout<<"Yes\n";
        else
            cout<<"No\n";
    }


    return 0;
}





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


Measured memory_bytes: 3072
L, R = map(int, input().split())

# n mod 2019 の答えは 0 ~ 2018 のいずれか
# それぞれのmodを取った積のmodでも同じ答えになる


def get_ans():
    # 差が2018以上なら積が0の組み合わせが存在する
    if R - L >= 2018:
        return 0

    # 総当たり
    ans = 2019
    for X in range(L, R):
        for Y in range(X + 1, R + 1):
            ans = min((ans, (X * Y) % 2019))
            if ans == 0:
                return 0

    return ans


print(get_ans())

Measured memory_bytes: 3060
#include<stdio.h>
int main(void)
{
    long long n,item,a,b,i,temp;


    scanf("%lld %lld",&a,&b);
    item=a*b;
    if(a<b)  {
        temp=a;
        a=b;
        b=temp;
    }
    for(i=b; i>0; i--) {
        if (a % i == 0 && b % i == 0) {

            break;
        }
    }
    n=item/i;
    printf("%lld",n);
    return 0;
}


Measured memory_bytes: 128
#include<bits/stdc++.h>
using namespace std;
int main(){
	int n , k;
    cin >> n >> k;
    int arr[n+1];
    int dp[n+1] = {1000000};
    for(int i = 1 ; i <= n  ; i++){
    	cin >> arr[i];
    	dp[i] = 1000000000;
    }

    dp[1] = 0;
    for(int i = 2 ; i <= n ; i++){
    	for(int j = i-1 ; j >= i - k ; j--){
        	if(j <= 0)	break;
            dp[i] = min(dp[i] ,dp[j] + abs(arr[i] - arr[j]));
        }
    }
    cout<<dp[n];
}


Measured memory_bytes: 1024
import numpy as np
n,k = map(int,input().split())
field = np.array(input().split(),np.int64)
dp = np.zeros(n,np.int64)
# numpyのブロードキャストとスライスを組み合わせることで1重のfor文で済ますという変態的なことをしてる
# ただ計算量がO(N)になっているかは謎
for i in range(1,n):
  left = max(0,i - k)
  dp[i] = (dp[left:i] + abs(field[left:i] - field[i])).min()
print(dp[-1])

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

typedef long long ll;
typedef vector<string> vs;
#define rep(i, n) for(int i = 0; i < (n); i++)
template<class T> istream& operator >> (istream& s, vector<T>& v)
{ for (T& x: v) { s >> x; } return s;}

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

    int N; cin >> N;
    vector<int> A(N); cin >> A;
    sort(A.begin(), A.end(), greater<int>());

    vector<int> wh;
    for (int i = 1; i < N; i++) {
        if (A[i] == A[i-1]) {
            wh.push_back(A[i]);
            if (wh.size() == 2) break;
            i++;
        }
    }
    ll ans = 0;
    if (wh.size()==2) ans = (ll)wh[0] * wh[1];
    cout << ans << endl;
}


Measured memory_bytes: 640
/**
 * @copyright (c) 2020 Daisuke Hashimoto
 */

#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;

// std::cout << std::setprecision(20) << 1.1 << endl;

const int64_t kMod = 1000000007LL;
// const int64_t kMod = 998244353LL;
struct Mint {
  int64_t value;
  Mint(int64_t value = 0LL) : value((value % kMod + kMod) % kMod) {}
  Mint operator-() const {
    return Mint(-value);
  }
  Mint &operator+=(const Mint rhs) {
    if ((value += rhs.value) >= kMod) {
      value -= kMod;
    }
    return *this;
  }
  Mint &operator-=(const Mint rhs) {
    if ((value += kMod - rhs.value) >= kMod) {
      value -= kMod;
    }
    return *this;
  }
  Mint &operator*=(const Mint rhs) {
    (value *= rhs.value) %= kMod;
    return *this;
  }
  Mint operator+(const Mint rhs) const {
    return Mint(*this) += rhs;
  }
  Mint operator-(const Mint rhs) const {
    return Mint(*this) -= rhs;
  }
  Mint operator*(const Mint rhs) const {
    return Mint(*this) *= rhs;
  }
  Mint Pow(int64_t p) const {
    if (p == 0LL) {
      return 1LL;
    } else if (p < 0LL) {
      return Pow(-p).Pow(kMod - 2LL);
    }
    Mint temp = Pow(p >> 1LL);
    temp *= temp;
    if (p & 1LL) {
      temp *= (*this);
    }
    return temp;
  }
  Mint Inv() const {
    return Pow(kMod - 2LL);
  }
  Mint &operator/=(const Mint a) {
    return *this *= a.Inv();
  }
  Mint operator/(const Mint a) const {
    return Mint(*this) /= a;
  }
};
std::ostream &operator<<(std::ostream &os, const Mint &a) {
  os << a.value;
  return os;
}

class Combination {
 public:
  explicit Combination(const int64_t max_n) : max_n_(max_n), fact_(max_n + 1L), ifact_(max_n + 1L) {
    if (max_n >= kMod) {
      std::cerr << "Combination::Combination: Invalid arg: max_n=" << max_n << ", kMod=" << kMod << std::endl;
      assert(0);
    }
    fact_[0] = 1L;
    for (int64_t i = 1L; i <= max_n; ++i) {
      fact_[i] = fact_[i - 1L] * i;
    }
    ifact_[max_n] = fact_[max_n].Inv();
    for (int64_t i = max_n; i >= 1L; --i) {
      ifact_[i - 1L] = ifact_[i] * i;
    }
  }
  Mint operator()(const int64_t n, const int64_t k) const {
    if (n > max_n_) {
      std::cerr << "Combination::operator(): Invalid arg: n=" << n << ", max_n=" << max_n_ << std::endl;
      throw 1;
    }
    const Mint result = (k < 0L || k > n) ? 0L : (fact_[n] * ifact_[k] * ifact_[n - k]);
    return result;
  }

 private:
  Combination() = delete;

 private:
  const int64_t max_n_;
  std::vector<Mint> fact_;
  std::vector<Mint> ifact_;
};

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

  Combination combination(2e6);
  int64_t X, Y;
  cin >> X >> Y;
  Mint result = 0;
  if ((-X + 2 * Y) % 3 == 0 && (2 * X - Y) % 3 == 0) {
    const int64_t a = (-X + 2 * Y) / 3;
    const int64_t b = (2 * X - Y) / 3;
    result = combination(a + b, a);
  }
  cout << result.value << endl;
  return 0;
}


Measured memory_bytes: 34552
S = list(input())
N = int(len(S))
revS = []
S2 = []
revS2 = []

S3 = []
revS3 = []
def check(S,revS,N):
    count = 0
    for i in range(N):
        revS.append(S[N-count-1])
        count += 1
    if S == revS:
        return 1
    else:
        return 0


for i in range(int((N-1)/2)):
    S2.append(S[i])
for i in range(int((N+3)/2)):
    S3.append(S[int((N+3)/2)-1])
if check(S,revS,N) == 1 and check(S2,revS2,len(S2)) == 1 and check(S3,revS3,len(S3)) == 1:
    print("Yes")
else:
    print("No")




Measured memory_bytes: 3064
#include <iostream>
#include <assert.h>
#include <vector>
#include <unordered_map>
#include <queue>
#include <climits>
#include <cmath>
using namespace std;
constexpr int64_t INF = 1000000000;

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

  int64_t H;
  cin >> H;
  int64_t cnt = 0;
  int64_t phase = 1;
  while (H) {
    H /= 2;
    cnt += phase;
    phase *= 2;
  }

  cout << cnt << endl;
  return 0;
}


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

typedef long long int64;

const int MAX_N = 101;
const int MAX_W = MAX_N * 3;

int64 dp[MAX_N][MAX_W];

int main()
{
  int N, W;
  cin >> N >> W;
  vector< int64 > w(N);
  vector< int64 > v(N);
  vector< int64 > diff(N);
  for (int i = 0; i < N; ++i) {
    cin >> w[i] >> v[i];
    diff[i] = w[i] - w[0];
  }

  int64 sm = 0ll;
  for (int i = 0; i < N; ++i) {
    for (int j = i; j >= 0; --j) {
      for (int64 k = sm; k >= 0; --k) {
	dp[j + 1][k + diff[i]] = max(dp[j + 1][k + diff[i]],
				     dp[j][k] + v[i]);
      }
    }
    sm += diff[i];
  }

  int64 ans = 0ll;
  
  for (int i = 0; i <= N; ++i) {
    for (int j = 0; j < MAX_W; ++j) {
      sm = w[0] * i + j;
      if (sm > W) {
	continue;
      }

      ans = max(ans, dp[i][j]);
    }
  }

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


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

int main() {
  int n;
  cin >> n;
  map<string, int> m;
  string s;
  for (int i = 0; i < n; i++) {
    cin >> s;
    m[s] += 1;
  }

  vector<string> v = {"AC", "WA", "TLE", "RE"};
  for (auto i : v) {
    cout << i << " x " << m[i] << endl;
  }

  return 0;
}


Measured memory_bytes: 3636
function Main(input) {
    input = input.split("\n");
    var mem = input[0].split(" ").map(Number);
    var arr = new Array(mem[0]+1).fill(mem[1]-mem[2]);
    input.shift();
    input.forEach(function(val){
        arr[val]++;
    })
    arr.shift()
    arr.forEach(function(val){
        console.log(val>=1?"Yes":"No");
    })
}Main(require("fs").readFileSync("/dev/stdin","utf8").trim());


Measured memory_bytes: 28648
#include <iostream>
#include <cstdint>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define re0 return 0
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define rSort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
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;
}
struct io
{
    io()
    {
        ios::sync_with_stdio(false);
        cin.tie(0);
    }
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;

string replaceOtherStr(std::string &replacedStr, std::string from, std::string to) {
    const ll pos = replacedStr.find(from);
    const ll len = from.length();
 
    if (pos == (ll)std::string::npos || from.empty()) {
        return replacedStr;
    }
 
    return replacedStr.replace(pos, len, to);
}


signed main() {
    ll x, y;
    cin >> x >> y;
    ll cnt = 2;
    if (x % y == 0) {
        mes(-1);
        re0;
    }
    while (true) {
        if ((x *cnt) % y != 0) {
            mes(x*cnt);
            re0;
        }
        cnt++;
    }
   
    
    
}


Measured memory_bytes: 3644
# ARC064C - Boxes and Candies (ABC048C)
def main():
    n, x = map(int, input().split())
    A = list(map(int, input().split()))

    # modify A[0] if >x
    ans = 0 if A[0] < x else A[0] - x
    A[0] = min(A[0], x)

    prv = A[0]
    for i in range(1, n):
        dif = max(0, prv + A[i] - x)
        A[i] -= dif
        ans += dif
        prv = A[i]
    print(ans)


if __name__ == "__main__":
    main()


Measured memory_bytes: 14052
#n, m, q = map(int, input().split())
#List = list(map(int, input().split()))
#req = [list(map(int, input().split())) for _ in range(q)]
#t = t[:-1]
#print(ans[j], end = "") 改行無しで出力
#[0]*n
#sort = sorted(a)[::-1] 降順
a, b, c = map(int, input().split())
k = int(input())

bcount = 0
ccount = 0

while(b <= a):
    b = 2*b
    bcount += 1

while(c <= b):
    c = 2*c
    ccount += 1

if k < bcount + ccount:
    print("No")

else:
    print("Yes")


Measured memory_bytes: 9168
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N, T = MAP()
ct = [LIST() for _ in range(N)]

ans = 10000
for c, t in ct:
	if t <= T:
		ans = min(ans, c)
if ans == 10000:
	print("TLE")
else:
	print(ans)


Measured memory_bytes: 5376
#include <cstdio>
#include <iostream>
#include <string>
#include <cmath>

using namespace std;

int main(){
	int leng;
	string S;
	int ans = 0;

	cin >> S;
	leng = S.length();
//	cout << leng;

	for(int i=0;i<leng/2;i++){
//		cout << S[i] << " " << S[leng-i-1] << endl;
//		printf("%d %d",S[i],S[leng-i]);
		if(S[i]!=S[leng-i-1]){
			ans++;
		}
	}
	printf("%d",ans);



	return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
const long long INF = 1LL << 60;
ll mod = 1e9 + 7;

int n;
ll a[100100], b[100100], c[100100];
ll dp[3][100100];

template <class T>
bool chamax(T &a, T b)
{
    if (a < b)
    {
        a = b;
        return true;
    }
    return false;
}

int main()
{
    cin >> n;
    rep(i, n) cin >> a[i] >> b[i] >> c[i];
    dp[0][0] = a[0], dp[1][0] = b[0], dp[2][0] = c[0];

    for (int i = 1; i < n; i++)
    {
        chamax(dp[0][i], dp[1][i - 1] + a[i]);
        chamax(dp[0][i], dp[2][i - 1] + a[i]);
        chamax(dp[1][i], dp[0][i - 1] + b[i]);
        chamax(dp[1][i], dp[2][i - 1] + b[i]);
        chamax(dp[2][i], dp[0][i - 1] + c[i]);
        chamax(dp[2][i], dp[1][i - 1] + c[i]);
    }

    cout << max(max(dp[0][n - 1], dp[1][n - 1]), dp[2][n - 1]) << endl;

    return 0;
}

Measured memory_bytes: 4992
#include<bits/stdc++.h>
using namespace std;
#define IOS std::ios::sync_with_stdio(false);cin.tie(NULL); cout.tie(NULL);

int main() {
	IOS;
	long long int n; 
	cin >> n;
	
	vector<long long> A(n);
	for(int i = 0; i < n; i++){
		cin >> A[i];
	}
	long long int nein = 1;
	bool flag = false;
	
	for(int i = 0; i < n; i++){
		if(A[i] == nein){
			nein++;
			flag = true;
		}
	}
	if(flag){
		cout << n - nein + 1 << endl;
	}
	else{
		cout << -1 << endl;
	}
    return 0;
}

Measured memory_bytes: 4724
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int h,n;
    cin>>h>>n;
    int a[n];
    for(int i=0;i<n;i++)
    {
     cin>>a[i];   
    }
    for(int i=0;i<n;i++)
    {
        h=h-a[i];
    }
    if(h<=0)
    {
        cout<<"Yes"<<endl;
    }
    else
    {
     cout<<"No"<<endl;   
    }
    return 0;
}

Measured memory_bytes: 640
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e16;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

template<class T> inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template<class T> inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
int ctoi(char c) {
  if (c >= '0' && c <= '9') {
    return c - '0';
  }
  return 0;
}
ll factorial(ll n) {
  if (n == 1) {
    return 1;
  }
  ll ans = factorial(n-1);
  return ans*n;
}
ll gcd(ll a, ll b) {
  if (b == 0) return a;
  return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
  return (a/gcd(a, b))*b;
}
bool is_prime(ll n) {
  for (ll i = 2; i*i <= n; i++) {
    if (n%i == 0) return false;
  }
  return n != 1;
}
ll mod_pow(ll x, ll n, ll mod) {
  if (n == 0) return 1;
  ll res = mod_pow(x*x%mod, n/2, mod);
  if (n & 1) res = res * x % mod;
  return res;
}

int main() {
  double a, b, x;
  cin >> a >> b >> x;
  double res;
  if (x < a*a*b/2.0) {
    res = atan(a*b*b/(2.0*x));
  } else {
    res = atan(2.0*b/a - 2.0*x/(a*a*a));
  }
  cout << fixed << setprecision(10);
  cout << res*180.0/M_PI << endl;
}

Measured memory_bytes: 512
parseInt(x::String) = parse(Int, x)
parseInt(x::SubString{String}) = parse(Int, x)
parseInt(x::Char) = parse(Int, x)
parseInt(x::Float64) = trunc(Int, x)
parseFloat(x::String) = parse(Float64, x)
parseFloat(x::Int) = trunc(Float64, x)
parseFloat(x::SubString{String}) = parse(Float64, x)
parseFloat(x::Char) = parse(Float64, x)
parseMap(x::Array{SubString{String},1}) = map(parseInt, x)

function main()
    a=readline()
    res=[[] for i in 1:4]
    push!(res[1],a[1])
    for i in 2:4
        for j in res[i-1]
            push!(res[i],join([j,'+',a[i]]))
            push!(res[i],join([j,'-',a[i]]))
        end
    end
    for i in res[4]
        num=parseInt(i[1])
        for j in 1:3
            if i[2*j]=='+'
                num+=parseInt(i[2*j+1])
            else
                num-=parseInt(i[2*j+1])
            end
        end
        if num==7
            println(i*"=7")
            break
        end
    end
end
main()

Measured memory_bytes: 199824
// <easy.cpp> - Mon Mar 27 20:17:23 2017
// This file is created by XuYike's black technology automatically.
// Copyright (C) 2015 ChangJun High School, Inc.
// I don't know what this program is.
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
typedef long long lol;
#define next NEXT
template<typename T>
inline void gg(T &res){
    res=0;T fh=1;char ch=getchar();
    while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
    if(ch=='-')fh=-1,ch=getchar();
    while(ch>='0'&&ch<='9')res=res*10+ch-'0',ch=getchar();
    res*=fh;
}
inline int gi(){int x;gg(x);return x;}
inline lol gl(){lol x;gg(x);return x;}
const int MAXN=400010;
const int INF=1e9;
const int MOD=924844033;
int bt,b[MAXN],next[MAXN],to[MAXN];
inline void add(int x,int y){
    next[++bt]=b[x];b[x]=bt;to[bt]=y;
    next[++bt]=b[y];b[y]=bt;to[bt]=x;
}
int n,size[MAXN],A[MAXN<<1],B[MAXN<<1],L,R[MAXN<<1];
void dfs(int x,int f){
    A[n]++;size[x]=1;
    for(int i=b[x];i;i=next[i]){
        if(to[i]==f)continue;
        dfs(to[i],x);
        size[x]+=size[to[i]];
        if(--A[size[to[i]]]<0)A[size[to[i]]]+=MOD;
    }
    if(--A[n-size[x]]<0)A[n-size[x]]+=MOD;
}
int qpow(int x,int y){
    int res=1;
    while(y){
        if(y&1)res=1ll*res*x%MOD;
        x=1ll*x*x%MOD;
        y>>=1;
    }
    return res;
}
void ntt(int *a,int f){
    for(int i=0;i<n;i++)if(i<R[i])swap(a[i],a[R[i]]);
    for(int i=1;i<n;i<<=1){
        int gn=qpow(5,(MOD-1)/(i<<1));
        for(int j=0;j<n;j+=i<<1){
            int g=1;
            for(int k=0;k<i;k++,g=1ll*g*gn%MOD){
                int x=a[j+k],y=1ll*g*a[j+k+i]%MOD;
                a[j+k]=(x+y)%MOD;
                a[j+k+i]=(x-y+MOD)%MOD;
            }
        }
    }
    if(f==-1){
        reverse(a+1,a+n);
        int ny=qpow(n,MOD-2);
        for(int i=0;i<n;i++)a[i]=1ll*a[i]*ny%MOD;
    }
}
int nj[MAXN];
int main(){
    n=gi();
    for(int i=1;i<n;i++)add(gi(),gi());
    dfs(1,0);
    int jc=1;
    for(int i=1;i<=n;i++)A[i]=1ll*A[i]*(jc=1ll*jc*i%MOD)%MOD;
    nj[n]=qpow(jc,MOD-2);for(int i=n;i;i--)nj[i-1]=1ll*nj[i]*i%MOD;
    for(int i=1;i<=n;i++)B[i]=nj[n-i];
    int m=n;
    for(n=1;n<=m<<1;n<<=1)L++;
    for(int i=0;i<n;i++)R[i]=R[i>>1]>>1|((i&1)<<(L-1));
    ntt(A,1);ntt(B,1);
    for(int i=0;i<n;i++)A[i]=1ll*A[i]*B[i]%MOD;
    ntt(A,-1);
    for(int i=1;i<=m;i++)printf("%d\n",1ll*A[m+i]*nj[i]%MOD);
    return 0;
}

Measured memory_bytes: 25728
#include <iostream>

using namespace std;

class Myclass
{
	int a, b, c;

public:
	void Get_Num();
	void Compare();
};

void Myclass::Get_Num()
{
	cin >> a;
	cin >> b;
	cin >> c;

	Compare();
}

void Myclass::Compare()
{
	if( ( 0 <= a && a <= 100 ) && 
		( 0 <= b && b <= 100 ) &&
		( 0 <= c && c <= 100 ) )
	{
		if( ( a < b ) && ( b < c ) && ( a < c ) ) 
		{
			cout << "Yes" << endl;
		}else
		{
			cout << "No" << endl;
		}
	}
}

int main()
{
	Myclass mc;
	
	mc.Get_Num();

	return 0;
}

Measured memory_bytes: 3092
#include <bits/stdc++.h>
 
using namespace std;
 
 
int a,b;
 
 
int main( ) {
    scanf("%d%d",&a,&b);
    int g = __gcd(a,b);
    printf("%lld",1LL*g*a/g*b/g);
    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define ll long long

typedef tree< pair<int,int>, null_type, less< pair<int,int> >, rb_tree_tag, tree_order_statistics_node_update>Order_Set;

Order_Set X;

const int mxn = 5e5+100;
const int mod = 1e9+7;

int arr[mxn];
int bitOn[55];
map<int,int>Mp, cnt, op;
vector< pair<int,int> >Pi;
vector<int>G[mxn];
vector<char>Ans[mxn];
set<int>seet[mxn];
bool visit[mxn];

int main()
{
    ios::sync_with_stdio(false);

    long long n;
    cin>>n;

    long long Ans = 1e15;

    for(long long i=1 ; i*i<=n ; i++){
        if(n%i == 0) Ans = min(Ans,((i-1)+((n/i)-1)));
    }

    cout<<Ans<<endl;

    return 0;
}


Measured memory_bytes: 48896
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
using namespace std;
typedef long long ll;

int N,K;
int D[50];

int main(){
    cin>>N>>K;
    rep(i,N) cin>>D[i];

    int ans=0;
    repn(k,min(N,K)){
        rep(m,k+1){
            vector<int> v;
            int res=0;
            //cout<<m<<' '<<k-m<<' '<<'/';
            rep(i,m){
                //cout<<D[i]<<' ';
                v.push_back(D[i]);
                res+=D[i];
            }
            //cout<<'/';
            rep(i,k-m){
                //cout<<D[N-i-1]<<' ';
                v.push_back(D[N-i-1]);
                res+=D[N-i-1];
            }
            //cout<<endl;
            sort(v.begin(),v.end());
            //rep(i,v.size()) cout<<v[i]<<' '; //cout<<endl;
            //cout<<res<<endl;
            rep(i,K-k){
                //cout<<v[i]<<endl;
                if(v[i]<0) res+=-v[i];
                else break;
            }
            //cout<<' '<<res<<endl;
            ans=max(ans,res);
        }
    }

    cout<<ans<<endl;
}

Measured memory_bytes: 3588
#include <cstdio>
#include <cmath>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <climits>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <vector>
#include <string>
#include <bitset>
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define INF 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define REP_R(i,n) for(int i=((int)(n)-1);i>=0;--i)
#define FOR(i,m,n) for(int i=((int)(m));i<(int)(n);++i)
#define FOR_R(i,m,n) for(int i=((int)(m)-1);i>=(int)(n);--i)
#define ALL(v) (v).begin(),(v).end()
#define RALL(v) (v).rbegin(),(v).rend()
#define SIZ(x) ((int)(x).size())
typedef long long int lli;
using namespace std;

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

  cin >> S;

  N = SIZ(S);
  
  char c = '1';

  int num1 = 0;
  

  REP(i,N)
    {
      if( S[i] != c )
	{
	  ++ num1;
	  
	}

      if( c == '1' )
	{
	  c = '0';
	  
	}
      else
	{
	  c = '1';
	  
	}
      
    }

  c = '0';

  int num0 = 0;
  

  REP(i,N)
    {
      if( S[i] != c )
	{
	  ++ num0;
	  
	}

      if( c == '1' )
	{
	  c = '0';
	  
	}
      else
	{
	  c = '1';
	  
	}
      
    }

  cout << min( num0 , num1 ) << endl;
  

  
  

}


Measured memory_bytes: 512
#include <bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long

using namespace std;


int main()
{
    FAST;
    
    int n;
    cin>>n;
    
    bool flag=false;
    
    if(n%10==7)
    {
        flag=true;    
    }
    
    n/=10;
    
    if(n%10==7)
    {
        flag=true;    
    }
    
    n/=10;
    
    if(n%10==7)
    {
        flag=true;    
    }
    
    if(flag)
    {
        cout<<"Yes\n";
    }
    else
    {
        cout<<"No\n";
    }
}

Measured memory_bytes: 3608
#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::endl;

int main(int argc, char* argv)
{
    int a, b, c;

    cin >> a >> b >> c;
    std::string s = (a + b >= c) ? "Yes" : "No";
    cout << s << endl;
    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
#define rep(i, a, n) for (ll i = (a); i < (n); i++)
#define debug(x) cerr << #x << ": " << x << endl;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

int main() {
    int n;
    cin >> n;
    vector<string> s(n);
    rep(i, 0, n) cin >> s[i];

    if (n == 1) {
        sort(s[0].begin(), s[0].end());
        cout << s[0] << endl;
        return 0;
    }

    string ans = "";
    for (auto c : s[0]) {
        bool ok = true;
        rep(i, 1, n) {
            bool bl = false;
            rep(j, 0, (int)s[i].size()) {
                if (c == s[i][j]) {
                    bl = true;
                    s[i][j] = '-';
                    break;
                }
            }
            ok &= bl;
        }
        if(ok) ans.push_back(c);
    }
    sort(ans.begin(), ans.end());
    cout << ans << endl;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define pi M_PI
#define R cin>>
#define Z class
#define ll long long
#define ln cout<<'\n'
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n",a)
#define mem(a) memset(a,0,sizeof(a))
#define all(c) (c).begin(),(c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define REP(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#define tr(it,c) for(iter(c) it=(c).begin();it!=(c).end();it++)
template<Z A>void pr(A a){cout<<a;ln;}
template<Z A,Z B>void pr(A a,B b){cout<<a<<' ';pr(b);}
template<Z A,Z B,Z C>void pr(A a,B b,C c){cout<<a<<' ';pr(b,c);}
template<Z A,Z B,Z C,Z D>void pr(A a,B b,C c,D d){cout<<a<<' ';pr(b,c,d);}
template<Z A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}ln;}
ll check(ll n,ll m,ll x,ll y){return x>=0&&x<n&&y>=0&&y<m;}
const ll MAX=1000000007,MAXL=1LL<<61,dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
typedef pair<int,int> P;

void Main() {
  ll n,m;
  cin >> n >> m;
  ll a[n];
  rep(i,n) R a[i];
  ll M=0,c=0,x=MAXL;
  rep(i,n) {
    x=min(x,a[i]);
    if(M<a[i]-x) {
      M=a[i]-x;
      c=1;
    } else if(M==a[i]-x) c++;
  }
  pr(c);
}

int main(){ios::sync_with_stdio(0);cin.tie(0);Main();return 0;}


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


typedef long long llint;

int main()
{
    llint n, c;
    std::cin >> n >> c;

    std::vector<llint> x(n), v(n);
    for (llint i = 0; i < n; ++i){
        std::cin >> x[i] >> v[i];
    }

    std::vector<llint> r1max(n + 1), r2max(n + 1), l1max(n + 1), l2max(n + 1);
    std::vector<llint>::iterator rx_it = x.begin(), rv_it = v.begin();
    std::vector<llint>::reverse_iterator lx_it = x.rbegin(), lv_it = v.rbegin();
    llint rsum = 0, lsum = 0, r1, r2, l1, l2;
    r1max[0] = 0;
    r2max[0] = 0;
    l1max[0] = 0;
    l2max[0] = 0;
    for (llint i = 0; i < n; ++i){
        rsum += *rv_it;
        lsum += *lv_it;
        r1 = rsum - *rx_it;
        r2 = rsum - 2 * (*rx_it);
        l1 = lsum - (c - *lx_it);
        l2 = lsum - 2 * (c - *lx_it);
        r1max[i + 1] = std::max(r1, r1max[i]);
        r2max[i + 1] = std::max(r2, r2max[i]);
        l1max[i + 1] = std::max(l1, l1max[i]);
        l2max[i + 1] = std::max(l2, l2max[i]);
        ++rx_it;
        ++lx_it;
        ++rv_it;
        ++lv_it;
    }

    llint r, l, rmax = 0, lmax = 0;
    for (llint i = 0; i < n + 1; ++i){
        r = r1max[i] + l2max[n - i];
        l = l1max[i] + r2max[n - i];
        rmax = std::max(r, rmax);
        lmax = std::max(l, lmax);
    }
    std::cout << std::max(rmax, lmax) << std::endl;

    return 0;
}


Measured memory_bytes: 4992