akhauriyash/Code-Regression huggingface dataset:
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn solve(level: usize, x: usize, layers: &Vec<usize>, ps: &Vec<usize>) -> usize {
    if x == 0 {
        return 0;
    }
    if x >= layers[level] {
        return ps[level];
    }
    if level == 0 {
        return 1;
    }
    let mut s = 0;
    s += solve(level - 1, x - 1, layers, ps);
    if x >= layers[level] / 2 + 1 {
        s += 1;
        s += solve(level - 1, x - layers[level] / 2 - 1, layers, ps);
    }
    s
}

fn main() {
    input! {
        n: usize,
        x: usize,
    }
    let mut layers = vec![0; n + 1];
    layers[0] = 1;
    for i in 1..n + 1 {
        layers[i] = 2 * layers[i - 1] + 3;
    }
    let mut ps = vec![0; n + 1];
    ps[0] = 1;
    for i in 1..n + 1 {
        ps[i] = 2 * ps[i - 1] + 1;
    }
    println!("{}", solve(n, x, &layers, &ps));
}


Measured memory_bytes: 4352
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define Sort(a) sort(a.begin(), a.end())
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
template <class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;} return false;}
template <class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;} return false;}

int main(){
    int n;
    cin >> n;
    vll a(n);
    ll ans = 1, tmp;
    bool flag = true;
    rep(i, n) {
        cin >> a[i];
        tmp = ans;
        ans *= a[i];    
        if(ans > 1000000000000000000) {
        flag = false;
        }
        if(tmp > ans) flag = false;
        if(a[i] == 0) {
            flag = true;
            break;
        }
    }
    if(flag){
        cout << ans << endl;
    }
    else {
        cout << -1 << endl;
    }
    return 0;
}

Measured memory_bytes: 4052
import java.util.Scanner;

class Main {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        double c;
        
        c = a * b / 3.305785;
        
            System.out.printf("%.6f\n",c);
            
        }

        
    }




Measured memory_bytes: 26392
/*input
1
1

*/
 
/*
                                                    ______________
                                                          |       )
                                                          |   )   /
                                                          |______/
                                                    |     |      \
                                                    |     |   )   \
                                                    |_____|_______)
 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <iomanip>
#include <fstream>
#include <stack>

using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll , ll> PLL;
typedef long double ld;
 
#define pb push_back
#define all(c) c.begin(),c.end()
#define allr(c) c.rbegin(),c.rend()
int mod = 1000000007;
const int inf = 1034567891;
const ll LL_INF = 1234567890123456789ll;
#define PI 3.14159265
#define endl '\n'
#define F first
#define S second
#define debug(x) cout << #x << " = " << x << endl;
#define TRACE
 
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
 
#define out(container) for (auto it : container) cout << it << " "; cout << endl;
 
 
template < typename T > T GCD(T a, T b)            { ll t; while(a) { t = a; a = b % a; b = t; } return b; }
template < typename T > string toString(T a)       { return to_string(a); }
template < typename T > void toInt(string s, T &x) { stringstream str(s); str >> x;}
inline int add(int x, int y){ x += y; if(x >= mod) x -= mod; return x;}
inline int sub(int x, int y){ x -= y; if(x < 0) x += mod; return x;}
inline int mul(int x, int y){ return (x * 1ll * y) % mod;}
inline int powr(int a, ll b){
  int x = 1 % mod;
  while(b){
    if(b & 1) x = mul(x, a);
    a = mul(a, a);
    b >>= 1;
  }
  return x;
}
inline int inv(int a){ return powr(a, mod - 2);}

int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  
  string str1, str2;
  cin >> str1 >> str2;
  int n = str1.size();
  for (int i = 0; i < n; i++) {
    if (str1[i] != str2[i]) {
      cout << "No" << endl;
      return 0;
    }
  }  
  cout << "Yes" << endl;

  return 0;
}

Measured memory_bytes: 3648
import numpy as np
n, k=map(int, input().split())
a=list(map(int, input().split()))

npr=np.zeros(max(a)+1)
for i in a:
    npr[i:] += 1

ruiseki=list(npr)
sm1=0
for i in a:
    sm1 += ruiseki[i-1]

ans1=(((k*(k-1))//2)%(10**9+7))*sm1

sm2=0
for i in a:
    sm2 += npr[i-1]
    npr[i:] -= 1

ans2=(sm2*k)%(10**9+7)

ans=(ans1+ans2)%(10**9+7)
print(int(ans))

Measured memory_bytes: 27224
import java.util.*;

import static java.lang.System.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int K = sc.nextInt();

        // a % K = b % K = c % K == 0 or A % K = b % K = c % K = (K / 2) のみ
        long cand1 = N / K;
        long cand2 = 0;
        if (K % 2 == 0) {
            cand2 = N / (K / 2) - cand1;    //cond1と数字がかぶる
        }

        out.println(cand1 * cand1 * cand1 + cand2 * cand2 * cand2);
    }
}



Measured memory_bytes: 21844
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair < ll, ll > Pi;
const ll LLINF = 1LL << 60;
struct Edge {
    ll to, cost;
    Edge () {}
    Edge (ll to, ll cost) : to(to), cost(cost) {}
};
vector < Edge > G[100005];
ll min_cost[100005];
ll cost[100005] = {};
ll N, M, C;
int main()
{
    ll sum = 0, minv = LLINF;
    priority_queue < Pi , vector < Pi > , greater < Pi >  > pq;
    cin >> N >> M >> C;
    for(int i = 0; i < M; i++) {
        int a, b, c;
        cin >> a >> b >> c; --a, --b; sum += c;
        G[a].push_back(Edge(b, c));
        G[b].push_back(Edge(a, c));
    }
    fill_n(min_cost, 100005, LLINF);
    min_cost[0] = 0; pq.push(Pi(0, 0));
    while(!pq.empty()) {
        Pi d = pq.top(); pq.pop();
        if(d.first > min_cost[d.second]) continue;
        sum -= cost[d.second];
        minv = min(minv, sum + C * d.first);
        for(int i = 0; i < G[d.second].size(); i++) {
            ll u = G[d.second][i].to, w = G[d.second][i].cost + d.first;
            cost[u] += G[d.second][i].cost;
            if(min_cost[u] > w) {
                min_cost[u] = w;
                pq.push(Pi(w, u));
            }
        }
    }
    cout << minv << endl;
    return (0);
}



Measured memory_bytes: 18036
#include <bits/stdc++.h>
#define int int64_t
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++ (i))
#define REP_R(i, n) for (int i = (int)(n) - 1; (i) >= 0; -- (i))
#define REP3R(i, m, n) for (int i = (int)(n) - 1; (i) >= (int)(m); -- (i))
#define REPP(i, n) for (int i = 1; (i) < (int)(n+1); ++ (i))
#define REPR(i, n) for (int i = (int)(n) - 1; (i) >= 0; -- (i))
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define FORR(i, m, n) for(int i=(m)-1; i>=(n); i--)
#define ALL(v) v.begin(), v.end()
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(),(c).end())
#define SORTR(c) sort((c).begin(),(c).end(),greater<int>());
#define BIT(n) (1LL<<(n))
#define PCNT(x) __builtin_popcountll(x)
#define GCD(x,y) __gcd(x,y)
#define LCM(x,y) x/__gcd(x,y)*y
#define PB push_back
#define MP make_pair
#define endl "\n"
#define pa cout << ans << endl
#define p(x) cout << x << endl
#define pall(x) for(auto iter : x) p(iter)
#define yes cout << "Yes" << endl
#define no cout << "No" << endl
#define yn(x) cout << (x ? "Yes" : "No") << endl
using namespace std;
using Graph = vector<vector<int> >;
using WeightedGraph = vector<vector<pair<int, int> > >;
typedef long double LD;
typedef vector<int> VI;
typedef vector<vector<int> > VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
const int INF = 2000000000;
const long double PI = acosl(-1);
const int MOD = 1000000007;
void print() {cout << endl;}
template <class Head, class... Tail> void print(Head&& head, Tail&&... tail) {cout << head; if (sizeof...(tail) != 0) cout << " ";print(forward<Tail>(tail)...);}
template <class T> void print(vector<T> &vec) {for (auto& a : vec) {cout << a; if (&a != &vec.back()) cout << " ";} cout << endl;}
template <class T> void print(vector<vector<T>> &df) { for (auto& vec : df) { print(vec);}}


signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    cout << fixed << setprecision(10);
    int ans = 0;
    
    int L, R, d;
    cin >> L >> R >> d;

    FOR(i,L,R+1) {
        if (i % d == 0) ans++;
    }

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

/*
cd ~/Desktop/Programming/AtCoder/contest/aising2020/aising2020_a && sh shellscripts/test_cpp.sh
cd ~/Desktop/Programming/AtCoder/contest/aising2020/aising2020_a && sh shellscripts/etest_cpp.sh
cd ~/Desktop/Programming/AtCoder/contest/aising2020/aising2020_a && sh shellscripts/submit_cpp.sh
*/


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

