akhauriyash/Code-Regression huggingface dataset:
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <stack>
#include <complex>
#include <stdlib.h>
#include <stdio.h>
#include <functional>
#include <cfloat>
#include <math.h>
#include <numeric>
#include <string.h>
#include <sys/time.h>
#include <random>


#define fs first
#define sc second

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;
vector<ll> formerVector[20];


int main(){
    int n, k;
    ll L, R;
    cin >> n >> k >> L >> R;
    ll a[40];
    for(int i = 0; i < n; i++){
        cin >> a[i];
    }

    for(int i = 0; i < (1 << n/2); i++){
        ll tmp = 0;
        int num = 0;
        for(int j = 0; j < n/2; j++){
            if((i >> j) % 2 == 1){
                tmp += a[j];
                num++;
            }
        }
        formerVector[num].push_back(tmp);
    }
    for(int i = 0; i < n/2; i++){
        sort(formerVector[i].begin(), formerVector[i].end());
    }

    ll res = 0;
    for(int i = 0; i < (1 << (n-n/2)); i++){
        ll tmp = 0;
        int num = 0;
        for(int j = 0; j < n-n/2; j++){
            if((i >> j) % 2 == 1){
                tmp += a[n/2 + j];
                num++;
            }
        }
        if(num > k){
            continue;
        }
        res += upper_bound(formerVector[k-num].begin(), formerVector[k-num].end(), R-tmp) - lower_bound(formerVector[k-num].begin(), formerVector[k-num].end(), L-tmp);
    }


    cout << res << endl;


    return 0;
}



Measured memory_bytes: 12276
package main

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

func max(a ...int) int {
	m := a[0]
	for i, v := range a {
		if i == 0 {
			continue
		}
		if m < v {
			m = v
		}
	}
	return m
}

