akhauriyash/Code-Regression huggingface dataset:
#include <iostream>
#include <stdio.h>
using namespace std;

struct Node {
  Node* parent;
  Node* left;
  Node* right;
  int value;
  Node() : parent(NULL), left(NULL), right(NULL), value(-1) {
  }
};

Node* root = NULL;

void insert(int value) {
  if(root == NULL) {
    root = new Node();
    root->value = value;
    return;
  }

  Node* parent = root;
  Node* node = root;
  int left = 0;
  while(node != NULL) {
    parent = node;
    if(node->value < value) {
      left = 0;
      node = node->right;
    } else {
      left = 1;
      node = node->left;
    }
  }

  Node* newNode = new Node();
  newNode->value = value;
  newNode->parent = parent;
  if(left == 1) {
    parent->left = newNode;
  } else {
    parent->right = newNode;
  }
}

void printInOrder(Node* n) {
  if(n->left != NULL)
    printInOrder(n->left);
  cout << " " << n->value;
  if(n->right != NULL)
    printInOrder(n->right);
}

void printPreOrder(Node* n) {
  cout << " " << n->value;
  if(n->left != NULL)
    printPreOrder(n->left);
  if(n->right != NULL)
    printPreOrder(n->right);
}

void print() {
  printInOrder(root);
  cout << endl;
  printPreOrder(root);
  cout << endl;
}

int main() {
  int n;
  cin >> n;
  for(int i=0; i<n; i++) {
    string op;
    cin >> op;

    if(op.compare("insert") == 0) {
      int value;
      cin >> value;

      insert(value);
    } else if(op.compare("print") == 0) {
      print();
    } else {
      cout << "unknown op: " << op << endl;
      return 1;
    }
  }
  return 0;
}

Measured memory_bytes: 26564
#include <bits/stdc++.h>
using namespace std;
 
int main() {
  int a,b,c;
  cin >> a >> b >> c;
  if (a == 5 & b == 5 & c == 7 || a == 5 & b == 7 & c == 5 || a == 7 & b == 5 & c == 5) {
  	cout << "YES" << endl;
  }else {
  	cout << "NO" << endl;
  }
}

Measured memory_bytes: 256
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
	int K,N;
	int buf;
	int max;
	vector <int> A;
	vector <int> distance;
	cin >> K >> N;
	for(int i = 0;i <= N - 1;i++){
		cin >> buf;
		A.push_back(buf);
	}
	for(int i = 0;i <= N-2;i++){
		distance.push_back(A[i+1] - A[i]);
	}
	distance.push_back(K - A[N-1] + A[0]);
	max = *max_element(distance.begin(),distance.end());
	cout << K - max;


	return 0;
}


Measured memory_bytes: 2548
(* unihernandez22
 * https://atcoder.jp/contests/abc176/tasks/abc176_b
 * implementation
 * *)

Printf.printf "%s\n" @@
Scanf.scanf "%s\n" @@ fun n ->
  let digits_sum = ref 0 in
  for i = 0 to String.length n - 1 do
    digits_sum := !digits_sum + (int_of_char n.[i]) - 48;
  done;
  if !digits_sum mod 9 = 0 then
    "Yes"
  else
    "No";;


Measured memory_bytes: 4376
import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner scn=new Scanner(System.in);
		int n=scn.nextInt();
		int k=scn.nextInt();
		int[] arr=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=scn.nextInt();
		}
		System.out.println(frog1(arr,k));
		
		
	}
	public static int frog1(int[] heights,int k) {
		
		int[] dp=new int[heights.length];
		dp[0]=0;
		dp[1]=Math.abs(heights[0]-heights[1]);
		
		int min=0;
		for(int vidx=2;vidx<heights.length;vidx++) {
			min=Integer.MAX_VALUE;
			for(int j=vidx-k;j<vidx;j++) {
				if((j)<0) {
					continue;
				}
		
				int val=Math.abs(heights[vidx]-heights[j])+dp[j];
				
				if(min>val) {
					min=val;
					dp[vidx]=min;
				}
				
			}
			
			
		}
		
		return dp[heights.length-1];
			
	}

}


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

// m < n
int gcd(int m, int n) {
    int t;
    while (m > 0) {
        t = m;
        m = n % m;
        n = t;
    }
    return n;
}


string affine(int a, int b, const string& word) {
    string newword;
    newword.resize(word.size());
    for (int i = 0, l = word.size(); i < l; i++) {
        if ('a' <= word[i] && word[i] <= 'z') {
            newword[i] = ((a * (word[i] - 'a') + b) % 26) + 'a';
        }
        else {
            newword[i] = word[i];
        }
    }
    return newword;
}

int main() {
    int n;
    string line;

    cin >> n;
    cin.ignore();
    while (n--) {
        int a, b;
        bool found_param = false;
        char tbl[26];

        getline(cin, line);
        for (a = 1; a < 26; a++) {
            if (gcd(a, 26) != 1) continue;
            for (b = 0; b < 26; b++) {
                string w1 = affine(a, b, "that");
                string w2 = affine(a, b, "this");
                string::size_type p1 = line.find(w1);
                string::size_type p2 = line.find(w2);
                if (p1 != string::npos || p2 != string::npos) {
                    found_param = true;
                    break;
                }
            }
            if (found_param) break;
        }
        if (!found_param) continue;
        for (int i = 0; i < 26; i++) {
            tbl[(a * i + b) % 26] = i + 'a';
        }
        for (int i = 0, l = line.size(); i < l; i++) {
            if ('a' <= line[i] && line[i] <= 'z') {
                cout << tbl[line[i] - 'a'];
            }
            else {
                cout << line[i];
            }
        }
        cout << endl;
    }
    return 0;
}

Measured memory_bytes: 1220
from collections import deque

H, W = [int(i) for i in input().split()]
A = [list(input()) for _ in range(H)]

Q = deque()
for i in range(H):
    for j in range(W):
        if A[i][j] == "#":
            Q.append((i, j, 0))

ma = 0
while Q:
    i, j, dist = Q.popleft()
    ma = max(ma, dist)
    for ni, nj in [(i + 1, j), (i, j + 1), (i - 1, j), (i, j - 1)]:
        if 0 <= ni < H and 0 <= nj < W and A[ni][nj] == ".":
            A[ni][nj] = "#"
            Q.append((ni, nj, dist + 1))