using lli = long long int;

template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}

template <class T>ostream &operator<<(ostream &o,const pair<T, T>&p)
{o<<"("<<p.first<<", "<<p.second<<")";return o;}

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

const lli MOD = 1000000007LL;

lli modpow(lli a, lli n){
    lli res = 1;

    for(lli ai = a; n; n>>=1){
        if(1&n) res = (res*ai)%MOD;
        ai=(ai*ai)%MOD;
    }
    return res;
}

lli inv(lli n){
    return modpow(n, MOD-2);
}

lli modperm(lli n, lli k){
    lli res = 1;
    rep(i, k){
        res = (res*(n-i))%MOD;
    }
    return res;
}

lli modcomb(lli n, lli k){
    return (modperm(n, k)*inv(modperm(k, k)))%MOD;
}

lli posmod(lli n){
    lli res = n;
    res %= MOD;
    if(res < 0) res += MOD;
    return res;
}
lli n, m;
vector<lli> A, D;
vector<pair<lli, lli>> cb;
lli res = 0;

int main(void){
    cin >> n >> m;
    rep(i, n){
        lli a;
        cin >> a;
        A.push_back(a);
    }
    rep(j, m){
        lli b, c;
        cin >> b >> c;
        cb.push_back(make_pair(c, b));
    }
    sort(cb.begin(), cb.end(), greater<pair<lli, lli>>());
    for(auto i : cb){
        while(i.second-- && D.size() < n){
            D.push_back(i.first);
        }
    }
    while(D.size()!=n) D.push_back(-LLONG_MAX);
    rep(i, n){
        A.push_back(D[i]);
    }
    sort(A.begin(), A.end(), greater<lli>());
    rep(i, n){
        res += A[i];
    }
    cout << res << endl;
    return 0;
}


Measured memory_bytes: 5616
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))

m = 0

for i in range(n):
  num = int(a[i])
  m += b[num - 1]
#  print(i, m)  #erase later
  if num != n and i != n - 1:
    if num + 1 == int(a[i + 1]):
      m += c[num - 1]
#      print('C point', m)  #erase later
print(m)


Measured memory_bytes: 3064
import math

T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())

if (A1 - B1) * T1 + (A2 - B2) * T2 == 0:
    print("infinity")
else:
    D, D1 = (A1 - B1) * T1 + (A2 - B2) * T2, (A1 - B1) * T1
    if (D1 > 0) == (D > 0):
        print(0)
    else:
        if D1 % D == 0:
            print(2 * math.floor(-D1 / D))
        else:
            print(2 * math.floor(-D1 / D) + 1)


Measured memory_bytes: 3060
z='abcdefghijklmnopqrstuvwxyz'
for _ in[0]*int(input()):
 e=input()
 for i in range(1,26,2):
  for j in range(26):
   a=''
   for c in e:
    if c in z:a+=z[(z.index(c)*i+j)%26]
    else:a+=c
   if'that'in a or'this'in a:print(a);break


Measured memory_bytes: 5596
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N = int(readline())
    A = list(map(int, readline().split()))
    ans = [0] * N
    for i in A:
        ans[i-1] += 1
    for i in ans:
        print(i)