func min(a ...int) int {
	m := a[0]
	for i, v := range a {
		if i == 0 {
			continue
		}
		if m > v {
			m = v
		}
	}
	return m
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

var sc = bufio.NewScanner(os.Stdin)

func main() {
	// Code for E - Dist Max
	var N int
	fmt.Scan(&N)

	sc.Split(bufio.ScanWords)
	x := make([]int, N)
	y := make([]int, N)

	z1 := make([]int, N)
	z2 := make([]int, N)

	var Max1 int
	var MaxNum1 int
	var Min1 int = 10000000000
	var MinNum1 int

	var Max2 int
	var MaxNum2 int
	var Min2 int = 10000000000
	var MinNum2 int

	for i := 0; i < N; i++ {
		x[i] = nextInt()
		y[i] = nextInt()

		z1[i] = x[i] - y[i]
		z2[i] = x[i] + y[i]

		if Max1 < z1[i] {
			Max1 = z1[i]
			MaxNum1 = i
		}

		if Min1 > z1[i] {
			Min1 = z1[i]
			MinNum1 = i
		}

		if Max2 < z2[i] {
			Max2 = z2[i]
			MaxNum2 = i
		}

		if Min2 > z2[i] {
			Min2 = z2[i]
			MinNum2 = i
		}
	}

	var ans, ans1, ans2, ans3, ans4 int
	for i := 0; i < N; i++ {
		//for j := 0; j < N; j++ {
		//temp = int(math.Abs(float64(x[i]-x[j]))) + int(math.Abs(float64(y[i]-y[j])))
		ans1 = int(math.Abs(float64(x[MaxNum1]-x[i]))) + int(math.Abs(float64(y[MaxNum1]-y[i])))
		ans2 = int(math.Abs(float64(x[MinNum1]-x[i]))) + int(math.Abs(float64(y[MinNum1]-y[i])))
		ans3 = int(math.Abs(float64(x[MaxNum2]-x[i]))) + int(math.Abs(float64(y[MaxNum2]-y[i])))
		ans4 = int(math.Abs(float64(x[MinNum2]-x[i]))) + int(math.Abs(float64(y[MinNum2]-y[i])))
		ans = max(ans, ans1, ans2, ans3, ans4)
		//}
	}

	fmt.Println(ans)
}


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

#define abs(N) ((N>0)?N:-1*N)
#define min(A,B) ((A>B)?B:A)
#define max(A,B) ((A<B)?B:A)
#define print(S) (cout << S)
#define println(S) (cout << S << endl)

int main(){
  long long int n,m,l;
  cin >> n >> m >> l;
  long long int matA[n][m],matB[m][l];

  for (long long int i = 0; i < n; ++i) {
    for (long long int j = 0; j < m; ++j) {
      cin >> matA[i][j];
    }
  }
  for (long long int i = 0; i < m; ++i) {
    for (long long int j = 0; j < l; ++j) {
      cin >> matB[i][j];
    }
  }


  for (long long int i = 0; i < n; ++i) {
    for (long long int j = 0; j < l; ++j) {
      long long int sum=0;
      for (long long int k = 0; k < m; ++k) {
        sum += matA[i][k]*matB[k][j];
      }
      cout << sum;
      if(j != l-1)
        cout << " ";
    }
    cout << endl;
  }


  return 0;
}



Measured memory_bytes: 3204
#include <bits/stdc++.h>
using namespace std;
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define vv(type, c, m, n, i) vector<vector<type>> c(m, vector<type>(n, i));
#define rep(i,a,n) for(int i=(a), i##_len=(n); i<i##_len; ++i)
#define rrep(i,a,n) for(int i=(a), i##_len=(n); i>i##_len; --i)
#define len(x) ((int)(x).size())
#define mp make_pair
#define eb emplace_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef vector<bool> vb;
constexpr int NIL = -2000000050;
struct Node { int key, l = NIL, r = NIL, p = 0; };
vector<Node> T;
int root = 0;
inline void insert(int z) {
	if(z == 0) return;
	int x = 0, y = 0;
	while(x != NIL) {
		y = x;
		x = (T[z].key < T[x].key ? T[x].l : T[x].r);
	}
	(T[z].key < T[y].key ? T[y].l : T[y].r) = z;
	T[z].p = y;
}
inline int find(int x) {
	int u = 0;
	while(u != NIL && x != T[u].key) {
		u = (x < T[u].key ? T[u].l : T[u].r);
	}
	return u;
}
inline int treeMinimum(int x) {
	while(T[x].l != NIL) x = T[x].l;
	return x;
}
inline int treeSuccessor(int x) {
	if(T[x].r != NIL) return treeMinimum(T[x].r);
	int y = T[x].p;
	while(y != NIL && x == T[y].r) {
		x = y;
		y = T[y].p;
	}
	return y;
}
inline void treeDelete(int z) {
	int y = (T[z].l == NIL || T[z].r == NIL ? z : treeSuccessor(z));
	int x = (T[y].l != NIL ? T[y].l : T[y].r);
	if(x != NIL) T[x].p = T[y].p;
	if(T[y].p == NIL) root = x;
	else (y == T[T[y].p].l ? T[T[y].p].l : T[T[y].p].r) = x;
	if(y != z) T[z].key = T[y].key;
}
inline void inorder(int x) {
	if(x == NIL) return;
	inorder(T[x].l);
	cout << ' ' << T[x].key;
	inorder(T[x].r);
}
inline void preorder(int x) {
	if(x == NIL) return;
	cout << ' ' << T[x].key;
	preorder(T[x].l);
	preorder(T[x].r);
}
int main() {
	int n; cin >> n;
	T.resize(n);
	string s;
	int x;
	rep(i, 0, n) {
		cin >> s;
		if(s == "insert") {
			cin >> x;
			T[i].key = x;
			insert(i);
		} else if(s == "find"){
			cin >> x;
			P(find(x) != NIL ? "yes" : "no");
		} else if(s == "delete"){
			cin >> x;
			treeDelete(find(x));
		} else {
			inorder(root);
			P("");
			preorder(root);
			P("");
		}
	}
	return 0;
}

Measured memory_bytes: 10596
N = int(input())
A = [0] * N
for i in range(N):
    A[i] = int(input())

if A[0] != 0:
    print(-1)
    exit()

ans = 0
for i in range(1,N):
    if A[i] == A[i-1] + 1:
        ans += 1
    elif A[i] < A[i-1] + 1:
        ans += A[i]
    else:
        print(-1)
        exit()
    
print(ans)

Measured memory_bytes: 10868
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define INF LLONG_MAX/10
#define rep(i,n) for(int i=0;i<n;i++)
#define krep(i,k,n,m) for(int i=k;i<n;i+=m)
#define erep(i,k,n) for(int i=k;i<n;i++)
#define mod 1000000007
//最大公約数
int gcd(int s,int b){
    if(b==0)return s;
    return gcd(b,s%b);
}
signed main(){
    int n;
    cin>>n;
    pair<int,int> a[n];
    rep(i,n){
        cin>>a[i].second>>a[i].first;
    }
    sort(a,a+n);
    int ans=0;
    rep(i,n){
        ans+=a[i].second;
        if(a[i].first<ans){
            cout<<"No"<<endl;
            return 0;
        }
    }
    cout<<"Yes"<<endl;
}


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

using namespace std;
typedef long long ll;

#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REPR(i, n) for (ll i = (n); i >= 0; i--)
#define FOR(i, m, n) for (ll i = (m); i < (n); i++)
#define FORR(i, m, n) for (ll i = (m); i >= (n); i--)
#define INF 1e9
#define pb push_back
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define SORT(x) sort((x).begin(), (x).end())
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
                      << " " << __FILE__ << endl

int main(int argc, char const *argv[])
{
    ll n, m;
    cin >> n >> m;
    vector<ll> c(m + 1, 0);
    REP(i, n)
    {
        ll k;
        cin >> k;
        REP(j, k)
        {
            ll tmp;
            cin >> tmp;
            // dump(tmp);
            c[tmp]++;
        }
    }
    ll res = 0;
    REP(i, m + 1)
    {
        // dump(c[i]);
        if (c[i] == n)
            res++;
    }
    cout << res << endl;
    return 0;
}


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

using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define For(i , j , k) for (int i = (j) , i##_end_ = (k) ; i <= i##_end_ ; ++ i)
#define rep(i , j) for (int i = 0 , i##_end_ = j; i < i##_end_ ; ++ i)
#define Fordown(i , j , k) for (int i = (j) , i##_end_ = (k) ; i >= i##_end_ ; -- i)
#define Set(a , b) memset(a , b , sizeof(a))
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define INF (0x3f3f3f3f)
#define INF1 (2139062143)
#define Ha (1000000007)
#ifdef hany01
#define debug(...) fprintf(stderr , __VA_ARGS__)
#else
#define debug(...)
#endif

inline void file()
{
#ifdef hany01 
	freopen("a.in" , "r" , stdin);
    freopen("a.out" , "w" , stdout);
#endif
}

template<typename T> inline bool chkmax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }

char c_; int _ , __;
inline int read()
{
    for (_ = 0 , __ = 1 , c_ = getchar() ; !isdigit(c_) ; c_ = getchar()) if (c_ == '-')  __ = -1;
    for ( ; isdigit(c_) ; c_ = getchar()) _ = (_ << 1) + (_ << 3) + (c_ ^ 48);
    return _ * __;
}

int n;
char s[100005];
int Min1, ls[100005], cnt, Min2;

int main()
{
	file();
    scanf("%s", s + 1); n = strlen(s + 1);
    Min1 = Min2 = n;
    For(i, 1, n)
        if (s[i] == '1') chkmin(Min1, max(n - i, i - 1)); else chkmin(Min2, max(n - i, i - 1));
    printf("%d\n", max(Min1, Min2));
    return 0;
}


Measured memory_bytes: 384
#include <bits/stdc++.h>
#define INF (1<<30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;

ll ans = 0;

ll gcd( ll x, ll y ){
	if( y != 0 ){
		ans += (x-x%y)*3;
		gcd( y, x%y );
	}
}


int main(){
	ll n, x;
	cin >> n >> x;
	if( x > n/2 ) x = n-x;
	gcd( n, x );
	cout << ans-3*x << endl;
	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <cstring>
using namespace std;
const int MAX = 51;
int H,W,cnt;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
string str[MAX];
bool BW[2];

void dfs(int x,int y){  
  if(x < 0 || x >= W || y < 0 || y >= H) return;
  if(str[x][y] == 'B'){
    BW[0] = true;
    return;
  }
  else if(str[x][y] == 'W'){
    BW[1] = true;
    return;
  }
  if(str[x][y] == '.'){
    cnt++;  
    str[x][y] = '#';
  }

  for(int i = 0 ; i < 4 ; i++){
    int nx = dx[i]+x;
    int ny = dy[i]+y;

    if(0 <= nx && nx < W && 0 <= ny && ny < H&&str[nx][ny] != '#'){
      dfs(nx,ny);
    }
  }
}

int main(){
  while(cin >> H >> W ,H + W){  
    for(int i = 0 ; i < W ; i++){
      cin >> str[i];
    }
    int BB = 0,WW = 0;
    for(int i = 0 ; i < W ; i++){
      for(int j = 0 ; j < H ; j++){
	cnt = 0;
	memset(BW,false,sizeof(BW));
	dfs(i,j);
	if(BW[0]&&!BW[1]) BB += cnt;
	else if(!BW[0]&&BW[1]) WW += cnt;
      }
    }    

    cout << BB << ' ' << WW << endl;
  }

  return 0;
}

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

#if ((_WIN32 || __WIN32__) && __cplusplus < 201103L)
#define lld I64d
#else
#define lld lld
#endif

//{{{
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define clr(a, b) memset(a, b, sizeof(a))
// clang-format off
#define debug(args...) {vector<string> _v = split(#args, ','); err(_v.begin(), args); cerr<<endl;}
vector<string> split(const string& s, char c) {vector<string> v; stringstream ss(s); string x; while
(getline(ss, x, c)) v.push_back(x); return v;} void err(vector<string>::iterator) {}
template<typename T, typename... Args> void err(vector<string>::iterator it, T a, Args... args)
{cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; err(++it, args...);}
// clang-format on
//}}}

const int N = 1e5 + 10;
int T;
int n;

struct I
{
    LL w, s, v;
} item[1010];

bool cmp(const I& a, const I& b) { return a.s + a.w < b.s + b.w; }

LL dp[1010][20010];

int main()
{
#ifdef LOCAL
    freopen("in", "r", stdin);
// freopen("out", "w", stdout);
#endif

    while (cin >> n)
    {
        for (int i = 1; i <= n; i++)
        {
            cin >> item[i].w >> item[i].s >> item[i].v;
        }
        sort(item + 1, item + 1 + n, cmp);

        clr(dp, -1);
        dp[0][0] = 0;

        for (int i = 0; i < n; i++)
        {
            LL w = item[i + 1].w;
            LL s = item[i + 1].s;
            LL v = item[i + 1].v;

            for (int j = 0; j <= 20000; j++)
            {
                dp[i + 1][j] = dp[i][j];
            }

            for (int j = 0; j <= 20000; j++)
            {
                if (dp[i][j] == -1) continue;
                if (j + w > 20000) continue;

                if (s >= j)
                {
                    dp[i + 1][j + w] = max(dp[i + 1][j + w], dp[i][j] + v);
                    // debug(w, s, j, i + 1, j + w, dp[i + 1][j + w]);
                }
                // else
                //{
                // if (dp[i][s] != -1)
                //{
                // dp[i + 1][s + w] = max(dp[i + 1][s + w], dp[i][s] + v);
                //// debug(w, s, j, i + 1, s + w, dp[i + 1][s + w]);
                //}
                //}
            }
        }
        LL ans = 0;
        for (int i = 0; i <= 20000; i++)
        {
            ans = max(ans, dp[n][i]);
        }
        cout << ans << endl;
    }

    return 0;
}


Measured memory_bytes: 161564
// バケット法による解
#include <iostream>
using namespace std;

int main() {
    int N;
    int d[110];
    cin >> N;
    for (int i = 0; i < N; ++i) cin >> d[i];

    //バケット砲
    //配列を全部ゼロにしてある場所に
    //1を足すことで重複の削除になる
    int num[110] = {0};  // バケット
    for (int i = 0; i < N; ++i) {
        num[d[i]]++;  // d[i] が 1 個増える
    }

    int res = 0;  // 答えを格納
    for (int i = 1; i <= 100; ++i) {  // 1 <= d[i] <= 100 なので 1 から 100 まで探索
        if (num[i]) {  // 0 より大きかったら
            ++res;
        }
    }
    cout << res << endl;
}


Measured memory_bytes: 3548
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (n);i++)
using ll = long long;
const ll MOD=1000000007;
const long long INF = 1LL << 60;
const double pi=acos(-1);


ll N,A,B,C,D;
vector<bool> sunuke;
string S;
bool sunuke_dp(ll n)
{
  //cout<<n<<endl;
  if(S.at(n)=='#') {return false;}
  if(sunuke.at(n)) {return true;}
  if(n-1>=A&&sunuke_dp(n-1))
  {
    sunuke.at(n)=true;
    return true;
  }
  if(n-2>=A&&sunuke_dp(n-2))
  {
    sunuke.at(n)=true;
    return true;
  }
  return false;
}  

vector<bool> hunuke;
bool hunuke_dp(ll n)
{
  if(S.at(n)=='#') {return false;}
  if(hunuke.at(n)) {return true;}
  if(n-1>=B&&hunuke_dp(n-1))
  {
    hunuke.at(n)=true;
    return true;
  }
  if(n-2>=B&&hunuke_dp(n-2))
  {
    hunuke.at(n)=true;
    return true;
  }
  return false;
}  



int main() 
{
  cin>>N>>A>>B>>C>>D; A--; B--; C--; D--; 
  cin>>S;
  sunuke=vector<bool>(N,false);
  hunuke=vector<bool>(N,false);
  sunuke.at(A)=true;
  hunuke.at(B)=true;
  //if(sunuke_dp(C)) {cout<<"s"<<endl;} else{cout<<"sx"<<endl;}
  //if(hunuke_dp(D)) {cout<<"h"<<endl;} else{cout<<"hx"<<endl;}
  if((B<C&&C<D)||(C<B&&B<D))
  {
    if(sunuke_dp(C)&&hunuke_dp(D)) {cout<<"Yes"<<endl; return 0;}
    cout<<"No"<<endl; return 0;
  }
  if(sunuke_dp(C)&&hunuke_dp(D))
  {
    for(int i=B;i<=D;i++)
    {
      if(S.at(i-1)=='.'&&S.at(i)=='.'&&S.at(i+1)=='.')
      {
        cout<<"Yes"<<endl; return 0;
      }
    }
  }
  cout<<"No"<<endl; 
    
  return 0;
}

Measured memory_bytes: 9188
#include<stdio.h>
int main()
{
  char s[3];
  
  scanf("%s %s %s",&s[0],&s[1],&s[2]);
  
  if(s[0]!=s[1]){
    if(s[1]!=s[2]){
      if(s[2]!=s[0]){
        printf("Yes");
      }else
        printf("No");
    }else
      printf("No");
  }else
    printf("No");
  
  return 0;
}

Measured memory_bytes: 128
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fo(a,b) for(int a=0;a<b;a++)
#define Sort(a) sort(a.begin(),a.end())
#define rev(a) reverse(a.begin(),a.end())
#define fi first
#define se second
#define co(a) cout<<a<<endl
#define sz size()
#define bgn begin()
#define en end()
#define pb(a) push_back(a)
#define pop pop_back
#define V vector
#define P pair
#define V2(a,b,c) V<V<int>> a(b,V<int>(c))
#define V2a(a,b,c,d) V<V<int>> a(b,V<int>(c,d))
#define incin(a) int a; cin>>a
#define yuko(a) setprecision(a)
//#define min min<int>
//#define max max<int>
template<class T>
 void cou(vector<vector<T>> a){
  int b=a.size();
  int c=a[0].size();
  fo(i,b){
    fo(j,c){
      cout<<a[i][j];
      if(j==c-1)
        cout<<endl;
      else
        cout<<' ';
    }
  }
}
/*template<>
 void cou(vector<vector<char>> a){
  int b=a.size();
  int c=a[0].size();
  fo(i,b){
    fo(j,c){
      cout<<a[i][j];
      if(j==c-1)
        cout<<endl;
      else
        cout<<' ';
    }
  }
}*/
 int wari(int a,int b) {
   if(a%b==0)
     return a/b;
   else
     return a/b+1;
 }
 int keta(int a){
  double b=a;
  b=log10(b);
  int c=b;
  return c+1;
 }
 int souwa(int a){
  return a*(a+1)/2;
 }
 int lcm(int a,int b){
  int d=a,e=b,f;
  if(a<b)
    swap(a,b);
  int c,m=1;
  while(m){
    c=a%b;
    if(c==0){
       f=b;
      m--;
    }
    else{
      a=b;
      b=c;
 }
  }
  return d*e/f;
    }
  int gcm(int a,int b){
      int d=a,e=b,f;
  if(a<b)
    swap(a,b);
  int c,m=1;
  while(m){
    c=a%b;
    if(c==0){
       f=b;
      m--;
    }
    else{
      a=b;
      b=c;
 }
  }
  return f;
  }
 bool prime(int a){
   if(a<2)
     return false;
   else if(a==2)
     return true;
   else if(a%2==0)
     return false;
   double b=sqrt(a);
    for(int i=3;i<=b;i+=2){
      if(a%i==0){
        return false;
      }
    }
   return true;
 }
struct Union{
  vector<int> par;
  Union(int n){
	par= vector<int>(n, -1);
  }
  int find(int x){
    if(par[x]<0)
      return x;
    else
      return par[x]=find(par[x]);
  }
  bool same(int a,int b){
    return find(a)==find(b);
  }
  int Size(int a){
    return -par[find(a)];
  }
  void unite(int a,int b){
    a=find(a);
    b=find(b);
    if(a==b)
      return;
    if(Size(b)>Size(a))
      swap<int>(a,b);
    par[a]+=par[b];
    par[b]=a;
  }
};
int ketas(int a){
  string b=to_string(a);
  int c=0;
  fo(i,keta(a)){
    c+=b[i]-'0';
  }
  return c;
}
/*struct aa{
	vector<int> gt;
  aa(int n){
	gt= vector<int>(n, 1);
  }
	void c(V<int> d,int b){
	if(d[b]==0){
		gt[d[b]-1]++;
		gt[gt.sz-1]++;
	}
	else{
		gt[d[b]-1]++;
		c(d,d[d[b]]-1);
	}
}
void cok(int a){
	cout<<gt[a-1]<<endl;
	fo(i,a-1)
	cout<<gt[i]<<endl;
}
};
*/
signed main(){
	int a,b,c;
  cin>>a>>b>>c;
	if(a>b)
		swap(a,b);
	if(a<=c&&c<=b)
		cout<<"Yes"<<endl;
	else
		cout<<"No"<<endl;
}

Measured memory_bytes: 256
N, K = map(int, input().split())
mod = 10**9+7

n = 1
A = []
while True:
    A.append(N//n)
    if N//(n+1) < n+1: break
    n += 1
A.append(n)

L = 2*n
dp = [[0]*L for _ in range(K)]
for l in range(n):
    dp[0][l] = 1

i = 0
for l in reversed(range(n, L)):
    dp[0][l] = A[i] - A[i+1]
    i += 1

for k in range(1, K):
    s = 0
    for l in reversed(range(L)):
        s = (s+dp[k-1][L-l-1]) % mod
        dp[k][l] = s * dp[0][l] % mod

ans = 0
for l in range(L):
    ans = (ans + dp[K-1][l]) % mod

print(ans)

Measured memory_bytes: 91372
#include<stdio.h>
int partition(int A[],int p,int r);
int A[1000001];
int main(){
  int i,q,n;
  scanf("%d",&n);
  for(i=0;i<n;i++)
    scanf("%d",&A[i]);
  q=partition(A,0,n-1);
  for(i=0;i<n;i++){
    if(i==q)printf("[%d]",A[i]);
    else printf("%d",A[i]);
    if(i<n-1) printf(" ");
  }
  printf("\n");
  return 0;
}

int partition(int A[], int p,int r){
  int x,i,j,tem1,tem2;
  x = A[r];
  i = p-1;
  for (j = p ;j<r;j++){
    if (A[j] <= x){
      i = i+1;
      tem1=A[i];
      A[i]=A[j];
      A[j]=tem1;
    }
  }
      tem2=A[i+1];
      A[i+1]=A[r];
      A[r]=tem2;
       return i+1;
}

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

int main(){
  string str;
  cin >> str;
  cout << str[0] << str[1] << str[2] << str[3] << str[4] << " ";
  cout << str[6] << str[7] << str[8] << str[9] << str[10]  << str[11] << str[12] << " ";
  cout << str[14] << str[15] << str[16] << str[17] << str[18] << " ";
  
  return 0;
}

Measured memory_bytes: 256
object Main extends App {
  val n = readInt
  (1 to n)
    .map(_ => (readLine, readLine))
    .map {
      case (str1, str2) =>
        if (str1.length > 80 || str2.length > 80) "overflow"
        else {
          val (bi1, bi2) = (BigInt(str1), BigInt(str2))
          val ans = bi1 + bi2
          if (ans.toString.length > 80) "overflow"
          else ans.toString
        }
    }
    .foreach(println)
}



Measured memory_bytes: 43600
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<bitset>
#include<vector>
#include<deque>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<iomanip>
#include <functional>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const double EPS = 1e-10;
const int INF = 2147483647;
//cout << fixed << std::setprecision(9)
//memset(a, 0, sizeof(a));
//--------------------------

int main()
{
	char c[4];
	for (int i = 0;i < 4;i++) cin >> c[i];

	if (c[0] == c[1] && c[1] == c[2]) {
		cout << "Yes" << endl;
		return 0;
	}

	if (c[1] == c[2] && c[2] == c[3]) {
		cout << "Yes" << endl;
		return 0;
	}

	cout << "No" << endl;

	return 0;
}


Measured memory_bytes: 256
#include <functional>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstring>
#include <iomanip>
#include <fstream>
#include <climits>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <deque>
#include <list>
#include <map>
#include <set>
using namespace std;

/*** typedef ***/
typedef long long LL;
typedef unsigned int ui;
typedef unsigned long long ULL;
typedef pair < int , int > ii;
typedef pair < LL  , LL  > ll;
typedef vector <int>  vint;
typedef vector <bool> vbool;
typedef vector <long> vlong;

/*** define ***/
#define sz(x)			((int)x.size())
#define tin(x)			scanf("%d",&x)
#define all(x)			x.begin(),x.end()
#define Set(b,a)		memset(b,a,sizeof b)
#define print1(x)		printf("Case %d:",x++)
#define tin2(x,y)		scanf("%d%d",&x,&y)
#define tin3(x,y,z)		scanf("%d%d%d",&x,&y,&z)
#define loop(i,i0,in)	for(int i=i0 ; i<in ; i++)
#define rep(i,n)		for(int i=0 ; i<(n) ; i++)
#define _rep(i,n)		for(int i=n-1 ; i>=0 ; i--)
#define _loop(i,in,i0)	for(int i=in-1 ; i>=i0 ; i--)
#define Fore(it, x)		for(typeof (x.begin()) it = x.begin(); it != x.end (); it++)
     
int main()  
{  
#ifdef Online_Judge
	freopen("a.in","r",stdin);
#endif
	string s;
	getline(cin,s);
	reverse(all(s));
	cout << s << endl;
	return 0;
}  

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

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP0(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)

typedef long long LL;
typedef pair<int, int> pii;

const int INTINF = int(1e9) + 1;
const LL LLINF = LL(1e18) + 1;
#define pow10(n) int(1e##n + n)

void solve()
{
    LL A, B;
    cin >> A >> B;

    if (A % 2 == 0)
    {
        LL len = B - A + 1;
        cout << (len % 2 == 0 ? (len / 2) % 2 : ((len - 1) / 2 % 2) ^ B) << endl;
    }
    if (A % 2 == 1)
    {
        LL len = B - A;
        cout << (len % 2 == 0 ? A ^ ((len / 2) % 2) : A ^ ((len - 1) / 2 % 2) ^ B) << endl;
    }
}

int main(int argc, char const *argv[])
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(10);
    solve();
    return 0;
}


Measured memory_bytes: 256
n = int(input())
a = [0]+list(map(int,input().split()))+[0]
cost = sum([abs(a[i-1]-a[i]) for i in range(1,n+2)])
for i in range(1,n+1):
    print(cost-abs(a[i]-a[i+1])-abs(a[i-1]-a[i])+abs(a[i-1]-a[i+1]))


Measured memory_bytes: 14048
#!/usr/bin/env python3
import sys


def solve(N: int, A: "List[int]"):
    X = [0] * N
    S = sum(A)
    # 初期
    X[0] = S - sum([2*A[i] for i in range(1,N) if i%2 == 1])
    # 漸化式
    for i in range(1, N):
        X[i] = 2*A[i-1] - X[i-1]

    print(' '.join(map(str, X)))
    
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [ int(next(tokens)) for _ in range(N) ]  # type: "List[int]"
    solve(N, A)

if __name__ == '__main__':
    main()


Measured memory_bytes: 28032
#include<iostream>
    #include<stdio.h>
    //#include <bits/stdc++.h>
    #include<vector>
    #include<float.h>
    #include<iomanip>
    #include<algorithm>
    #include<string>
    #include<cstring>
    #include<math.h>
    #include<sstream>
    #include<set>
    #include<map>
    #include<queue>
    #include <cassert>
    #include <cmath>

    #define INF 1e9
    #define rep(i,n)for(int i=0;(i)<(int)(n);i++)
    #define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
    #define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
    #define vec(type,n) vector<type>(n)
    #define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))

    using namespace std;
    using ll = long long;
    using Graph = vector<vector<int>>;


    vector<bool> seen;
    void dfs(const Graph &G,int v){
        int cnt = 0;
        seen[v] = true;
        for(auto nv:G[v]){
            if(seen[nv])continue;
            cnt++;
            dfs(G,nv);
        }
    }

    int main(){
      int h,a;cin>>h>>a;
      int cnt = 0;
      while(h>0){
          h -= a;
          cnt++;
      }
      cout<<cnt;
    }


Measured memory_bytes: 256
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <bitset>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <queue>

#define mp make_pair
#define pb push_back


typedef long long ll;
typedef long double ld;

using namespace std;

#ifndef LOCAL
#define cerr _cer
struct _cert
{
    template <typename T> _cert& operator << (T) { return *this; }
};
_cert _cer;
#endif

template <typename T> void dprint(T begin, T end) {
    for (auto i = begin; i != end; i++) {
		cerr << (*i) << " ";
    }
    cerr << "\n";
}

const int CC = 20;
int n, v;
ll x[220000];
vector<int> vv;
int gl[CC][220000];
int gr[CC][220000];
int dpl[(1 << CC)];
int dpr[(1 << CC)];
int ad[220000];


int main() {
	scanf("%d%d", &n, &v);
	for (int i = 0; i < n; ++i)
		scanf("%lld", x + i);
	int tmp = v;
	while (tmp) {
		vv.push_back(tmp);
		tmp /= 2;
	}
	vv.push_back(tmp);
	reverse(vv.begin(), vv.end());
	for (int i = 0; i < vv.size(); ++i) {
		int pr = 0;
		for (int j = 0; j < n; ++j) {
			if (j != 0 && x[j] - x[j - 1] > vv[i])
				pr = j;
			gl[i][j] = pr;
		}
		pr = n - 1;
		for (int j = n - 1; j >= 0; --j) {
			if (j != n - 1 && x[j + 1] - x[j] > vv[i])
				pr = j;
			gr[i][j] = pr;
		}
	}
	int cc = vv.size();
	for (int i = 0; i < (1 << cc); ++i)
		dpl[i] = 0, dpr[i] = n - 1;
	for (int j = 0; j < (1 << cc); ++j) {
		for (int i = 0; i < cc; ++i) {
			if ((j >> i) & 1)
				continue;
			int x = dpl[j];
			if (x < n)
				x = gr[i][x] + 1;
			dpl[j | (1 << i)] = max(dpl[j | (1 << i)], x);
			x = dpr[j];
			if (x >= 0)
				x = gl[i][x] - 1;
			dpr[j | (1 << i)] = min(dpr[j | (1 << i)], x);

		}
	}
	for (int i = 0; i < (1 << (cc - 1)); ++i) {
		int l = dpl[i];
		int r = dpr[((1 << (cc - 1)) - 1) ^ i];
		if (l > r) {
			++ad[0];
			--ad[n];
		}
		else if (gr[cc - 1][l] >= r) {
			++ad[gl[cc - 1][l]];
			--ad[gr[cc - 1][l] + 1];
		}
	}
	int now = 0;
	for (int i = 0; i < n; ++i) {
		now += ad[i];
		if (now)
			printf("Possible\n");
		else
			printf("Impossible\n");
	}
	return 0;
}




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

using namespace std;

//FILE *fi=freopen("1.txt","r",stdin);

int n,m;
string s;

void nhap()
{
    scanf("%d %d",&n,&m);
    for (int i=1;i<=n;++i)
    {
        for (int j=1;j<=m;++j)
        {
            cin>>s;
            if (s=="snuke")
            {
                char c='A'+j-1;
                cout<<c<<i;
                return;
            }
        }
    }
}

int main()
{
    nhap();
    return 0;
}


Measured memory_bytes: 256
#include <iostream>
#include <vector>
#include <array>
#include <set>
#include <cmath>
#include <string>
#include <queue> //std::priority_queue<int> que; // 4, 3, 2, 1 (defualt, less) : 
#include <list>
#include <stack>
#include <unordered_map>
#include <algorithm>
#include <numeric>  // std::accumulate(m.begin(), m.end(), 0LL);
#include <functional>
#include <cassert>
#include <cctype>  // std::islower(), std::isupper(), std::tolower, std::toupper
#include <iomanip> // std::setprecision(X)
#include <limits>  //std::numeric_limits<int>::max(), min()

typedef long long ll;

int main (void) {
  int N; std::cin >> N;
  std::vector<ll> X(N); for(int i=0; i<N; i++) std::cin >> X[i];
  auto K = X;

  std::sort(X.begin(), X.end());
  int cand1 = X[N/2-1];
  int cand2 = X[N/2];

  for(int i=0; i<N; i++) {
    if ( K[i] <= cand1 ) std::cout << cand2 << std::endl;
    else if ( K[i] >= cand2 ) std::cout << cand1 << std::endl;
  }
  return 0;
}


Measured memory_bytes: 5376
// #include {{{
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <complex>
#include <algorithm>
using namespace std;
// }}}
// #define {{{
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
#define de(x) cout << #x << "=" << x << endl
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define per(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
// }}}

const int N = 2e5 + 10;
int n , m , a , b , cnt[N];

int main(){
    scanf("%d%d",&n,&m);
    rep(i,0,m){
        scanf("%d%d",&a,&b);
        if(a == 1) cnt[b] ++;
        if(b == n) cnt[a] ++;
    }
    rep(i,1,n+1) if(cnt[i] == 2)
        return puts("POSSIBLE") , 0;
    puts("IMPOSSIBLE");
    return 0;
}


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

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)   FOR(i,0,n)
#define ll long long
#define PINT pair<int,int>
#define f1 first
#define s2 second
const int INF = 1e9 + 7;

using namespace std;

int main(){
    cin.tie(0), ios::sync_with_stdio(false);
    int x,y,z;
    cin >> x >> y >> z;
    if(x+y>=z) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0;
}


Measured memory_bytes: 256
#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define pb push_back
int dy[]={0, 0, 1, -1, 1, 1, -1, -1};
int dx[]={1, -1, 0, 0, 1, -1, -1, 1};

#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define mp make_pair
#define fi first
#define sc second
int n;
char s[10000];
char s2[10000];
int main(){
	cin >> n;
	cin >> s;

	while(1) {
		int l = 0;
		int d = 0;
		REP(i,n) {
			if(s[i] == '(') {
				l++;
			}else{
				if(l <= 0) {
					s2[d++] = '(';
					break;
				}
				l--;
			}
		}
		REP(i,n) {
			s2[i + d] = s[i];
		}

		if(!d && l > 0) {
			s2[n] = ')';
		}
		if(!d && l == 0) {
			break;
		}
		n++;
		REP(i,n) {
			s[i] = s2[i];
		}
		s[n] = '\0';
	}
	cout << s << endl;
	return 0;
}


Measured memory_bytes: 384
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
  long a;
  long  b;
  cin >> a;
  cin >> b;
  long count = 0;
  if(a== 1 && b==1){
    count = 1;
  }else if(a == 1){
    count = b - 2;
  }else if(b == 1){
    count = a - 2;
  }else{
    count = (a-2) * (b-2);
  }
 cout << count;
  return 0;
}