print(ma)

Measured memory_bytes: 161628
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;

#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
#define INF 0x3f3f3f3f

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};

// https://gist.github.com/MagallanesFito/61afb009986f0319774cb079b8914bb2
typedef pair<int, int> myPair;
class Graph {
  int V;
  list<myPair> *adj;

public:
  Graph(int V);
  void addEdge(int u, int v, int w);
  set<pair<ll, ll>> shortestPath(int src);
};
Graph::Graph(int V) {
  this->V = V;
  adj = new list<myPair>[this->V];
}
void Graph::addEdge(int u, int v, int w) {
  // adj[u].push_back(makepair(v,w));
  // adj[v].push_back(makepair(u,w));
  adj[u].push_back({v, w});
  adj[v].push_back({u, w});
}
// Dijkstra
set<pair<ll, ll>> Graph::shortestPath(int src) {
  // pair<peso,label>
  priority_queue<myPair, vector<myPair>, greater<myPair>> pq;
  vector<int> dist(this->V, INF);
  vector<int> pre(this->V);
  dist[src] = 0;
  pre[src] = 0;
  list<myPair>::iterator it;

  pq.push({0, src});
  while (!pq.empty()) {
    int u = pq.top().second;
    pq.pop();

    for (it = adj[u].begin(); it != adj[u].end(); ++it) {
      int v = it->first;
      int w = it->second;
      if (dist[v] > dist[u] + w) {
        dist[v] = dist[u] + w;
        pre[v] = u;
        pq.push({dist[v], v});
      }
    }
  }

  set<pair<ll, ll>> ret;
  for (int i = 0; i < this->V; i++) {
    if (pre[i] != 0) {
      ret.insert(mp(pre[i], i));
    }
  }

  return ret;
}

void solve(long long N, long long M, std::vector<long long> a,
           std::vector<long long> b, std::vector<long long> c) {
  Graph g(N + 1);
  rep(m, M) { g.addEdge(a[m], b[m], c[m]); }

  set<pair<ll, ll>> passed;
  rep(s, N + 1) {
    if (s == 0) {
      continue;
    }
    set<pair<ll, ll>> tmp = g.shortestPath((int)s);
    for (auto t : tmp) {
      passed.insert(t);
    }
  }

  int ans = 0;
  rep(m, M) {
    if (find(all(passed), mp(a[m], b[m])) == passed.end()) {
      ans++;
    }
  }

  print(ans);
}

int main() {
  long long N;
  scanf("%lld", &N);
  long long M;
  scanf("%lld", &M);
  std::vector<long long> a(M);
  std::vector<long long> b(M);
  std::vector<long long> c(M);
  for (int i = 0; i < M; i++) {
    scanf("%lld", &a[i]);
    scanf("%lld", &b[i]);
    scanf("%lld", &c[i]);
  }
  solve(N, M, std::move(a), std::move(b), std::move(c));
  return 0;
}


Measured memory_bytes: 384
#include<cstdio>
using namespace std;

long long n,a[100010];
long long ans;

inline long long abs(const long long x)
{
	if(x<0)  return -x;
	return x;
}
int main()
{
	scanf("%lld",&n);
	for(register int i=1;i<=n;i++)
	{
		scanf("%lld",&a[i]);
		ans+=abs(a[i]-a[i-1]);
	}
	ans+=abs(a[n]);
	for(register int i=1;i<=n;i++)
	{
		register long long sum=ans;
		sum-=abs(a[i]-a[i-1])+abs(a[i+1]-a[i]);
		sum+=abs(a[i+1]-a[i-1]);
		printf("%lld\n",sum);
	}
	return 0;
}

Measured memory_bytes: 1920
N = int(input())
D, X = map(int, input().split())
A = [int(input()) for _ in range(N)]

n_eaten_choco = 0
for a in A:
    i = 0 
    while a*i + 1 <= D:
        n_eaten_choco += 1
        i += 1

print(X + n_eaten_choco)

Measured memory_bytes: 3060
#include<bits/stdc++.h>
using namespace std;
int main(){
    int a,b,c,d,e,f,g,h,i;
    scanf ("%d%d%d",&a,&b,&e);  
    c=3*e-a-b;
    h=2*e-b;
    f=2*a-h;
    i=3*e-c-f;
    d=2*e-f;
    g=3*e-h-i;
    printf ("%d %d %d\n",a,b,c);
    printf ("%d %d %d\n",d,e,f);
    printf ("%d %d %d\n",g,h,i);  
    return 0;
}

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

int main() {
  
  string s,t;
  cin >> s >> t;
  
  int N = s.size();
  int ans = 0;
  
  for (int i = 0; i < N; i++) {
    if (s[i] != t[i]) {
      ans++;
    }
  }
  
  cout << ans;
  
}


Measured memory_bytes: 3904
#include <iostream>
#include <vector>
#include <sstream>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)

vector<string> split(const string &s, char delim) {
    vector<string> elems;
    stringstream ss(s);
    string item;
    while (getline(ss, item, delim)) {
        if (!item.empty()) {
            elems.push_back(item);
        }
    }
    return elems;
}

int main(){
    string s = "1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51";
    int k; cin >> k;
    char d = ',';
    vector<string> v;
    v = split(s, d);
    cout << v[k-1];
}


Measured memory_bytes: 256
n,k=map(int,input().split())
t=[tuple(map(int,input().split()))for i in range(n)]
t=sorted(t,key=lambda t:t[0])
total=0
for i in range(n):
    total+=t[i][1]
    if k<=total:
        print(t[i][0])
        exit()


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

int n, k;
int a[10];

bool used[10] = {false};
int b[10];
set<int> dict;

void dfs(int id) {
	if (id == k) {
		int num = 0;
		for (int i = 0; i < k; i++) {
			if (b[i] >= 10) num *= 100;
			else num *= 10;
			num += b[i];
		}
		dict.insert(num);
	}
	for (int i = 0; i < n; i++) {
		if (!used[i]) {
			used[i] = true;
			b[id] = a[i];
			dfs(id + 1);
			used[i] = false;
		}
	}
}

int main() {
	while (cin >> n >> k) {
		if (!n) break;
		dict.clear();
		for (int i = 0; i < n; i++) cin >> a[i];
		dfs(0);
		cout << dict.size() << endl;
	}
	return 0;
}