if __name__ == '__main__':
    main()

Measured memory_bytes: 27968
//10.0.3.47 perfec
#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<climits>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define LL long long
#define ULL unsigned long long
using namespace std;
int read(){
	int f=0,x=0;char c=getchar();
	while(c<'0'||'9'<c){if(c=='-')f=1;c=getchar();}
	while('0'<=c&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return f?-x:x;
}
#define MAXN 100000
#define INF 0x3f3f3f3f
int a[MAXN+5];
int main(){
	int n=read();
	for(int i=1;i<=n;i++)
		a[i]=read();
	for(int i=2;i<=n;i++){
		if(a[i]<a[i-1])
			a[i]++;
		if(a[i]<a[i-1]){
			puts("No");
			return 0;
		}
	}
	puts("Yes");
	return 0;
}


Measured memory_bytes: 640
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define TOUPPER(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define TOLOWER(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
#define FILLZERO(s, n)                      \
    do {                                    \
        ostringstream os;                   \
        os << setw(n) << setfill('0') << s; \
        s = os.str();                       \
    } while (0);
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end()) //sortしてからつかうこと
#define INIT                               \
    std::cin.tie(nullptr);                 \
    std::ios_base::sync_with_stdio(false); \
    cout << std::fixed << std::setprecision(10);

constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;

template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
    for (T &x : vec)
        is >> x;
    return is;
}
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() {
    INIT;
    cin >> N >> M;
    M /= 2;
    if (N > (N + M) / 2LL)
        cout << M << endl;
    else
        cout << (N + M) / 2LL << endl;
}

Measured memory_bytes: 3592
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()
A = LIST()

# bをmとした時の悲しさ値
def check(m):
    sm = 0
    for i, a in enumerate(A):
        sm += abs(a - (m+i+1))
    return sm

# 三分探索
low = -10**9
hi = 10**9
while low+2 < hi:
    m1 = (low*2+hi) // 3
    m2 = (low+hi*2) // 3
    res1 = check(m1)
    res2 = check(m2)
    # 今回は下に凸な関数なので値の小さい方に向かって狭めていく
    if res1 <= res2:
        hi = m2
    else:
        low = m1

print(min(check(m1), check(m2)))


Measured memory_bytes: 81648
inf = 10**100
def cal(x, y):
    if x <= y:
        return y - x
    else:
        return inf
x, y = map(int, input().split())
ans = 0
x_1 = x
x_2 = -x
y_1 = y
y_2 = -y
print(min(cal(x_1, y_1), cal(x_1, y_2) + 1, cal(x_2, y_1) + 1, cal(x_2, y_2) + 2))

Measured memory_bytes: 3064
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef unsigned long ul;
typedef unsigned int ui;
typedef pair<int,int> P;
typedef pair<ll,ll> LP;
#define All(v) (v).begin(),(v).end()
#define Rep(i,n) for(int i = 0; i < (int)n; i++)
#define Reps(i,n) for(int i = 1; i <= (int)n; i++)
#define For(i,m,n) for(int i = m; i < n; i++)
#define Fors(i,m,n) for(int i = m; i <= n; i++)
#define Inf 2e9
#define F first
#define S second
#define pb push_back
#define mp make_pair
struct speed{speed(){cin.tie(); ios::sync_with_stdio(false); cout << fixed << setprecision(18);}}speed;

int dy[] = {0,0,1,-1};
int dx[] = {1,-1,0,0};

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

ll lcm(ll a, ll b){
    return a*b/gcd(a,b);
}


int main (){
    int x,a;
    cin >> x >> a;
    if(x < a) cout << 0 << "\n";
    else cout << 10 << "\n";
}

Measured memory_bytes: 256
package main

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

const (
	initialBufSize = 100000
	maxBufSize     = 10000000
)

var (
	sc = bufio.NewScanner(os.Stdin)
	wt = bufio.NewWriter(os.Stdout)
)

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

func nextInt() int {
	i, _ := strconv.Atoi(next())
	return i
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextFloat64s(n int) []float64 {
	slice := make([]float64, n)
	for i := 0; i < n; i++ {
		slice[i] = nextFloat64()
	}
	return slice
}

func putf(format string, a ...interface{}) {
	fmt.Fprintf(wt, format, a...)
}

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}

func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, initialBufSize), maxBufSize)
	defer wt.Flush()

	x := nextInt()

	ans := 0
	for i := 100; i < x; i += int(float64(i) * 0.01) {
		ans++
	}

	puts(ans)
}


Measured memory_bytes: 1764
#include<bits/stdc++.h>
using namespace std;
int main()
{
    std::ios::sync_with_stdio(false);
    int A,B,C,X,Y,n,k=0x7fffffff;
    cin>>A>>B>>C>>X>>Y;
    n=min(min(A,B),C);
    int t=max(max(A,B),C);
    for(int i=0; i<=100000;i++)
    {
       k=min(k,(i*2*C + max(0,X- i) *A + max(0, Y- i)*B));
    }
    cout<<k<<endl;
    return 0;
}