Measured memory_bytes: 256
import java.util.*;

public class Main {
public static void main(String[] args) {
		
		Scanner keyboard = new Scanner(System.in); 
		
		String S = keyboard.next();	
		String T = keyboard.next();	
			
		String[] strArrayS = S.split("");
		String[] strArrayT = T.split("");
		
		int Slong = S.length();
		
		int count = 0;
		for (int i=0; i<Slong; i++) {
			if(!strArrayS[i].contentEquals(strArrayT[i])) {

				count++;
			}
		}
					
							
		System.out.println(count);
		keyboard.close();	
	}
}


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

int main() {
  int n;
  cin >> n;
  if (n % 1000 % 111 == 0 || n / 10 % 111 == 0) {
    cout << "Yes" << endl;
  } else {
    cout << "No" << endl;
  }
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define fo(i, a, b) for (int i = a; i < b; i++)
#define re(i, n) fo(i, 0, n)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
int main()
{
  string s;
  cin >> s;

  regex r("(dream|dreamer|erase|eraser)*");

  if(regex_match(s, r)) cout << "YES" << endl;
  else cout << "NO" << endl;

  return 0;
}


Measured memory_bytes: 39808
#include <iostream>
#include <cstdio>
#include <iomanip>
#include <cmath>
using namespace std;

string S;

int main() {
  	cin.tie(0);
    ios::sync_with_stdio(false);
    cin >> S;
    if (S == "Sunny") {
      cout << "Cloudy";
    } else if (S == "Rainy") {
      cout << "Sunny";
    } else {
      cout << "Rainy";
    }
}

Measured memory_bytes: 256
/*
    ????????°??§???????????¨????????????
*/

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <limits.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <iterator>
#include <vector>
#include <map>
#include <utility>
#define LLU unsigned long long int
#define LL long long int
#define LD long double
using namespace std;
#define LLUmax ULLONG_MAX
#define LLmax LLONG_MAX
#define dmax INT_MAX
#define vd vector<int>
#define vLL vector<long long int>
#define vLLU vector<unsigned long long int> 
#define pb push_back
#define mp make_pair
#define fi first
#define sec second
#define debug printf("asd\n")
#define debugd(a) printf("--%d\n",a)
#define debugdd(a,b) printf("--%d %d\n",a,b)
#define debugarr(a,b) for(int i=0 ; i<b ; i++)printf("%d ",a[i]);printf("\n")
#define newline printf("\n")
#define forin(a,b,c) for(int a=b ; a<c ; a++)
#define forde(a,b,c) for(int a=b ; a<c ; a--)


inline void scd(int &a){scanf("%d",&a);}
inline void scdd(int &a,int &b){scanf("%d %d",&a,&b);}
inline void sctd(int &a,int &b,int &c){scanf("%d %d %d",&a,&b,&c);}
inline void scdlld(long int &a,long int &b){scanf("%I64d %I64d",&a,&b);}
inline void sclld(long long int &a){scanf("%I64d",&a);}

#define scarrd(a,b) for(int index=0 ; index<b ; index++)scanf("%d",&a[index])
#define prdlld(a,b) printf("%I64d %I64d",a,b)
#define prdd(a,b) printf("%d %d",a,b)
#define prd(a) printf("%d",a)
#define prarr(a,b) for(int i=0 ; i<b ; i++)printf("%d ",a[i])
#define iniarr(a,b) for(int i=0 ; i<b ;i++)a[i]=0
#define arr(a,b) int *a=(int *)malloc(b*sizeof(int))
#define llarr(a,b) long long int *a=(long long int *)malloc(b*sizeof(long long int))
#define st(a,b) char *a=(char *)malloc(b*sizeof(char))
#define grav 9.8
#define pi 3.14159265

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

int main()
{
	int a,b;
	scdd(a,b);
	printf("%d\n",gcd(a,b));
	return 0;
}

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

using namespace std;

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

    int n, a = 0, x, y;
    cin >> n >> y;

    for (int i = 1; i <= n; i++)
    {
        cin >> x;
        a += (x >= y);
    }
    cout << a << "\n";


    return 0;
}


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