Measured memory_bytes: 1308
#include<bits/stdc++.h>
using namespace std;
#define  ft  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define  ll  long long
ll M=1e9+7;
int main()
{
    ft
    int t,i,j,n,m,l,r;
    cin>>n>>m;
    string s[n+1];
    ll dp[n+1][m+1];
    for(i=0;i<n;i++)
    {
        cin>>s[i];
    }
    l=1;
    for(i=0;i<n;i++)
    {
        if(s[i][0]=='#')
        {
            l=0;
        }
        dp[i][0]=l;
    }
    l=1;
    for(i=0;i<m;i++)
    {
        if(s[0][i]=='#')
        {
            l=0;
        }
        dp[0][i]=l;
    }
    for(i=1;i<n;i++)
    {
        for(j=1;j<m;j++)
        {
            if(s[i][j]=='#')
            {
                dp[i][j]=0;
            }
            else
            {
                dp[i][j]=(dp[i-1][j]+dp[i][j-1])%M;
            }
        }
    }
    cout<<dp[n-1][m-1]<<"\n";
    return 0;
}

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

// region template
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;

ll gcd(ll a, ll b) { return __gcd(a, b); }

ll euclid(ll a, ll b, ll &x, ll &y) {
    if (b) { ll d = euclid(b, a % b, y, x);
        return y -= a/b * x, d; }
    return x = 1, y = 0, a;
}

typedef unsigned long long ull;
typedef long double ld;
ull mod_mul(ull a, ull b, ull M) {
    ll ret = a * b - M * ull(ld(a) * ld(b) / ld(M));
    return ret + M * (ret < 0) - M * (ret >= (ll)M);
}
ull mod_pow(ull b, ull e, ull mod) {
    ull ans = 1;
    for (; e; b = mod_mul(b, b, mod), e /= 2)
        if (e & 1) ans = mod_mul(ans, b, mod);
    return ans;
}

const ll mod = 1000000007;
struct Mod {
    ll x;
    Mod(ll xx) : x(xx) {}
    Mod operator+(Mod b) { return Mod((x + b.x) % mod); }
    Mod operator-(Mod b) { return Mod((x - b.x) % mod); }
    Mod operator*(Mod b) { return Mod((x * b.x) % mod); }
    Mod operator/(Mod b) { return *this * invert(b); }
    Mod invert(Mod a) {
        ll x, y, g = euclid(a.x, mod, x, y);
        assert(g == 1); return Mod((x + mod) % mod);
    }
    Mod operator^(ll e) {
        if (!e) return Mod(1);
        Mod r = *this ^ (e / 2); r = r * r;
        return e & 1 ? *this * r : r;
    }
};
// endregion

const int nmax = (1 << 15) + 5;

int cnt[nmax];

int main() {
    cin.sync_with_stdio(0); cin.tie(0); cin.exceptions(cin.failbit);

    for (int i = 1; i * i < nmax; i++) {
        cnt[i * i]++;
        for (int j = i; i * i + j * j < nmax; j++) {
            cnt[i * i + j * j]++;
            for (int k = j; i * i + j * j + k * k < nmax; k++) {
                cnt[i * i + j * j + k * k]++;
                for (int l = k; i * i + j * j + k * k + l * l < nmax; l++) {
                    cnt[i * i + j * j + k * k + l * l]++;
                }
            }
        }
    }

    for (;;) {
        int n; cin >> n;
        if (!n) break;
        cout << cnt[n] << endl;
    }
}


Measured memory_bytes: 3276
using System;
using System.Collections.Generic;
class aoj_2_1_A{
  public static void Main(){
    List<string> list = new List<string>();
    int numoforder = int.Parse(Console.ReadLine());
    for(int i=0; i<numoforder; i++){
      String[] order = Console.ReadLine().Split(' ');
      switch (int.Parse(order[0])){
        case 0:
          list.Add(order[1]);
          break;
        case 1:
          Console.WriteLine(list[int.Parse(order[1])]);
          break;
        case 2:
          list.RemoveAt(list.Count-1);
          break;
        default:
          break;
      }
    }
  }
}



Measured memory_bytes: 30708
//#include <bits/stdc++.h>
#include <string>
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>
#include <climits>

using namespace std;
using ll=long long;

void solve(){
  int s;
  cin >> s;
  cout << s/3600 << ":" << s%3600/60 << ":" << s%60 << endl;
}

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



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

using namespace std;
#define all(a)a.begin(),a.end()
using ll=long long;
const int INF = 1<<30;
const ll INFll =1LL<<62;
const int mod= int(1e9)+7;
using P = pair<ll,ll>;
using ld=long double;