Measured memory_bytes: 256
#include<bits/stdc++.h>
using namespace std;
void print_err() {
	cerr << "\n";
}
template <class T, class... Arg>
void print_err(T x, Arg&&... args) {
	cerr << x << " ";
	print_err(args...);
}
#ifdef local
#define debug(...) print_err(__VA_ARGS__)
#else
#define debug(...)
#endif
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define mod 1000000007
#define ll long long int
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pll pair<ll,ll>
#define vl vector<ll>
#define vpll vector<pair<ll,ll>>
#define mll map<ll,ll>
#define mllrev map<ll,ll,greater<int>>
#define ps(x,y) fixed<<setprecision(y)<<x
#define w(t) ll t;cin>>t;while(t--)
#define fo(i,n) for(ll i=0;i<n;++i)
#define foab(i,a,b) for(ll i=a;i<b;++i)
#define inp cin>>
#define pr cout<<
#define fastio ios_base::sync_with_stdio(NULL);cin.tie(NULL);cout.tie(NULL);
class Graph {
public:
	list<ll> *adj_list;
	ll v;
	Graph(ll v) {
		this->v = v;
		adj_list = new list<ll>[v];
	}
	void add_edge(ll u, ll v, bool bidirectional = true) {
		adj_list[u].push_back(v);
		if (bidirectional) {
			adj_list[v].push_back(u);
		}
	}
	void print();
	void connected_compo();
	void dfs(ll v, bool visited[]);
	void bfs(ll v, bool visited[]);
};
void solve() {
	// // http://codeforces.com/problemset/problem/445/A
	// inp n >> m;
	// fo(i, n) {
	// 	fo(j, m) {
	// 		inp ch[i][j];
	// 	}
	// }
	ll n, temp;
	inp n;
	ll dp[n][3], arr[n][3];
	fo(i, n) {
		fo(j, 3) {
			cin >> arr[i][j];
			dp[i][j] = 0;
		}
	}
	dp[0][0] = arr[0][0]; dp[0][1] = arr[0][1]; dp[0][2] = arr[0][2];
	foab(i, 1, n) {
		temp = 0;
		temp = max(arr[i][0] + dp[i - 1][1], arr[i][0] + dp[i - 1][2]);
		dp[i][0] = temp;
		temp = 0;
		temp = max(arr[i][1] + dp[i - 1][0], arr[i][1] + dp[i - 1][2]);
		dp[i][1] = temp;
		temp = 0;
		temp = max(arr[i][2] + dp[i - 1][1], arr[i][2] + dp[i - 1][0]);
		dp[i][2] = temp;
	}
	temp = 0;
	temp = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
	cout << temp << endl;
	return ;
}
int main() {
	fastio
#ifdef local
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	freopen("error.txt", "w", stderr);
#endif
	solve();
	return 0;
}
// ll n, m;
// char ch[100][100];
// bool istrue = false;
// ll dx[] = { -1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
// void dfs(ll row, ll col, char ch) {
// 	if (ch[row][col] == 'B' or ch[row][col] == 'W' or ch[row][col] == '-' or istrue) {
// 		return;
// 	}
// 	fo(i, 4) {
// 		if (isvalid(ch, row + dx[i], col + dy[i])) {
// 			if (ch == 'B') {
// 				dfs(row + dx[i], col + dy[i], 'W');
// 			} else if (ch == 'W') {
// 				dfs(row + dx[i], col + dy[i], 'B');
// 			}
// 		}
// 	}
// }

Measured memory_bytes: 8304
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True # and False
def ddprint(x):
  if DBG:
    print(x)

a,p = inm()
print((3*a+p)//2)


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

typedef long long ll;

const long long MOD = 1000000007;

void solve(long long S){
  // num seq len j whose sum <= i
  vector<ll> dp((S+1) * S,0);
  const auto ix = [S](ll i, ll j){
    return i * S + j;
  };
  if (S < 3) {
    cout << 0 << endl;
    return;
  }
  dp[ix(0,0)] = 1;
  dp[ix(1,0)] = 1;
  dp[ix(2,0)] = 1;
  for (ll i = 3; i <= S; ++i) {
    dp[ix(i,0)] = 1;
    for (ll j = 1; j < S; ++j) {
      dp[ix(i,j)] = dp[ix(i-3, j-1)];
      dp[ix(i,j)] = (dp[ix(i,j)] + dp[ix(i-1,j)]) % MOD;
    }
  }
  ll rv = 0;
  for (ll j = 0; j < S; ++j) {
    rv = (rv + dp[ix(S,j)]) % MOD;
    rv = (rv - dp[ix(S-1, j)] + MOD) % MOD;
  }
  cout << rv << endl;
}

int main() {
  long long S;
  scanf("%lld",&S);
  solve(S);
  return 0;
}


Measured memory_bytes: 34176
#include<bits/stdc++.h>
using namespace std;
const int maxn=2003;
const int mod=1e9+7;
int n,K;
int f[maxn][maxn];
int Fac[maxn*maxn],Inv[maxn*maxn];
inline int Pow(int a,int n){
	int ans=1;
	for(;n;n>>=1,a=a*1ll*a%mod)if(n&1)ans=ans*1ll*a%mod;
	return ans;
}
inline int C(int n,int m){
	if(n<m||m<0)return 0;
	return Fac[n]*1ll*Inv[m]%mod*Inv[n-m]%mod;
}
int main(){
	scanf("%d%d",&n,&K);
	if(K==1)return puts("1"),0;
	Fac[0]=1;
	for(int i=1;i<=n*K;i++)Fac[i]=Fac[i-1]*1ll*i%mod;
	Inv[n*K]=Pow(Fac[n*K],mod-2);
	for(int i=n*K-1;i>=0;i--)Inv[i]=Inv[i+1]*(i+1ll)%mod;
	f[0][0]=1;
	for(int i=0;i<=n;i++){
		for(int j=0;j<=i;j++){
			(f[i+1][j]+=f[i][j])%=mod;
			f[i][j+1]=(f[i][j+1]+f[i][j]*1ll*C(n*K-(i+j*(K-1))-1,K-2))%mod;
		}
	}
	printf("%lld\n",f[n][n]*1ll*Fac[n]%mod);
	return 0;
}


Measured memory_bytes: 47232
def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

def main():
    s = input()
    i = 0
    cc = output = 0
    while i < len(s)-1:
        if s[i] == 'A':
            cc += 1
            i += 1
        elif s[i] == 'B' and s[i+1] == 'C':
            output += cc
            i += 2
        else:
            cc = 0
            i += 1
    print(output)

    return

if __name__ == '__main__':
    main()


Measured memory_bytes: 3500
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
string w[105];
int main(void){
    int n,c=0;cin>>n>>w[0];
    for(int i=1;i<n;i++){
        cin>>w[i];
        if(w[i-1][w[i-1].size()-1]!=w[i][0])c--;
        for(int j=0;j<i;j++){
            if(w[j]==w[i]){
                c--;
                break;
            }
        }
    }
    if(c<0)cout<<"No"<<endl;
    else cout<<"Yes"<<endl;
    return 0;
}


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

#define fastio 			ios::sync_with_stdio(0);	cin.tie(0); cout.tie(0);  cout<<fixed;  cout<<setprecision(12);	
#define randomINT 		mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define	newl 			cout<<"\n"
#define DISP(as)		for(auto it : as) cout<<it<<" ";newl;
#define all(x)         	(x).begin(),(x).end()
#define mset(x,val)    	memset(x,val,sizeof(x))
#define newl           	cout<<"\n"
#define pb             	push_back
#define mp             	make_pair
#define f 				first
#define s 				second
#define dline          cerr<<"///REACHED///\n";
#define deb1(x)        cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y)      cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z)    cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';

typedef long long 				ll;
typedef long double 			ld;
typedef vector<ll> 				vll;
typedef pair<ll ,ll> 			pll;
typedef pair<ld,ld> 			pld;
typedef unordered_map<ll,ll> 	um;
typedef vector<pll> 			vpll;

const ll 	MAX5 	= 	1e+5+7;
const ll 	MAX7 	= 	1e+7+7;
const ll 	MAXN 	= 	MAX7;
const ll   	INF   	=  	0x7f7f7f7f7f7f7f7f;
const int  	INFi 	=  	0x7f7f7f7f;
const ll 	MOD		=  	1e+9+7;

vll adj[MAXN];ll visit[MAXN]={};
int dx8[]={0,1,1,1,0,-1,-1,-1}, dy8[]={1,1,0,-1,-1,-1,0,1};
int dx4[]={0,1,0,-1}, dy4[]={1,0,-1,0};

// <------------- Declare Variables Here ------------> //

ll t=1;
ll n,x;ld a,b,c,d;
string s;

// <------------- Implement Functions Here ----------> //



// <------------- Start of main() -------------------> //

void MAIN() {
	cin>>a>>b>>c>>d;

	if(ceil(a/d) >= ceil(c/b)) cout<<"Yes";
	else cout<<"No";
}

int main() {
	fastio;randomINT;
	//cin>>t;
	while(t--) {
		MAIN();
	}
	return 0;
}


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

int main() {
  char c;
  cin>>c;
  if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'){
    cout<<"vowel"<<endl;
  }
  else{
    cout<<"consonant"<<endl;
  }
}