int main()
{
	int a, b, x;
	string op;

	cin >> a >> op >> b;
	
	while (op != "?"){
		if (op == "+"){
			x = a + b;
		}
		else if (op == "-"){
			x = a - b;
		}
		else if (op == "*"){
			x = a*b;
		}
		else if (op == "/"){
			x = a / b;
		}
		cout << x << endl;
		cin >> a >> op >> b;
	}
	
	return 0;
}


Measured memory_bytes: 3120
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
//import java.lang.StringBuilder;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder(br.readLine());
        System.out.println(sb.reverse().toString());
    }
}

Measured memory_bytes: 16988
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i = 0; i<n; i++)
int main()
{
	int X,Y;
	cin >> X >> Y;
	int judge = 0;

	rep(i,X+1){
		if(i*2+(X-i)*4==Y){
			judge++;
			break;
		}
	}

	if(judge==0)
		cout << "No\n";
	else
		cout << "Yes\n";

	cin >> X;
	
	return 0;	
}


Measured memory_bytes: 3636
#include<bits/stdc++.h>
using namespace std;
int main(){
    int a,b,c=0,res,i;
    cin>>a>>b;
    if(a>b){
        swap(a,b);
    }
    for(i=a;i<=b;i++){
        res=a*b*i;
        if(res%2!=0){
            c=1;
            break;
        }
    }
    if(c==1){
        cout<<"Yes"<<endl;
    }
    else{
        cout<<"No"<<endl;
    }
    return 0;
}



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