int main(){
    vector<vector<int>>d(10,vector<int>(10));
    int h,w;cin >>h>>w;
    for (int i = 0; i < 10; ++i) {
        for (int j = 0; j < 10; ++j) {
            cin >>d[i][j];
        }
    }
    for (int k = 0; k < 10; ++k) {
        for (int i = 0; i < 10; ++i) {
            for (int j = 0; j < 10; ++j) {
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
    int ans=0;
    for (int i = 0; i <h; ++i) {
        for (int j = 0; j < w; ++j) {
            int a;cin >>a;
            if(a==-1)continue;
            else ans+=d[a][1];
        }
    }
    cout <<ans <<endl;
    return 0;
}


Measured memory_bytes: 3624
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define rep2(i, a)for(auto i : a)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x, std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll co(ll n, ll k) { ll a = 1; rep(i, 1ll, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }

int main(void) {
	int d, t, s;
	cin >> d >> t >> s;
	puts(t * s >= d ? "Yes" : "No");
	return 0;
}


Measured memory_bytes: 3632
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<stack>
#include<functional>
#include<queue>
#include<vector>
#include<algorithm>
#include<iomanip>
#include<utility>
#include<set>
#include<unordered_set>
#include<map>
#include<unordered_map>
typedef long long int ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) for(int i=0;i<signed(n);i++)
#define EREP(i,n) for(int i=1;i<=signed(n);i++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
//#define EVEL 1
#ifdef EVEL
#define DEB(X) cout << #X <<":" <<X<<" " ;
#define TF(f) f ? cout<<"true  " : cout<<"false ";
#define END cout<<"\n";
#else
#define DEB(X) {}
#define TF(f) {}
#define END {}
#endif
const ll MOD = 1000000007;
const ll INF = 9e14;
typedef std::pair<ll,ll> P;
struct edge{ int to,cost; };
#define VMAX 100000
//bool cmp(P a,P b){ return a.second < b.second;}
struct UnionFind {
    vector< int > data;
    UnionFind(int sz){
        data.assign(sz, -1);
    }

    bool unite(int x, int y){
        x = find(x), y = find(y);
        if(x == y) return(false);
        if(data[x] > data[y]) std::swap(x, y);
        data[x] += data[y];
        data[y] = x;
        return(true);
    }

    int find(int k){
        if(data[k] < 0) return(k);
        return(data[k] = find(data[k]));
    }

    bool same(int x,int y){
        return find(x)==find(y);
    }
    int size(int k){
        return(-data[find(k)]);
    }
};

	ll N,M,K,ans=0;
	// ll A[100010];
	// ll B[100010];
	// ll C[100010];



int main(){
	std::ios_base::sync_with_stdio(false);
	cin>>N>>M>>K;
	UnionFind U(100010);
	std::vector<int> G[100010],H[100010];
	REP(i,M){
		int a,b;
		cin>>a>>b;
		a--,b--;
		G[a].push_back(b);
		G[b].push_back(a);
		U.unite(a,b);
	}
	REP(i,K){
        int a,b;
		cin>>a>>b;
		a--,b--;
		H[a].push_back(b);
		H[b].push_back(a);
	}
	REP(i,N){
        ll as=U.size(i)-1-G[i].size();
        REP(j,H[i].size()){
            if(U.same(H[i][j],i)){
                as--;
            }
        }
        cout<<as;
        if(i!=N-1)cout<<" ";
	}
	// cout<<ans<<endl;

	return 0;
}


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

int main (void) {
    int a, b;

    scanf("%d%d", &a, &b);

    if ( a%2 == 0 || b%2 == 0 )
        printf("No\n");
    else
        printf("Yes\n");

    return EXIT_SUCCESS;
}


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

void fnInput(int& rnSpcNum, int& rnMinSum, int& rnMaxSum)
{
  cin >> rnSpcNum >> rnMinSum >> rnMaxSum;
}

int fnDigitsSum(int nNum)
{
  int nDigitsSum = 0;
  while ( nNum )
  {
    nDigitsSum += nNum % 10;
    nNum /= 10;
  }
  return nDigitsSum;
}

int fnSomeSums(int nSpcNum, int nMinSum, int nMaxSum)
{
  int nTotal = 0;
  for (int n = 1; n <= nSpcNum; n++)
  {  
    int nDigitsSum = 0;

    nDigitsSum += fnDigitsSum(n);
    if (nMinSum <= nDigitsSum && nDigitsSum <= nMaxSum)
      nTotal += n;
  }
  return nTotal;
}

int main()
{
  int nSpcNum, nMinSum, nMaxSum;
  fnInput(nSpcNum, nMinSum, nMaxSum);

  cout << fnSomeSums(nSpcNum, nMinSum, nMaxSum)  << endl;
  return 0;
}
 

Measured memory_bytes: 256
#include<stdio.h>
int main()
{
    char n[17];
    scanf("%s", n);
    int i, a, b, j;
    i = a = b = j = 0;
    int p;
    while (n[i] != '\0')
    {
        i++;
    }
    j = 0;
    for (b = 1; b < i; b++)
        if (n[b] != '9')
            j++;
    if (j == 0)
    {
        a = (i - 1) * 9 + (n[0] - '0');
    }
    else
    {
        while (n[0] == '0')
        {
            for (j = 0; j < i - 1; j++)
                n[j] = n[j + 1];
            i--;
        }
        a = 9 * (i - 1) + (int)(n[0] - '0') - 1;
    }
    printf("%d\n", a);
    return 0;
}

Measured memory_bytes: 128
#include <bits/stdc++.h>
using namespace std;
#define INF 2147483647
#define INFF 9223372036854775807
#define ll long long
#define REP(i,n) for(int i=0;i<n;i++)
#define REPP(i,m,n) for(int i=m;i<n;i++)
#define ALL(N) (N.begin(),N.end())
#define de cout << "line : " << __LINE__ << " debug" << endl;
#define pb push_back
#define pq priority_queue
#define Dcout(N) cout << setprecision(20) << N << endl;
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; }


signed main(){
    int N;
    cin >> N;
    vector<int> L(N);
    REP(i,N) cin >> L[i];
    sort ALL(L);
    int ans = 0;
    REP(i,N){
        REPP(j,i+1,N){
            int k = lower_bound(L.begin(),L.end(),L[i] + L[j]) - L.begin();
            ans += max(k - (j+1),0);
        }
    }
    cout << ans << endl;
}


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

int main(){
	int n,y;
	cin>>n>>y;
	for(int s10=0;s10<=min(y/10000,n);s10++){
		for(int s5=0;s5<=min((y-s10*10000)/5000,n);s5++){
			if(s10*10000 + s5*5000 + (n-s10-s5)*1000 == y){
				cout<<s10<<" "<<s5<<" "<<n-s10-s5<<endl;
				return 0;
			}
		}
	}
	cout<<"-1 -1 -1"<<endl;
	return 0;
}


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

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

const long long INF =1LL << 60;

int N;
long long a[1000010][3];

long long dp[1000010][3];

int main() {
  int N, K; cin >> N;
  for (int i = 0; i < N; i++) for (int j = 0; j < 3; j++) cin >> a[i][j];
  
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < 3; j++) {
      for (int k = 0; k < 3; k++) {
        if (j == k) continue;
        chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
      }
    }
  }
  long long res = 0;
  for (int j = 0; j < 3; j++) chmax(res, dp[N][j]);
  
  cout << res << endl;
}
    


Measured memory_bytes: 8448
#include<iostream>
#include<stdio.h>
#include<string>
#include<math.h>
#include<algorithm>
using namespace std;
int main(){
	int n, d, cnt = 0;
	double x, y;
	cin >> n >> d;
	for (int i = 1; i <= n; i++){
		cin >> x >> y;
		if (sqrt(x*x + y*y) <= d)cnt++;
	}
	cout << cnt << endl;
	return 0;
}