Measured memory_bytes: 256
#include<bits/stdc++.h>
#define mod 1000000007
#define ll long long int
#define ar array
#define mp make_pair
using namespace std;

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	string s,t;
	getline(cin,s);
	stringstream ss(s);
	while(ss>>t)
	{
		cout<<char(t[0]-32);
	}
	return 0;
}

Measured memory_bytes: 256
#define DEB
#include<bits/stdc++.h>
#define REP(i,m) for(int i=0;i<(m);++i)
#define REPN(i,m,in) for(int i=(in);i<(m);++i)
#define ALL(t) (t).begin(),(t).end()
#define CLR(a) memset((a),0,sizeof(a))
#define pb push_back
#define mp make_pair
#define fr first
#define sc second

using namespace std;


#ifdef DEB
#define dump(x)  cerr << #x << " = " << (x) << endl
#define prl cerr<<"called:"<< __LINE__<<endl
#define dumpR(x) cerr<<"\x1b[31m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpY(x) cerr<<"\x1b[33m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
#define dumpG(x) cerr<<"\x1b[32m"<<#x<<" = " <<(x)<<"\x1b[39m"<<endl
template<class T> void debug(T a,T b){ for(;a!=b;++a) cerr<<*a<<' ';cerr<<endl;}
#else
#define dump(x) ;
#define dumpR(x) ;
#define dumpY(x) ;
#define dumpG(x) ;
#define prl ;
template<class T> void debug(T a,T b){ ;}
#endif

template<class T> void chmin(T& a,const T& b) { if(a>b) a=b; }
template<class T> void chmax(T& a,const T& b) { if(a<b) a=b; }

typedef long long int lint;
typedef pair<int,int> pi;

namespace std{
  template<class S,class T>
  ostream &operator <<(ostream& out,const pair<S,T>& a){
    out<<'('<<a.fr<<','<<a.sc<<')';
    return out;
  }
}

//const int INF=5e8;
char s[105];
int ar[105];
int main(){
  scanf("%s",s);
  int n=strlen(s);
  REP(i,n) ar[i]=s[i]-'a';
  for(int i=0;i<n;++i){
    REP(c,26){
      bool mark[105]={false};
      REP(j,n) if(ar[j]==c){
        for(int k=max(0,j-i);k<=j;++k) mark[k]=true;
      }
      bool fail=false;
      REP(j,n-i) if(!mark[j]) fail=true;
      if(!fail){
        cout<<i<<endl;
        return 0;
      }
    }
  }
  return 0;
}





Measured memory_bytes: 256
#include<bits/stdc++.h>
#define maxn 200050
using namespace std;
typedef long long LL;

int n;
char s[maxn];

int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    LL ans=0,sum=0;
    for (int i=n;i;--i)
    {
        if (s[i]=='B')
            ans+=sum;
        else
            ++sum;
    }
    printf("%lld\n",ans);
    return 0;
}

Measured memory_bytes: 384
N, M =map(int, input().split())
H = list(map(int, input().split()))
li = [1]*N
for i in range(M):
    a, b = map(int, input().split())
    if H[a-1] >= H[b-1]:
        li[b-1] = 0
    if H[b-1] >= H[a-1]:
        li[a-1] = 0
print(li.count(1))

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

char str[105];
bool vis[105];

inline int read()
{
    int a=0,f=1; char c=getchar();
    while (c<'0'||c>'9') {if (c=='-') f=-1; c=getchar();}
    while (c>='0'&&c<='9') {a=a*10+c-'0'; c=getchar();}
    return a*f;
}