#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define repr(i,a,b) for(int i=(int)(a-1);i>=b;i--)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout << #x" = " << x << endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;

#define INF INT_MAX/3

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


Measured memory_bytes: 256
#include<iostream>
#include<string>
#include<algorithm>	
#include<cmath>
#include<map>
#include<vector>
#define int long long
using namespace std;
int test[51];
signed main() {
    int n; double a, b; char x, y;
    while (cin >> n >> x >> a >> y >> b) {
        if (a / b / b >= 25) {
            cout << n << endl;
        }
    }
}


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

int main()
{
    int N, D;
    cin >> N >> D;
    if (N % (2 * D + 1) == 0)
        cout << N / (2 * D + 1) << endl;
    else
        cout << N / (2 * D + 1) + 1 << endl;
    return 0;
}


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

int main() {
  int A, B, C, X;
  int counter = 0;
  cin >> A >> B >> C >> X;
  for(int i = 0; i <= A; i++) {
    for(int j = 0; j <= B; j++) {
      for(int k = 0; k <= C; k++) {
        int sum = i*500 + j*100 + k*50;
        if(sum == X) counter++;
      }
    }
  }
  cout << counter << endl;
}


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

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

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

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

#define FF first
#define SS second

template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class T>
istream& operator>>(istream& is, vector<T>& xs){
  for(auto& x: xs)
	is >> x;
  return is;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& xs){
  for(unsigned int i=0;i<xs.size();++i)
	os << (i?" ":"") << xs[i];
  return os;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}