Measured memory_bytes: 3784
round=int(input())
T_pt=0
H_pt=0

for i in range(round):
	pair=raw_input().split(" ")
	T_card=pair[0].lower()
	H_card=pair[1].lower()

	if T_card<H_card:
		H_pt+=3
	elif T_card>H_card:
		T_pt+=3
	else:
		T_pt+=1
		H_pt+=1
print T_pt,H_pt

Measured memory_bytes: 6284
using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
using static System.Math;

namespace A_ABC132
{
    class MainClass
    {

        static int[] s;

        public static void Main(string[] args)
        {

            string u = ReadLine();
            string ans = "No";
            string y = "Yes";
            if (u[0] == u[1] && u[1] == u[2] && u[2] == u[3])
            {

                WriteLine(ans);
                return;
            }
            if (u[0] == u[1] && u[2] == u[3])
            {
                ans = y;
                WriteLine(ans);
                return;
            }
            if (u[0] == u[2] && u[1] == u[3])
            {
                ans = y;
                WriteLine(ans);
                return;
            }
            if (u[0] == u[3] && u[1] == u[2])
            {
                ans = y;
                WriteLine(ans);
                return;
            }
            WriteLine(ans);


        }
    }
}


Measured memory_bytes: 11092
#include <stdio.h>
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define FOR(i,m,n) for(i=m;i<n;i++)

int main(void)
{
	int a,b,c,i,x=0,y;
	scanf("%d %d %d",&a,&b,&c);
	for(i=110;i>0;i--){
		if(a%i==0){
			if(b%i==0){
				x++;
			}
		}
		if(x==c){
			y=i;
			break;
		}
	}
	printf("%d",y);
	return 0;
}

Measured memory_bytes: 128
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0; i<(int)(n); i++)
int main(){
int D, T, S; string ans="Yes"; cin >> D >> T >> S;
if(S*T<D){ ans="No"; }
cout << ans << "\n";
}

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

int main(){
    int N;
    int A[2][100];

    cin >> N;
    for(int i=0;i<2;i++)
        for(int j=0;j<N;j++)
            cin >> A[i][j];
    
    int max=0;
    for(int i=0;i<N;i++){
        int count=0;
        for(int j=0;j<=i;j++){
            count+=A[0][j];
        }
        for(int j=i;j<N;j++){
            count+=A[1][j];
        }

        if(count>max) max=count;
    }

    cout << max;

    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 1e5;

int totalNoDays;
int happyMatrix[3][N];
int dp[3][N];
int bestDayRoutine(int previousDayTask,int noOfDays){
   if(noOfDays==totalNoDays)
    return 0;
    if(dp[previousDayTask][noOfDays]!=0){
        return dp[previousDayTask][noOfDays];
    }
    if(noOfDays==0){
        int x = happyMatrix[0][noOfDays]+bestDayRoutine(0,noOfDays+1);
        int y = happyMatrix[1][noOfDays]+bestDayRoutine(1,noOfDays+1);
        int z = happyMatrix[2][noOfDays]+bestDayRoutine(2,noOfDays+1);
        return max(x,max(y,z));
    }
    else{
        int sum = 0;
        for(int i=0;i<3;i++){
            if(i != previousDayTask){
                sum = max(sum,happyMatrix[i][noOfDays]+bestDayRoutine(i,noOfDays+1));
            }
        }
        dp[previousDayTask][noOfDays] = sum;
        return sum;
    }
}

int main() {
	// your code goes here
	cin>>totalNoDays;

	for(int i = 0;i<totalNoDays;i++){
	    scanf("%d %d %d",&happyMatrix[0][i],&happyMatrix[1][i],&happyMatrix[2][i]);
	}
	for(int i=0;i<totalNoDays;i++){
        for(int j=0;j<3;j++){
            dp[j][i] = 0 ;
        }
	}
	cout<<bestDayRoutine(0,0)<<endl;
	return 0;
}


Measured memory_bytes: 10368
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<iomanip>
#include<queue>
#include<numeric>
typedef long long LL;

using namespace std;

LL gcd(LL a, LL b) {
	LL r;
	while ((r = a % b) != 0) {
		a = b;
		b = r;
	}
	return b;
}
LL lcm(LL a, LL b) {
	return (a / gcd(a, b) * b);
}


int main(void) {
	int n;
	cin >> n;
	vector<LL>a(n);
	map<LL, LL>m;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
		m[a[i]]++;
	}
	LL ans = 0;
	for (int i = 0; i < n; i++) {
		if (m[a[i]] % 2 != 0) {
			ans++;
			m[a[i]] = 0;
		}
	}
	cout << ans;
	return 0;
}

Measured memory_bytes: 7296
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Node{
    int key;
    struct Node *parent,*right,*left;
};

struct Node *root,*NIL;

struct Node *find(struct Node *x, int y){
    while(x!=NIL && y!=x->key){
        if(y<x->key)x=x->left;
        else x=x->right;
    }
    return x;
}

void insert(int k){
struct Node *y=NIL;
struct Node *x=root;
struct Node *z;

z=(struct Node *)malloc(sizeof(struct Node));
z->key=k;
z->left=NIL;
z->right=NIL;

while(x!=NIL){
    y=x;
    if(z->key<x->key){
        x=x->left;
    }
    else x=x->right;
}
z->parent=y;
if(y==NIL){
    root=z;
}
else{
    if(z->key<y->key){
        y->left=z;
    }
    else y->right=z;
}
}
void inorder(struct Node *u){
    if(u==NIL) return;
    inorder(u->left);
    printf(" %d",u->key);
    inorder(u->right);
}

void preorder(struct Node *u){
    if(u==NIL)return;
    printf(" %d",u->key);
    preorder(u->left);
    preorder(u->right);
}
int main(){
    int n,i,x;
    char str[10];
   scanf("%d",&n);

    for(i=0;i<n;i++){
        scanf("%s",str);
       
        if(str[0]=='i'){
            scanf("%d",&x);
            insert(x);
        }
        
        else if(str[0]=='p'){
            inorder(root);
            printf("\n");
            preorder(root);
            printf("\n");
        }
        else if(str[0]=='f'){
            scanf("%d",&x);
            struct Node *f=find(root,x);
            if(f!=NIL)printf("yes\n");
            else printf("no\n");
        }
    }
    return 0;
}