int main()
{
    scanf("%s",str+1);
    int len=strlen(str+1);
    for (int i=1;i<=len;i++)
        vis[str[i]-'a']=true;
    int c=-1;
    for (int i=0;i<26;i++)
        if (!vis[i])
        {
            c=i;
            break;
        }
    if (c!=-1)
    {
        printf("%s%c\n",str+1,c+'a');
        return 0;
    }
    bool flag=false;
    for (int i=len;i>1;i--)
        if (str[i]>str[i-1])
        {
            flag=true;
            int t=26;
            for (int j=i;j<=len;j++)
                if (str[j]>str[i-1])
                    t=min(t,str[j]-'a');
            for (int j=1;j<i-1;j++)
                putchar(str[j]);
            putchar(t+'a');
            puts("");
            break;
        }
    if (!flag) puts("-1");
    return 0;
}


Measured memory_bytes: 256
n,m = map(int,input().split())
A = list(map(int,input().split()))
allA = sum(A)
A.sort(reverse=True)
ans = "Yes"
for i in range(m):
    a = A[i]
    div = allA/(4*m)
    if a < div:
        ans = "No"
        break
print(ans)


Measured memory_bytes: 3060
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.array;
import std.algorithm;

void main(){
    auto ab = readln().chomp().split().map!(to!int).array();
    ab.solve().writeln();
}

int solve(int[] input){
    auto a = input[0];
    auto b = input[1];
    if (b >= a){
        return a;
    }else{
        return a - 1;
    }
}

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

using namespace std;

int main()
{
    int n , k ;
    cin>>n>>k ;
    int arr[n+1] ;
    for(int i = 1 ; i  <= n ; ++i)
        cin>>arr[i] ;
    int x = 0 , ans = 0, cnt = 0;
    for(int i = 1 ; i <= n ; ++i)
    {
        cnt++;
        if(cnt == k)
           i -= (i != n) , ans++ ,cnt = 0;
    }
    if(cnt == 0)
        cout<<ans;
    else
        cout<<ans+1;
    return 0 ;
}

Measured memory_bytes: 640
#include<bits/stdc++.h>
using namespace std;
int main()
{
    string s;
    cin>>s;
    int sum=0;
    for(int i=0;i<s.size();i++)
    {
        sum=sum+s[i]-48;
    }
    int k,j=0,count=0,countt=0;
    if(sum==0){
        cout<<"Yes"<<endl;}
        else{
    while(k<=sum){
        k=j*9;
        if(k==sum){
            count++;
        break;}
        else{
            j++;}
    }
    if(count>0)
        cout<<"Yes"<<endl;
    else
        cout<<"No"<<endl;}
}


Measured memory_bytes: 3708
n,m=map(int,input().split())
a = []
for i in range(n):
    a.append(list(map(int, input().split())))
    a[i]+=[sum(a[i])]
    print(*a[i])
a=list(zip(*a[::-1]))
for i in range(m):print(sum(a[i]),end=' ')
print(sum(a[m]))

Measured memory_bytes: 7724
#include <stdio.h>
#include <stdlib.h>
#pragma warning(disable:4996)

int main() {
	int n = 0,k=0,c=0,u=0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		int v[101] = { 0 };
		scanf("%d", &c);
		scanf("%d", &k);
		for (int j = 0; j < k; j++) {
			scanf("%d", &u);
			v[u] = 1;
		}
		for (int j = 1; j < n ; j++) {
			printf("%d ", v[j]);
		}
		for (int j = n; j < n + 1; j++) {
			printf("%d\n", v[j]);
		}
	}
}


Measured memory_bytes: 2132
#include <bits/stdc++.h>
#pragma GCC optimize ("O2,unroll-loops")
//#pragma GCC optimize("no-stack-protector,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef pair<ll, ll> pll;
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugp(x) cerr<<#x<<"= {"<<(x.first)<<", "<<(x.second)<<"}"<<endl;
#define debug2(x, y) cerr<<"{"<<#x<<", "<<#y<<"} = {"<<(x)<<", "<<(y)<<"}"<<endl;
#define debugv(v) {cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;}
#define all(x) x.begin(), x.end()
#define pb push_back
#define kill(x) return cout<<x<<'\n', 0;

const ld eps=1e-7;
const int inf=1000000010;
const ll INF=10000000000000010LL;
const int mod=1000000007;
const int MAXN=100010, LOG=20;

ll n, m, k, u, v, w, t, a, b, ans;

int main(){
	ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	cin>>a>>v>>b>>w>>t;
	if (a==b) kill("YES")
	if (v<=w) kill("NO")
	a=abs(a-b);
	v-=w;
	if (a>v*t) kill("NO")
	kill("YES")
	return 0;
}


Measured memory_bytes: 3648
import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
//        sc.useDelimiter("\n");

        String s = sc.next();
        String p = sc.next();
        String ss = s.concat(s);
        if (ss.indexOf(p) != -1)
            pw.println("Yes");
        else
            pw.println("No");
        
        pw.flush();
    }
}


Measured memory_bytes: 26356
import java.util.*;

class Main{

  	public static void main(String args[]){
    	Scanner sc=new Scanner(System.in);
      
      	int a=sc.nextInt();
      	int b=sc.nextInt();
      	int c=sc.nextInt();
      	int d=sc.nextInt();
      
      	int sum=0;
      	if(a>b){
        	sum+=b;
        }else{
        	sum+=a;
        }
      	
      if(c>d){
        	sum+=d;
        }else{
        	sum+=c;
        }
      	
      System.out.println(sum);
    }
}

Measured memory_bytes: 21844
#include<iostream>
int main(void){
  int D, T, S;
  std::cin >> D >> T >> S;
  double time = double(D) / double(S);
  if (time > T){
    std::cout << "No" << std::endl;
  }else{
    std::cout << "Yes" << std::endl;
  }
  return 0;
}

Measured memory_bytes: 3620
#include<stdio.h>

int main() {
	int s, i, bool[10000];
	if (scanf("%d", &s) == 0) return 1;
	for (i = 0; i < 10000; i++) bool[i] = 0;
	i = 0;
	while (1) {
		i++;
		if (bool[s] == 0) bool[s] = i;
		else break;
		s = (s % 2 == 0) ? s / 2 : 3 * s + 1;
	}
	printf("%d", i);
	return 0;
}


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

int main(){
  string s;
  cin >> s;

  if(s[0] == 'Y' && s[1] == 'A' && s[2] == 'K' && s[3] == 'I')
    cout << "Yes";
  else
    cout << "No";
  
  return 0;
}