void debug(istringstream&){}
template <char sep=',', class Head, class... Tail>
void debug(istringstream& iss, Head&& head, Tail&&... tail)
{
  string name;
  getline(iss, name, ',');
  cerr << sep << name << "=" << head;
  debug(iss, forward<Tail>(tail)...);
}
#define DEBUG(...) \
  do{ \
    istringstream ss(#__VA_ARGS__); \
    debug<' '>(ss, __VA_ARGS__); \
    cerr<<endl; \
  }while(0)

const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

const int MX = 1000 * 1001 / 2;
LL sums[MX];
bool ng[MX];

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

  LL N, K;
  cin >> N >> K;
  VL xs(N);
  cin >> xs;

  int M = 0;
  REP(i,N){
    LL s = 0;
    FOR(j,i,N){
      s += xs[j];
      sums[M++] = s;
    }
  }

  LL ans = 0;
  for(int i=40;i>=0;--i){
    int cnt = 0;
    REP(j,M){
      if(!ng[j] && (sums[j]>>i&1))
        ++cnt;
    }
    if(cnt >= K){
      ans |= 1ll << i;
      REP(j,M){
        if(!ng[j] && (sums[j]>>i&1) == 0)
          ng[j] = true;
      }
    }
  }

  cout << ans << endl;

  return 0;
}