Measured memory_bytes: 20500
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


# aとbの最大公約数
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


# aとbの最小公倍数
def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


def main():
    b = input()
    m = {"A": "T", "T": "A", "C": "G", "G": "C"}

    print(m[b])


if __name__ == '__main__':
    main()


Measured memory_bytes: 4072
#include <iostream>
#include <string>
using namespace std;
int main(){
  int n,m;
  cin>>n;
  m=n%10;
    if (m==2||m==4||m==5||m==7||m==9)
      cout<<"hon"<<endl;
    else if (m==0||m==1||m==6||m==8)
      cout<<"pon"<<endl;
    else
      cout<<"bon"<<endl;
}

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

using ll = long long;
using vll = vector<ll>;

int main () {
  int n;
  ll k;
  cin >> n >> k;
  vll arr(n), m_arr(n);
  for (int i = 0; i < n; ++i) {
    ll x;
    cin >> x;
    arr[i] = x;
    m_arr[i] = -x;
  }
  sort(arr.begin(), arr.end());
  sort(m_arr.begin(), m_arr.end());

  ll ok = - 1e18;
  ll ng = 1e18 + 1;

  while (ng - ok > 1) {
    ll mid = (ok + ng) / 2;
    ll smaller = 0;
    ll smaller_or_same = 0;

    for (int i = 0; i < n; ++i) {
      ll a = arr[i];
      if (a > 0) {
        ll b = mid / a;
        if (mid < 0 && mid % a != 0) b--;
        smaller_or_same += max(0, static_cast<int>(distance(arr.begin(), upper_bound(arr.begin(), arr.end(), b)) - (i + 1)));
        if (mid % a != 0) b++;
        smaller += max(0, static_cast<int>(distance(arr.begin(), lower_bound(arr.begin(), arr.end(), b)) - (i + 1)));
      }
      if (a < 0) {
        ll b = mid / (-a);
        if (mid < 0 && mid % (-a) != 0) b--;
        smaller_or_same += min(n - (i + 1), static_cast<int>(distance(m_arr.begin(), upper_bound(m_arr.begin(), m_arr.end(), b))));
        if (mid % (-a) != 0) b++;
        smaller += min(n - (i + 1), static_cast<int>(distance(m_arr.begin(), lower_bound(m_arr.begin(), m_arr.end(), b))));
      }
      if (a == 0) {
        if (mid >= 0) smaller_or_same += n - (i + 1);
        if (mid > 0) smaller += n - (i + 1);
      }
    }
    if (smaller < k && k <= smaller_or_same) {
      cout << mid << endl;
      return 0;
    } else if (smaller_or_same < k) {
      ok = mid + 1;
    } else {
      ng = mid;
    }
  }
  cout << ok << endl;
}

Measured memory_bytes: 3328
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<iomanip>
using namespace std;
long long a[201111]={0},b[200001]={0},ans,n,m,c[200001]={0},d[200001]={0};
int main(){
//char b[100001];
cin>>n>>m;
for(int i=1;i<=m;i++){
	cin>>a[i]>>b[i];
	if(a[i]==1)c[b[i]]=1;
	if(b[i]==n)d[a[i]]=1;
}
for(int i=1;i<=n;i++){
	if(c[i]==1&&d[i]==1){
		cout<<"POSSIBLE";
		return 0;
	}
}
cout<<"IMPOSSIBLE";
return 0;
}

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

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


Measured memory_bytes: 256
#include<iostream>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef pair<int,int> P;
map<string,int> mp;
int N,M;
vector<P> t,A,B;

int solve(int start){
  int ai=0,bi=0,now=start,res=0;
  int as=A.size(),bs=B.size(),cnt=0;
  while(1){
    int ag=(ai<as?A[ai].first:1e8);
    int bg=(bi<bs?B[bi].first:1e8);
    if(7*60*24+start-30<ag)ag=1e8;
    if(7*60*24+start-30<bg)bg=1e8;
    if(ag==1e8&&bg==1e8)break;

    if(ag<now){ai++;continue;}
    if(bg<now){bi++;continue;}
    if(ag+30<=bg){
      res++;
      now=ag+30;
      ai++;
    }else{
      res++;
      cnt++;
      now=bg+30;
      bi++;
    }
  }
  if(cnt<M)return -1;
  else return res;
}

void init(){
  t.clear();
  A.clear();
  B.clear();
  mp.clear();
}

int main(){
  while(1){
    cin>>N;
    if(N==0)break;
    init();
    for(int i=0;i<N;i++){
      string a;
      int b,c;
      cin>>a>>b>>c;
      b=(c/100*60+c%100)+(b*60*24);
      mp[a]=i;
      t.push_back(P(b%(7*60*24),i));
    }
    cin>>M;
    for(int i=0;i<M;i++){
      string a;
      cin>>a;
      B.push_back(t[mp[a]]);
      t[mp[a]]=P(-1,-1);
    }
    for(int i=0;i<(int)t.size();i++)
      if(t[i].first!=-1)
	A.push_back(t[i]);

    sort(A.begin(),A.end());
    sort(B.begin(),B.end());
    int ans=-1;
    for(int i=0;i<=30;i++)ans=max(ans,solve(i));
    cout<<ans<<endl;
  }
  return 0;
}

Measured memory_bytes: 1296
#include<bits/stdc++.h>
using namespace std;
int main()
{

    long long int a,b,c,d,e,f,g,flag,r[20000],cnt;
    while(cin>>a>>b)
    {
        cnt=0;
        for(c=a;c<=b;c++)
        {

            d=c;
            e=0;
            while(d!=0)
            {
               r[++e]=d%10;
               d=d/10;


            }
            flag=1;
            for(f=1,g=e;f<=e;f++,g--)
            {

                if(r[f]!=r[g])
                {
                    flag=0;
                }

            }
            if(flag==1)
            {
                cnt++;
            }


        }
        cout<<cnt<<endl;


    }
    return 0;
}


Measured memory_bytes: 256
#include<iostream>
#include<string>
#include<cmath>
#include<algorithm>/*toupperとかが入っている*/
#include<vector>/*可変長配列vectorのインクルード*/
using namespace std;/*標準名前空間を利用する。cinやcoutはこれによって利用可能になる*/