Measured memory_bytes: 256
N = int(input())
a = list(map(int, input().split()))
ma = max(a)
mi = min(a)
if ma - mi >= 2:
    print('No')
elif ma == mi:
    if a[0] == N - 1:
        print('Yes')
    elif 2 * a[0] <= N:
        print('Yes')
    else:
        print('No')
else:
    al = 0
    na = 0
    for i in range(N):
        if a[i] == ma - 1:
            al += 1
        else:
            na += 1

    if al < ma and 2 * (ma - al) <= na:
        print('Yes')
    else:
        print('No')

Measured memory_bytes: 52804
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
 
using namespace std;
using namespace __gnu_pbds;
 
using ll = long long;
using ldb = long double;
using pa = pair < ll, ll >;
using vec = vector < ll >;
 
template < typename T > using index_set = tree < T, null_type, less < T >, rb_tree_tag, tree_order_statistics_node_update >;
template < typename T > using MinPriorityQueue = priority_queue < T, vector < T >, greater < T > >;

#define pb push_back
#define po pop_back
#define mp make_pair
#define mt make_tuple
#define F  first
#define S  second
#define f(i,x,n) for(ll i=x;i<n;i++) 
#define all(c) c.begin(),c.end()
#define str string
#define edl "\n"
#define add insert
#define cot continue
#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL)

const int MOD = 1e9 + 7, INF = INT_MAX, N = 1e5 + 10;
const double PI = acos(-1);
const ll LINF = LLONG_MAX;
int main() 
{

  fast();
  
    ll n;
    cin >> n;
    vector<double> q(n);
    f(i,0,n)
    {
        cin >> q[i];
    }
    sort(all(q));
    double s=q[n-1];
    q.pop_back();
    cout<<accumulate(all(q),0.0)+s/2;


    cerr << "Time taken: " << int((clock() * 1000.) / CLOCKS_PER_SEC) << "ms\n";
    return 0;
}
 

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

int a, b, hasil;

int main () {
cin >> a >> b;
if ((0<a)&&(0<b)&&(10>a)&&(10>b)) {
     hasil=a*b;
     cout << hasil << endl;
} else {
     hasil=-1;
     cout << hasil << endl;
}
}