Measured memory_bytes: 4608
using System;

class ABC079A
{
	static public void Main(string[] args)
	{
		string s = Console.ReadLine();
	
		int count = 1;
		for(int i=1; i<s.Length; i++)
		{
			if(s[i-1] == s[i])
				count++;
			else
				count = 1;
			if(count == 3)
				break;
		}
		if(count == 3)
			Console.WriteLine("Yes");
		else
			Console.WriteLine("No");
	}
}


Measured memory_bytes: 13140
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
const int INFTY = (1 << 21); // 2097152
// const ll INFTY = (1LL << 60);
const ll MD = 1000000007LL;
// fprintf(stderr, "%d %lld \n", x, xll);


int H, W;
int C[26];
map<int, int> M;

bool run_x(int a){

    rep(i, M[a]/a){
        bool flg = false;
        rep(c, 26){
            if(C[c] >= a) {
                C[c] -= a;
                flg = true;
                break;
            }
        }
        if(!flg) return false;
    }

    return true;
}

bool run(){

    if(!run_x(4)) return false;
    if(!run_x(2)) return false;
    if(!run_x(1)) return false;
	return true;
}

int main() {
	rep(c, 26) C[c] = 0;

	// count
	cin >> H >> W;
	rep(y, H){
		string s; cin >> s;
		rep(x, W) C[s[x] - 'a']++;
	}

	// make pairs
	M.insert(make_pair(1, 0));
	M.insert(make_pair(2, 0));
	M.insert(make_pair(4, 0));

	rep(y, H) rep(x, W){
		int a = (y * 2 == H - 1 ? 1 : 2) * (x * 2 == W - 1 ? 1 : 2);
		M[a] += 1;
	}
    // fprintf(stderr, "%d %d %d %d %d\n", H, W, M[4], M[2], M[1]);

    cout << (run() ? "Yes" : "No") << endl;
}

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