int N;
int K;
string S;

int main(void) {
  cin >> N >> K;
  cin >> S;
  
  S[K-1]=S[K-1]+32; 

  cout << S << endl;
  return 0;
}


Measured memory_bytes: 256
////////////////////////////////////////////
///                                      ///
///         Template ver. 1 rapel        ///
/// Fear is Temporary, Regret is Forever ///
///          Must Try and Get AC         ///
///                                      ///
////////////////////////////////////////////
#include <stdio.h>
#include <iostream>
#include <sstream>
#include <iomanip>

#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>

#include <math.h>
#include <complex>

#include <assert.h>
#include <time.h>
//#include <chrono>
//#include <random>

#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <bitset>

#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define endl '\n'
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;

void desperate_optimization(int precision){
  	ios_base::sync_with_stdio(false);
  	cin.tie(0);
  	cout.tie(0);
  	cout.setf(ios::fixed);
  	cout.setf(ios::showpoint);
  	cout.precision(precision);
}

vector<pair<int,int> > vec;

const int N = 5000;
LL dp[N + 5];

bool cmp(pair<int,int> A,pair<int,int> B){
	return A.FI + A.SE < B.FI + B.SE;
}

void hora(int tc) {
	int n;
	cin>>n;
	for(int i = 0;i < n;i++) {
		pair<int,int> tmp;
		cin>>tmp.FI>>tmp.SE;
		vec.PB(tmp);
	}
	sort(vec.begin(),vec.end(), cmp);
	for(int i = 1;i <= n;i++) dp[i] = 1e18;
	dp[0] = 0;
	for(int i = 0;i < n;i++) {
//		cout<<"ITER "<<i<<" "<<vec[i].FI<<" "<<vec[i].SE<<endl;
		for(int j = n;j >= 1;j--) {
			if(dp[j - 1] <= vec[i].FI) {
				dp[j] = min(dp[j], dp[j - 1] + vec[i].SE);
			}
		}
	}
	int total = 0;
	for(int i = 0;i <= n;i++) {
//		cout<<i<<" "<<dp[i]<<endl;
		if(dp[i] != 1e18) total = i;
	}
	cout<<total<<endl;
}

int main(){
	desperate_optimization(10);
	int ntc = 1;
	//cin>>ntc;
	for(int tc = 1;tc <= ntc;tc++) hora(tc);
	return 0;
}



Measured memory_bytes: 512
#include <iostream>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <queue>
#include <cstdio>
#include <cmath>
#include <stack>
typedef long long ll;
#define INF 0x3f3f3f3f

using namespace std;
void clock(int& x1, int& y1, int& x2, int& y2)
{
	int dx = y1 - y2;
	int dy = x2 - x1;
	
	x1 = x2;
	y1 = y2;
	x2 = x2 + dx;
	y2 = y2 + dy;
}
int main(int argc, char *argv[]) {
	int x1, x2, y1, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	
	clock(x1, y1, x2, y2);
	cout << x2 << " " << y2 << " ";
	clock(x1, y1, x2, y2);
	cout << x2 << " " << y2 << endl;
}

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

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    vector<int> b = {0,2,5,5,4,5,6,3,7,6};
    int n,m; cin>>n>>m;
    vector<int> a(m);rep(i,m)cin>>a[i];
    sort(a.rbegin(),a.rend());
    vector<ll> dp(n+1,-INF);
    dp[0]=0;
    for(int i=1; i<=n; i++){
        ll M = -INF;
        for(int j:a){
            if(b[j]<=i)M=max(M,dp[i-b[j]]+1);
        }
        dp[i]=M;
    }
    

    for(int j:a){
        while(n>=b[j]&&dp[n]==dp[n-b[j]]+1){cout<<j;n-=b[j];}
    }

    return 0;
}