Measured memory_bytes: 3572
{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}
{-# LANGUAGE BangPatterns #-}

import           Control.Applicative
import qualified Data.ByteString.Char8  as B
import qualified Data.ByteString.Unsafe as B
import           Data.Char
import           Data.Monoid
import qualified Data.Vector.Unboxed    as U

main :: IO ()
main = do
    [n, q] <- map read.words <$> getLine :: IO [Int]
    queries <- U.unfoldrN q (readInt3.B.dropWhile isSpace) <$> B.getContents
    putStr.unlines.map show $ solve n queries

solve :: Int -> U.Vector (Int, Int, Int) -> [Int]
solve n queries = ($[]) . fst $ U.foldl' step  (id, segtree0) queries
  where
    segtree0 = toSegTree $ U.replicate n mempty
    step (!acc, !segtree) (com, x, y)
        | com == 0 = (acc, updateKey x (const y) segtree)
        | otherwise = let !v = queryRange x y segtree
                      in (acc.(v:), segtree)

instance Monoid Int where
    mempty = 0x7fffffff
    mappend = min
    {-# INLINE mempty #-}
    {-# INLINE mappend #-}

-------------------------------------------------------------------------------

readInt3 :: B.ByteString -> Maybe ((Int,Int,Int), B.ByteString)
readInt3 bs = Just ((x,y,z),bsz)
  where
    Just (x, bsx) = B.readInt bs
    Just (y, bsy) = B.readInt $ B.unsafeTail bsx
    Just (z, bsz) = B.readInt $ B.unsafeTail bsy

data SegTree m
    = Node
    {-# UNPACK #-} !Int
    {-# UNPACK #-} !Int
    !m
    !(SegTree m)
    !(SegTree m)
    | Leaf
    {-# UNPACK #-} !Int
    !m
    deriving Show


extract :: SegTree m -> m
extract (Node _ _ m _ _) = m
extract (Leaf _ m) = m
{-# INLINE extract #-}

toSegTree :: (U.Unbox m, Monoid m) => U.Vector m -> SegTree m
toSegTree vec = go 0 (U.length vec - 1)
  where
    go !l !r
        | l < r = let !m = (l + r) `quot` 2
                      lt = go l m
                      rt = go (m + 1) r
                  in Node l r (extract lt <> extract rt) lt rt
        | otherwise = Leaf l $ U.unsafeIndex vec l

updateKey :: Monoid m => Int -> (m -> m) -> SegTree m -> SegTree m
updateKey key f = go
  where
    go segtree@(Node l r _ lt rt)
        | key < l || r < key = segtree
        | 2 * key <= l + r = let !lt' = go lt
                             in Node l r (extract lt' <> extract rt) lt' rt
        | otherwise = let !rt' = go rt
                      in Node l r (extract lt <> extract rt') lt rt'
    go segtree@(Leaf k m)
        | k == key = Leaf k (f m)
        | otherwise = segtree
{-# INLINE updateKey #-}

queryKey :: Monoid m => Int -> SegTree m -> m
queryKey key = go
  where
    go (Node l r _ lt rt)
        | key < l || r < key = mempty
        | 2 * key <= l + r = go lt
        | otherwise = go rt
    go (Leaf k m)
        | k == key = m
        | otherwise = mempty
{-# INLINE queryKey #-}

queryRange :: Monoid m => Int -> Int -> SegTree m -> m
queryRange kl kr = go
  where
    go (Node l r m lt rt)
        | r < kl || kr < l = mempty
        | kl <= l && r <= kr = m
        | otherwise = go lt <> go rt
    go (Leaf k m)
        | kl <= k && k <= kr = m
        | otherwise = mempty
{-# INLINE queryRange #-}

Measured memory_bytes: 36396
import java.util.Arrays;
import java.util.Scanner;

public class Main
{
	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		boolean[] flag = new boolean[1000001];
		for(int i=2;i*i<=1000000;i++)
		{
			if(!flag[i])
			{
				for(int j=i*2;j<=1000000;j+=i)
				{
					flag[j] = true;
				}
			}
		}
		
		while(sc.hasNext())
		{
			int n = sc.nextInt();
			int count = 0;
			for(int i=2;i<=n;i++)
			{
				if(!flag[i]) count++;
			}
			System.out.println(count);
		}
	}
}

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

#define N 8
#define FREE -1
#define NOFREE 1

int row[N], col[N], dpos[2*N-1], dneg[2*N-1];

bool X[N][N];

void initialize()
{
    for (int i=0; i<N;i++)
    {
        row[i]=FREE,col[i]=FREE;
    }
    for (int i=0; i<2*N-1;i++)
    {
        dpos[i]=FREE;
        dneg[i]=FREE;
    }
}

void printBoard()
{
    for (int i= 0;i<N;i++)
    {
        for (int j=0; j<N;j++)
        {
            if (X[i][j])
            {
                if (row[i]!=j)
                    return;
            }
        }
    }
    for (int i=0; i<N;i++)
    {
        for (int j=0;j<N;j++)
        {
            cout << ((row[i]==j) ? "Q" : ".");
        }
        cout << endl;
    }
}

void recursive(int i)
{
    if (i==N)
    {
        printBoard();
        return;
    }
    for (int j=0;j<N;j++)
    {
        if (NOFREE == col[j] || NOFREE == dpos[j + i] || NOFREE == dneg[i-j+N-1])
            continue;
        row[i] = j;
        col[j] = dpos[i+j]=dneg[i-j+N-1] = NOFREE;
        recursive(i + 1);
        row[i] = col[j] = dpos[i+j] = dneg[i-j+N-1] = FREE;
    }
}

int main()
{
    initialize();

    for (int i=0;i<N;i++)
        for (int j=0;j<N;j++)
            X[i][j] = false;
    int k;
    cin >> k;
    for (int i=0;i<k;i++)
    {
        int r, s;
        cin >> r >> s;
        X[r][s] = true;
    }
    recursive(0);

    return 0;
}


Measured memory_bytes: 3124
#include <iostream>
using namespace std;
#define MOD 1000000007
int n;
int adj[30];
long long dp[(1<<21)];
int main () {
	cin >> n;
	bool inp;
	for (int i=0; i<n; i++) {
		for (int j=0; j<n; j++) {
			cin >> inp;
			if (inp) adj[i] |= (1<<j);
		}
	}
	dp[0] = 1;
	for (int i=1; i<(1<<n); i++) {
		int cnt = 0;
		for (int j=0; j<n; j++) {
			if (i & (1<<j)) cnt++;
		}
		for (int j=0; j<n; j++) {
			if (i & (1<<j) && (adj[cnt-1] & (1<<j))) {
				dp[i] = (dp[i]+dp[i-(1<<j)])%MOD;
			}
		}
	}
	cout << dp[(1<<n)-1] << endl;
}

Measured memory_bytes: 19948
#include <stdio.h>
#include<iostream>
using namespace std;

const int M = 1000010;
int prime[M];
bool isprime[M];

bool is_prime(int n);  
int sieve(int n);  

int main ( )
{
    int n;
    while(~scanf("%d",&n))
        printf("%d\n",sieve(n));

    return 0;
}

bool is_prime(int n)
{
    for(int i=2;i*i<=n;i++)
        if(n%i==0)
            return false;

    return n!=1;
}

int sieve(int n)
{
    int p=0,i;
    for( i=0;i<=n;i++)
        isprime[i] = true;
    isprime[0] = isprime[1] = false;
    i++;
    for( i=2;i<=n;i++)
        {
        if(isprime[i])
        {
            prime[p++] = i;
            for(int j=2*i;j<=n;j+=i)
                isprime[j] = false;
        }
    }
    i++;
    return p;
}


Measured memory_bytes: 4416
function Main(input) {
  "use strict";
  const lines = input.split("\n");
  const line1 = lines[0].split(" ");
  const line2 = lines[1].split(" ");
  const line3 = lines[2].split(" ");
  const line4 = lines[3].split(" ");

  const a = parseInt(line1[0], 10);
  const b = parseInt(line2[0], 10);
  const c = parseInt(line3[0], 10);
  const x = parseInt(line4[0], 10);

  var count = 0
  for (var i = 0; i <= a; i++) {
    for (var j = 0; j <= b; j++) {
      for (var k = 0; k <= c; k++) {
        if (i*500 + j*100 + k*50 === x) {
          count++

        }

      }
    }
  }
  console.log(count)
}
// Exec
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


Measured memory_bytes: 33552
D, G = map(int,input().split(' '))
pc = [list(map(int,input().split(' '))) for i in range(D)]


ans = 0
for i in range(D):
    ans += pc[i][0]

for i in range(2**D-1):
    temp_ans = 0
    temp_sum = 0
    s = '{:010b}'.format(i)[::-1]
 #   print(s)
    notused = -1
    for j in range(D):
        if s[j] == '1':
            temp_ans += pc[j][0]
            temp_sum += (j+1)*pc[j][0]*100 + pc[j][1]
        else:
            notused = j
#    print(notused,temp_ans,temp_sum)
    if temp_sum >= G:
        ans = min(temp_ans,ans)
    else:
        for i in range(1,pc[notused][0]):
            if (notused+1)*i*100+temp_sum >= G:
                ans = min(temp_ans+i,ans)
#                print(ans)
                break
print(ans)

Measured memory_bytes: 3064
N, T = map(int, input().split())
t = [int(i) for i in input().split()]

tmp = T
ans = T

for i in range(1, N):
    if t[i] <= T:
        ans += tmp - (T - t[i])
        T += tmp - (T - t[i])
    else:
        ans += tmp
        T += tmp + t[i] - T

print(ans)


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

int main(){
    int d,t,s;
    cin>>d>>t>>s;
    if(s*t>=d) cout<<"Yes";
    else cout<<"No";
}


Measured memory_bytes: 3620