int n,M[105][105],d[105];
queue<int> Q;

void dfs(int s){
	d[s]=0;
	Q.push(s);
	int v;
	while(!Q.empty()){
		s=Q.front();Q.pop();
		for(int v=0;v<n;v++){
			if(M[s][v]==0){
				continue;
			}
			if(d[v]!=-1){
				continue;
			}
			d[v]=d[s]+1;
			Q.push(v);
		}
	}
}

int main() {
  cin>>n;
  for(int i=0;i<105;i++){
  	d[i]=-1;
    for(int j=0;j<105;j++){
      M[i][j];
    }
  }
  int u,k,v;
  for(int i=0;i<n;i++){
    cin>>u>>k;
    u--;
    for(int j=0;j<k;j++){
      cin>>v;
      v--;
      M[u][v]=1;
    }
  }
  dfs(0);
  for(int i=0;i<n;i++){
  	printf("%d %d\n",i+1,d[i]);
  }
}


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

#define rep(i,n) for(int i=0;i<n;i++)
#define srep(i,s,e) for(int i=s;i<=e;i++)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define MAX (int)1e9 + 99
#define vi vector<int>
#define vb vector<bool>
#define ll long long
#define ull unsigned long long
#define vll vector<ll>
#define pa pair<int, int>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define MOD 998244353
#define bitcnt(x) __builtin_popcount(x)
#define gcd(a,b) __gcd(a,b)
#define all(x) (x).begin(),(x).end()
#define ts(x) to_string(x)
ll fastPowMod(ll a, ll p,ll mod){ if(p==0) return 1; ll z = fastPowMod(a,p/2,mod); z = (z*z)%mod; if(p%2) z = (z*a)%mod; return z; }
template<class T> istream &operator>>(istream &is, vector<T> &v) { for (T &x : v) is >> x; return is;}
template<class T> ostream &operator<<(ostream &os, const vector<T> &v) {if (!v.empty()) {os << v.front();for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];} return os;}


void solve()
{
    int n;
    cin>>n;
    vi a(n),b(n),c(n);

    rep(i,n)
    cin>>a[i]>>b[i]>>c[i];

    int dp[n][3];
    memset(dp,0,sizeof(dp));

    dp[0][0] = a[0];
    dp[0][1] = b[0];
    dp[0][2] = c[0];

    srep(i,1,n-1)
    {
        dp[i][0] = a[i] + max(dp[i-1][1], dp[i-1][2]);
        dp[i][1] = b[i] + max(dp[i-1][0], dp[i-1][2]);
        dp[i][2] = c[i] + max(dp[i-1][0], dp[i-1][1]); 
    }



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

int main()
{
    fastio
    /*int t;
    cin>>t;
    
    rep(i,t)
    {*/
        solve();
        cout<<"\n";
    //}
    return 0;
}

Measured memory_bytes: 5564
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, a, b) for (int i = a; i < (b); i++)
#define FOR(i, n) for (int i = n; i >= 0; i--)
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ll long long
#define SIZE 100001
#define MOD 1000000007
#define INF 100000000
using namespace std;
 
int main() {
  int n;
  cin >> n;
 
  int a[200001];
 
  REP(i, n) cin >> a[i];
  ll sum = 0;
  REP(i, n) sum += a[i];
 
  ll min_num = 2000000001;
  ll ans = 0;
  REP(i, n-1) {
    ans += a[i];
    ll other = sum - ans;
    if (abs(ans - other) < min_num) {
      min_num = abs(ans - other);
    }
  }
 
  cout << min_num << endl;
 
  return 0;
}

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

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

int main() {
        string s;
        cin >> s;
        string ss = "CODEFESTIVAL2016";
        int ans = 0;
        rep(i, s.size()) {
                ans += s[i] != ss[i];
        }
        cout << ans << endl;
        return 0;
}



Measured memory_bytes: 256