Measured memory_bytes: 892
// inputに入力データ全体が入る
function Main(input) {
  // まずメインの入力の値をとる
var a = input.split(" ");
  console.log(a[0] - a[1] + 1);  
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

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

int main(){
    ll a,b,x;
    std::cin >> a >> b >> x;
    ll first,last;
    if(a%x == 0)
    {
        first = a/x;
    }else
    {
        first = a/x +1;
    }
    
    last = b/x;

    std::cout << last -first +1;
    

    return 0;
}




Measured memory_bytes: 256
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;typedef double db;
typedef pair<int, int> pii;typedef pair<ll, ll> pll;
typedef pair<int,ll> pil;typedef pair<ll,int> pli;
#define Fi first
#define Se second
#define _Out(a)	cerr<<#a<<" = "<<(a)<<endl
const int INF = 0x3f3f3f3f, MAXN = 1e3 + 7;
const ll LINF = 0x3f3f3f3f3f3f3f3f, MOD = 1e9+7;
const db Pi = acos(-1), EPS = 1e-6;
void test(){cerr << "\n";}template<typename T,typename...Args>void test(T x,Args...args){cerr<<x<<" ";test(args...);}
inline ll qpow(ll a, ll b){return b?((b&1)?a*qpow(a*a%MOD,b>>1)%MOD:qpow(a*a%MOD,b>>1))%MOD:1;}
inline ll qpow(ll a, ll b,ll c){return b?((b&1)?a*qpow(a*a%c,b>>1,c)%c:qpow(a*a%c,b>>1,c)) %c:1;}
inline ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
inline ll cede(ll a,ll b){if(b<0)return cede(-a,-b);if(a<0)return a/b;return (a+b-1)/b;}
inline ll flde(ll a,ll b){if(b<0)return flde(-a,-b);if(a<0)return (a-b+1)/b;return a/b;}
inline int sign(db x){return x<-EPS ? -1:x>EPS;}
inline int dbcmp(db l,db r){return sign(l - r);}
namespace Fast_IO{ //orz laofu
    const int MAXL((1 << 18) + 1);int iof, iotp;
    char ioif[MAXL], *ioiS, *ioiT, ioof[MAXL],*iooS=ioof,*iooT=ioof+MAXL-1,ioc,iost[55];
    char Getchar(){
        if (ioiS == ioiT){
            ioiS=ioif;ioiT=ioiS+fread(ioif,1,MAXL,stdin);return (ioiS == ioiT ? EOF : *ioiS++);
        }else return (*ioiS++);
    }
    void Write(){fwrite(ioof,1,iooS-ioof,stdout);iooS=ioof;}
    void Putchar(char x){*iooS++ = x;if (iooS == iooT)Write();}
    inline int read(){
        int x=0;for(iof=1,ioc=Getchar();ioc<'0'||ioc>'9';)iof=ioc=='-'?-1:1,ioc=Getchar();
        for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
    }
    inline long long read_ll(){
        long long x=0;for(iof=1,ioc=Getchar();ioc<'0'||ioc>'9';)iof=ioc=='-'?-1:1,ioc=Getchar();
        for(x=0;ioc<='9'&&ioc>='0';ioc=Getchar())x=(x<<3)+(x<<1)+(ioc^48);return x*iof;
    }
    template <class Int>void Print(Int x, char ch = '\0'){
        if(!x)Putchar('0');if(x<0)Putchar('-'),x=-x;while(x)iost[++iotp]=x%10+'0',x/=10;
        while(iotp)Putchar(iost[iotp--]);if (ch)Putchar(ch);
    }
    void Getstr(char *s, int &l){
        for(ioc=Getchar();ioc <'a'||ioc>'z';)ioc=Getchar();
        for(l=0;ioc<='z'&&ioc>='a';ioc=Getchar())s[l++]=ioc;s[l] = 0;
    }
    void Putstr(const char *s){for(int i=0,n=strlen(s);i<n;++i)Putchar(s[i]);}
} // namespace Fast_IO
using namespace Fast_IO;




void work()
{
    int D=read(),T=read(),S=read();
    printf("%s",S*T<D?"No":"Yes");
    
}

int main()
{
    //std::ios::sync_with_stdio(false);
   // int T=read();for(int cas=1;cas<=T;cas++)
    //int T;scanf("%d",&T);for(int i=1;i<=T;i++)
    work();
    // Write();
}
/*
3
6 9 2 1 1 1 4 1 3 3
6 9 2 1 1 1 5 1 4 3
6 9 2 1 1 1 5 1 5 3
6 9 2 1 1 1 8 1 6 3
6 9 2 1 1 1 8 1 7 4

5 6 4 1 1 4 3 999 1 10
10 10 4 1 1 3 7 999 1 100
10 10 4 1 1 8 9 999 1 100
*/

Measured memory_bytes: 3660
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define fr(i,n) for(long long i=0;i<(n);++i)
#define Fr(i,n) for(long long i=1;i<=(n);++i)
#define ifr(i,n) for(long long i=(n)-1;i>=0;--i)
#define iFr(i,n) for(long long i=(n);i>0;--i)

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  int x,y;
  cin>>x>>y;
  cout<<max(x+y,max(x-y,x*y));
}

Measured memory_bytes: 256
#include "bits/stdc++.h"
#define _overload3(_1,_2,_3,name,...)name
#define _rep(i,n)repi(i,0,n)
#define repi(i,a,b)for(int i=int(a),i##_len=(b);i<i##_len;++i)
#define MSVC_UNKO(x)x
#define rep(...)MSVC_UNKO(_overload3(__VA_ARGS__,repi,_rep,_rep)(__VA_ARGS__))
#define all(c)c.begin(),c.end()
#define write(x)cout<<(x)<<'\n'
using namespace std; typedef long long ll; template<class T>using vv = vector<vector<T>>;
template<class T>auto vvec(int n, int m, T v) { return vv<T>(n, vector<T>(m, v)); }
template<class T, class U>bool chmax(T& a, U&& b) { return a < b ? a = b, 1 : 0; }
template<class T, class U>bool chmin(T& a, U&& b) { return b < a ? a = b, 1 : 0; }
constexpr int INF = 1 << 29, MOD = int(1e9) + 7; constexpr ll LINF = 1LL << 60;
struct aaa { aaa() { cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10); }; }aaaa;

int main() {
    int N;
    cin >> N;
    vector<int> A(N);
    rep(i, N) cin >> A[i];
    sort(all(A));

    bool ans = true;
    if (N > 2 && A[N - 1] == 1) ans = false;
    if (A[N - 1] % 2) {
        if (A[0] != (A[N - 1] + 1) / 2) ans = false;
    }
    else {
        if (A[0] != A[N - 1] / 2) ans = false;
    }
    if (A[N - 2] != A[N - 1]) ans = false;
    for (int i = 0, j; i < N; i = j) {
        for (j = i + 1; j < N; ++j) if (A[j] != A[i]) break;
        if (i == 0 && j - i != 1 + A[N - 1] % 2) ans = false;
        else if (i > 0 && A[i] - A[i - 1] != 1) ans = false;
        else if (i > 0 && j - i < 2) ans = false;
    }

    write(ans ? "Possible" : "Impossible");
}

Measured memory_bytes: 256
//  Created by conan1024hao in 2019.
//  Copyright © 2019 conan1024hao. All rights reserved.
//  専用ライブラリです、自由にコピーして構いません。
//  感谢看我的代码！Wechat:conan1024hao QQ:810396815
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#define INF 10e16
#define MOD 1000000007
#define  mod 998244353
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
using namespace std;
//using Int=int_fast64_t;
typedef long long int ll;
typedef pair<ll,ll>Pll;
typedef pair<int,int>Pin;
long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }
long long LCM(long long a, long long b)  {return a/GCD(a,b)*b;}
int dx[8]={-1,0,1,0};
int dy[8]={0,-1,0,1};
char dir[4]={'u','l','d','r'};
ll cmp1(pair<ll,string>a,pair<ll,string> b){
        if(a.fi!=b.fi)
        return a.fi<b.fi;
        else
        return a.se<b.se;
}
//--------------------------------------------------------------------------

//---------------------------------------------------------------------------
int main(){//問題をちゃんと見ろ!!!!!!!!!!!!!!!!!      llか??????????        memset()!!!!!!!!!!!!       ペナを減らせ!!!!!!!!!!!!!
    cin.tie(0);
    ios::sync_with_stdio(false);
    //-------------------------------
    string s;cin>>s;
    sort(all(s));
    if(s=="abc")
        cout<<"Yes"<<endl;
    else
        cout<<"No"<<endl;
    //-------------------------------
    return 0;
}
//---------------------------------------------------------------------------






Measured memory_bytes: 256