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

using namespace std;
using ll =long long;
#define For(i, a, b)    for(int i = (a) ; i < (b) ; ++i)
#define rep(i, n)       For(i, 0, n)
#define debug(x)  cerr << #x << " = " << (x) << endl;
#define leftunique(a) {sort((a).begin(),(a).end());(a).erase(unique((a).begin(),(a).end()),(a).end());}
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; }
static const ll INF = 1LL << 60;
//Write From this Line

int main()
{
	ll n;
	cin >> n;
	vector<ll> x(n), y(n), h(n);
	rep(i,n) cin >> x[i] >> y[i] >> h[i];
	// 全探索
	ll H;
	int index;
	rep(i,n){
		if(h[i] != 0) {
			index = i;
			break;
		}
	}
	for(int Cx = 0; Cx <= 100; Cx++) {
		for(int Cy = 0; Cy <= 100; Cy++) {
			int H = h[index] + abs(x[index] - Cx) + abs(y[index] - Cy);
			if(H < 1) continue;
			bool flag = true;
			rep(i,n){
				if(h[i] != max((ll)H - abs(x[i] - Cx) -abs(y[i] - Cy), (ll)0)){
					flag = false;
				}
			}
			if(flag){
				printf("%d %d %d\n", Cx, Cy, H);
			}
		}
	}
}


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

#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
typedef long long int ll;

using namespace std;

int main() {
  int N;
  vector<int> V(N), C(N);
  cin >> N;
  REP(i, N) cin >> V[i];
  REP(i, N) cin >> C[i];

  int ans = 0;
  REP(i, N) {
    if (V[i] > C[i]) ans += V[i] - C[i];
  }
  cout << ans << endl;
}

Measured memory_bytes: 512
s = input()
q = int(input())

start = ''
end = ''

rvs = False

for i in range(q):
  query = input()
  if query[0] == '1':
    if rvs == False:
      rvs = True
    else:
      rvs = False
  else:
    t, f, c = query.split()
    if f == '1':
      if rvs == False:
        start = c + start
      else:
        end = end + c
    else:
      if rvs == False:
        end = end + c
      else:
        start = c + start

if rvs == False:
  print(start + s + end)
else:
  ans = start + s + end
  print(ans[::-1])

Measured memory_bytes: 4560
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef long double LD;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 1e18;
const double INFD = 1e30;
const double EPS = 1e-6;
const double PI = 3.14159265;
const ll MOD = 1e9 + 7;
template <typename T>
inline T read() {
    T X = 0, w = 0;
    char ch = 0;
    while (!isdigit(ch)) {
        w |= ch == '-';
        ch = getchar();
    }
    while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
    return w ? -X : X;
}
const int MAXN = 200005;
int n, m, k;
int dr[4] = {1, 0, -1, 0};
int dc[4] = {0, 1, 0, -1};
int dr2[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int dc2[8] = {1, 0, -1, 1, 0, -1, 1, -1};
int CASE = 1;
struct Inv {
    ll x, c;
    bool operator<(const Inv& other) const { return x < other.x; }
};
Inv mons[MAXN];
ll diff[MAXN];

struct ST {
    static const int MAX_LOG = 18;
    int st[MAX_LOG][MAXN];
    void init() {
        int logg = log2(n);
        for (int i = 1; i <= logg; i++) {
            for (int j = 1; j <= n; j++) {
                st[i][j] = max(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
            }
        }
    }
    int query(int l, int r) {
        int logg = log2(r - l + 1);
        return max(st[logg][l], st[logg][r - (1 << (logg)) + 1]);
    }
};

ST st;

int main() {
#ifdef LOCALLL
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= n; i++) {
        int x, h;
        scanf("%d%d", &x, &h);
        mons[i].x = x, mons[i].c = (h + k - 1) / k;
    }
    sort(mons + 1, mons + n + 1);
    ll cur = 0, res = 0;
    for (int i = 1; i <= n; i++) {
        cur += diff[i];
        if (mons[i].c - cur <= 0) continue;
        int l = 1, r = n, ans = 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (mons[mid].x <= mons[i].x + 2 * m) {
                ans = mid, l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        res += mons[i].c - cur;
        diff[i] += mons[i].c - cur, diff[ans + 1] -= mons[i].c - cur;
        cur = mons[i].c;
    }
    printf("%lld", res);
    return 0;
}

Measured memory_bytes: 6656
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
#include"stdio.h"
#include"stdlib.h"
#include"assert.h"
#include"ctype.h"
#include"string.h"
#include"math.h"
#include"string"
#include"deque"
#include"iostream"
#include"set"
#include"map"
#include"vector"
#include"algorithm"
#include"bitset"
#include"stack"
#include"queue"
#include"sstream"
using namespace std;
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define int long long
#define ends ' '
#define endl '\n'
#define pb emplace_back
#define x first
#define y second
#define pii pair<int, int>
#define sz(x) (int)(x).size()

int32_t main()
{
	// #ifndef ONLINE_JUDGE
	// 	freopen("input.txt", "r", stdin);
	// 	freopen("output.txt", "w", stdout);
	// #endif
	IOS;

	int n;
	cin >> n;

	int a[n];

	for(int i = 0; i < n; ++i)
		cin >> a[i];

	sort(a, a+n);

	int temp = a[n/2-1];

	if(a[n/2] == temp)
	{
		cout << 0;
		return 0;
	}

	++temp;

	cout << a[n/2]-temp+1;

	return 0;
}

Measured memory_bytes: 1024
use std::cmp;

const MAX_C: usize = 30;
const MAX_N: usize = 100000;

fn main() {
    let mut sc = Scanner::new();
    let n: usize = sc.read();
    let c: usize = sc.read();

    let mut records: Vec<Vec<(usize, usize)>> = (0..MAX_C).map(|_| Vec::new()).collect();
    for _ in 0..n {
        let s = sc.read::<usize>() - 1;
        let t = sc.read::<usize>() - 1;
        let c = sc.read::<usize>() - 1;
        records[c].push((s, t));
    }

    let mut starts = vec![0; MAX_N];
    let mut ends = vec![0; MAX_N];
    for c in 0..MAX_C {
        records[c].sort();
        for i in 0..records[c].len() {
            if i == 0 {
                let (s, t) = records[c][i];
                starts[s] += 1;
                ends[t] += 1;
            } else {
                let (ps, pt) = records[c][i - 1];
                let (s, t) = records[c][i];
                starts[s] += 1;
                ends[t] += 1;
                if pt == s {
                    ends[s] -= 1;
                    starts[s] -= 1;
                }
            }
        }
    }

    let mut ans = 0;
    let mut cur = 0;
    for i in 0..MAX_N {
        cur += starts[i];
        ans = cmp::max(ans, cur);
        cur -= ends[i];
    }

    println!("{}", ans);
}

struct Scanner {
    ptr: usize,
    length: usize,
    buf: Vec<u8>,
    small_cache: Vec<u8>,
}

impl Scanner {
    fn new() -> Scanner {
        Scanner { ptr: 0, length: 0, buf: vec![0; 1024], small_cache: vec![0; 1024] }
    }

    fn load(&mut self) {
        use std::io::Read;
        let mut s = std::io::stdin();
        self.length = s.read(&mut self.buf).unwrap();
    }

    fn byte(&mut self) -> u8 {
        if self.ptr >= self.length {
            self.ptr = 0;
            self.load();
            if self.length == 0 {
                self.buf[0] = b'\n';
                self.length = 1;
            }
        }

        self.ptr += 1;
        return self.buf[self.ptr - 1];
    }

    fn is_space(b: u8) -> bool { b == b'\n' || b == b'\r' || b == b'\t' || b == b' ' }

    fn read<T>(&mut self) -> T where T: std::str::FromStr, T::Err: std::fmt::Debug, {
        let mut b = self.byte();
        while Scanner::is_space(b) {
            b = self.byte();
        }

        for pos in 0..self.small_cache.len() {
            self.small_cache[pos] = b;
            b = self.byte();
            if Scanner::is_space(b) {
                return String::from_utf8_lossy(&self.small_cache[0..(pos + 1)]).parse().unwrap();
            }
        }

        let mut v = self.small_cache.clone();
        while !Scanner::is_space(b) {
            v.push(b);
            b = self.byte();
        }
        return String::from_utf8_lossy(&v).parse().unwrap();
    }
}



Measured memory_bytes: 10492
#include<iostream>
#include<vector>
#include<queue>

using namespace std;

using ll = long long;

int main() {
    int N, M;
    cin >> N >> M;
    vector<bool> isReached(N, false), is(N,false);
    vector<ll> count(N,0),c(N,0);
    vector< vector<int> > graph(N);
    queue<int> que;
    vector<int> dist(N),d(N);
    int s, t;
    cin >> s >> t;
    s--; t--;
    int x, y;
    for(int i=0 ; i<M ; i++){
        cin >> x >> y;
        x--; y--;
        graph[x].push_back(y);
        graph[y].push_back(x);
    }
    int now;
    que.push(s);
    count[0] = 1;
    isReached[s] = true;
    dist[s] = 0;
    while(!que.empty()){
        now = que.front();
        que.pop();
        for(int i=0; i<graph[now].size() ; i++){
            if(!isReached[graph[now][i]]){
                que.push(graph[now][i]);
                isReached[graph[now][i]] = true;
                dist[graph[now][i]] = dist[now]+1;
                count[dist[graph[now][i]]]++;
            }
        }
    }
    que.push(t);
    c[0] = 1;
    is[t] = true;
    d[t]=0;
    while(!que.empty()){
        now = que.front();
        que.pop();
        for(int i=0; i<graph[now].size() ; i++){
            if(!is[graph[now][i]]){
                que.push(graph[now][i]);
                is[graph[now][i]] = true;
                d[graph[now][i]] = d[now]+1;
                c[d[graph[now][i]]]++;
            }
        }
    }
    ll ans=0;
    for(int i=0; i<= dist[t]-2 ; i++){
        ans+= count[i]*c[dist[t]-2-i];
    }
    cout << ans << endl;
    return 0;
}



Measured memory_bytes: 11756
let [| N; K |] = stdin.ReadLine().Split() |> Array.map int

let r = Array.zeroCreate<float> N

let solver =
    let rec loop i =
        if i = N then ()
        else
            let mutable s = i + 1
            r.[i] <- 1. / (float N)
            while s < K do
                s <- s * 2
                r.[i] <- r.[i] * 0.5
            loop (i + 1)
    loop 0

solver
r
|> Array.sum
|> stdout.WriteLine


Measured memory_bytes: 11988
#include <bits/stdc++.h>
//#include <map>
//#include <set>
//#include <list>
//#include <cmath>
//#include <ctime>
//#include <deque>
//#include <queue>
//#include <stack>
//#include <string>
//#include <bitset>
//#include <cstdio>
//#include <limits>
//#include <vector>
//#include <climits>
//#include <cstring>
//#include <cstdlib>
//#include <fstream>
//#include <numeric>
//#include <sstream>
//#include <iomanip>
//#include <iostream>
//#include <algorithm>
//#include <unordered_map>

using namespace std;

#define file freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
#define PI 3.141592653589793238462643383279502884
#define MAX 1000100
#define mod 1000000007
#define EPS 1E-9
#define int long long
#define endl "\n"

int fix(int cur, int m)
{
    return ((cur%m) + m) % m;
}

int fast_power(int x, int y,int m)
{
    if (y == 0)
        return 1;
    int temp = fast_power(x, y / 2, m) ;
    temp = (temp*temp)% m;
    if (y % 2 != 0)
        temp = (temp*x)% m;
    return temp;

}

int32_t main()
{
    //freopen("C:/Users/Joe/Desktop/tests/in11.txt", "r", stdin);
    //freopen("C:/Users/Joe/Desktop/tests/out11.txt", "w", stdout);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin.tie(0);
    std::ios::sync_with_stdio(false);
    cout.tie(0);

    int t=1;
    //cin >> t;
    while(t--)
    {
        int arr[]={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;
        cout << arr[k-1] << endl;
    }
    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
typedef long long ll;
typedef vector<ll> vl;
#define rp(i, f, t) for (int i = f; i < t; i++)
#define pr(i, f, t) for (int i = t - 1; i >= f; i--)
#define ca(n, a) rp(ca_i, 0, n) cout << a[ca_i] << ((ca_i == n - 1) ? "\n" : " ")
#define za(n, a) rp(za_i, 0, n) a[za_i] = 0
#define be(a) a.begin(), a.end()
int main()
{
    ll n, m;
    cin >> n >> m;
    ll s[m], c[m];
    rp(i, 0, m) cin >> s[i] >> c[i];

    set<ll> co[n];
    rp(i, 0, m) co[s[i] - 1].insert(c[i]);
    bool si = true;

    rp(i, 0, n) if (co[i].size() >= 2) si = false;
    bool sii = false;
    if (n == 1)
        sii = true;

    vl ans;
    if (si)
    {
        rp(i, 0, n)
        {
            bool siii = false;
            rp(j, 0, m)
            {
                if (s[j] == i + 1)
                {
                    ans.push_back(c[j]);
                    sii = true;
                    siii = true;
                    break;
                }
            }
            if (!siii)
            {
                if (sii)
                {
                    ans.push_back(0);
                }
                else
                {
                    ans.push_back(1);
                    sii = true;
                }
            }
        }
        if (ans[0] == 0 && ans.size() > 1)
        {
            cout << -1 << endl;
        }
        else
        {
            rp(i, 0, n)
            {
                cout << ans[i];
            }
            cout << endl;
        }
    }
    else
    {
        cout << -1 << endl;
    }
}

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

const double EPS=1e-10;
const double INF=1e10;

// 点オブジェクト
// ベクトルを表すのにも使う
struct Point {
    double x, y;
    Point(double x=0, double y=0) : x(x), y(y) {}
    double distance (const Point &o) const {
        return sqrt((x - o.x) * (x - o.x) + (y - o.y) * (y - o.y));
    }

    Point operator+(const Point &o) const {
        return Point(x+o.x, y+o.y);
    }

    Point operator-(const Point &o) const {
        return Point(x-o.x, y-o.y);
    }

    Point operator*(const double m) const {
        return Point(x*m, y*m);
    }

    Point operator/(const double d) const {
        return Point(x/d, y/d);
    }

    // 外積
    double cross(const Point &o) const {
        return x * o.y - y * o.x;
    }

    // 内積
    double dot(const Point &o) const {
        return x * o.x + y * o.y;
    }

    // ベクトルがx軸となす角
    double atan() const {
        return atan2(y, x);
    }

    // ベクトルの長さの二乗
    double norm() const {
        return dot(*this);
    }
};

// 点の進行方向
// 戻り値:
//     +1: 反時計回り
//     -1: 時計回り
//     +2: c, a, bの順に一直線上
//     -2: a, b, cの順に一直線上
//      0: a, c, bの順に一直線上
int ccw(Point a, Point b, Point c) {
    b = b-a, c = c-a;
    if (b.cross(c) > EPS) return +1; 
    if (b.cross(c) < -EPS) return -1;
    if (b.dot(c) < 0) return +2;
    if (b.norm() < c.norm()) return -2;
    return 0;
}

// 多角形
struct Polygon {
    vector<Point> vertex;

    Polygon() {}
    Polygon(vector<Point> vertex) : vertex(vertex) {}

    inline void add_vertex(Point v) {
        vertex.push_back(v);
    }

    void debug() {
        cout << vertex.size() << ' ';
    }

    Point next(int v) const {
        return vertex[(v+1) % vertex.size()];
    }
    Point prev(int v) const {
        return vertex[(v-1+vertex.size()) % vertex.size()];
    }

    double area() const {
        double ret = 0;
        for (int i = 0; i < vertex.size(); i++) {
            ret += vertex[i].cross(next(i));
        }
        return abs(ret) * 0.5;
    }
};

inline double deg2rad(double theta) {
    return theta / 180.0 * M_PI;
}

int main() {
    int m, n;
    while (cin >> m, m != 0) {
        vector<Point> v1, v2;
        int theta = 0;
        for (int i = 0; i < m-1; i++) {
            int dtheta;
            cin >> dtheta;
            theta += dtheta;
            v1.push_back(Point(cos(deg2rad(theta)), sin(deg2rad(theta))));
        }
        theta = 0;
        cin >> n;
        for (int i = 0; i < n-1; i++) {
            int dtheta;
            cin >> dtheta;
            theta += dtheta;
            v2.push_back(Point(cos(deg2rad(theta)), sin(deg2rad(theta))));
        }
        Polygon p1(v1), p2(v2);
        p1.add_vertex(Point(1, 0));
        p2.add_vertex(Point(1, 0));
        double a1 = p1.area();
        double a2 = p2.area();
        if (abs(a1 - a2) < EPS) {
            cout << 0 << endl;
        } else if (a1 > a2) {
            cout << 1 << endl;
        } else {
            cout << 2 << endl;
        }
    }
    return 0;
}

Measured memory_bytes: 0
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#include<random>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;
int main() {
	int T; ld E;cin>>T>>E;
	vector<long long int>cs(2*T+1);
	for (int i = 0; i < 2 * T + 1; ++i) {
		cin>>cs[i];
	}
	ld ans=0;
	ans=E/cs[T];
	int l=T-1,r=T+1;
	{
		ld sum=0;
		ld pre=1e18;
		for (int i = T + 1; i < 2 * T + 1; ++i) {
			ld now=sum+(2*T+1-i)*cs[i];
			if (now < pre) {
				r=i;
				pre=now;
			}
			sum+=cs[i];
		}
	}
	{
		ld sum = 0;
		ld pre = 1e18;
		for (int i = T - 1; i >=0; --i) {
			ld now = sum + (i+1)*cs[i];
			if (now < pre) {
				l = i;
				pre = now;
			}
			sum += cs[i];
		}
	}
	ld sum=0;
	assert(l<r);
	for (int i = l; i <= r; ++i) {
		if(i==l)sum+=(i+1)*cs[i];
		else if(i==r)sum+=(2*T+1-i)*cs[i];
		else sum+=cs[i];
	}
	ans=max(ans,E/sum*(T+1));
	cout<<setprecision(20)<<fixed<<ans<<endl;
	return 0;
} 

Measured memory_bytes: 4524
#include<bits/stdc++.h>
#define ll long long int
#define ul unsigned long long int
#define va vector<long long int> a 
#define vb vector<long long int> b
#define debug() for(ll l=0;l<50;l++){}
#define fast cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);
const ll M = 998244353;
const ll inf = 1e18+5;
const ll INF=INT_MAX;
using namespace std;
ll bs(ll arr[], ll l, ll r, ll x){
	ll mid=0;
    if (r >= l){
		if (arr[mid] == x) return mid; 
        if (arr[mid] > x) return bs(arr, l, mid - 1, x); 
        return bs(arr, mid + 1, r, x); 
    }
    return -1;
}
ll power(ll x,ul y,ll p){
	ll res = 1;
	x = x % p;
	if(x == 0) return 0;
	while (y > 0){
		if (y & 1) res = (res*x) % p;
		y = y>>1;
		x = (x*x) % p;
		}
	return res;
}
const int max1=500001;
pair<int,int>st[4*max1];
int arr[max1],arr1[max1];
void buildtree(int si,int ss,int se){
	if(ss==se){
        st[si].first=arr1[ss];
        st[si].second=arr1[ss];
		return;
	}
	int mid=ss+(se-ss)/2;
	buildtree(2*si,ss,mid);
	buildtree(2*si+1,mid+1,se);
	if(arr1[mid]>arr1[mid+1]) st[si].first=st[2*si].first+st[2*si+1].first;
    else st[si].second=st[2*si].second+st[2*si+1].second;
	
}
int query(int si,int ss,int se,int qs,int qe){
	if(qs>se || qe<ss) //completely outside
		return INF;
	if(ss>=qs && se<=qe)
		return st[si].first;
	int mid=ss+(se-ss)/2;
	int l=query(2*si,ss,mid,qs,qe);
	int r=query(2*si+1,mid+1,se,qs,qe);
	return min(l,r);
}
int geteven(int si,int ss,int se,int qs,int qe){
	if(ss>qe || se<qs) //completely outside
		return 0;
	if(ss>=qs && se<=qe)
		return st[si].second;
	int mid=ss+(se-ss)/2;
	int l=geteven(2*si,ss,mid,qs,qe);
	int r=geteven(2*si+1,mid+1,se,qs,qe);
	return l+r;
}
int getodd(int si,int ss,int se,int qs,int qe){
	if(qs>se || qe<ss) //completely outside
		return 0;
	if(ss>=qs && se<=qe)
		return st[si].first;
	int mid=ss+(se-ss)/2;
	int l=getodd(2*si,ss,mid,qs,qe);
	int r=getodd(2*si+1,mid+1,se,qs,qe);
	return l+r;
}
void update(int si,int ss,int se,int qi,int newval){
	if(ss==se){
        if(arr[ss]%2==1) st[si]={0,1};
        else st[si]={1,0};
		arr[ss]=newval;
		return;
	}
	int mid=ss+(se-ss)/2;
	if(qi<=mid) update(2*si,ss,mid,qi,newval);
	else update(2*si+1,mid+1,se,qi,newval);
	st[si].first=st[2*si].first+st[2*si+1].first;
    st[si].second=st[2*si].second+st[2*si+1].second;
}
void solve(){
	ll n,a,b,c=0,max1=0;
	cin>>n;
	for(ll i=0;i<n;i++){
		cin>>a>>b;
		if(a==b) c++;
		else c=0;
		max1=max(max1,c);
	} 
	if(max1>=3) cout<<"Yes\n";
	else cout<<"No\n";
	
}
int main(){
	fast;
	ll t=1;
	//cin>>t;
	while(t--) solve();
	return 0;
}


Measured memory_bytes: 3612
#include <iostream>
#include <stack>

using namespace std;

int main() {
	int A[10];
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < 10; j++)
			cin >> A[j];
		stack<int> B, C;
		string ans = "YES";
		for (int j = 0; j < 10; j++) {
			if (j == 0)
				B.push(A[j]);
			else if (A[j] > B.top())
				B.push(A[j]);
			else if (A[j] < B.top()) {
				if (C.empty())
					C.push(A[j]);
				else if (A[j] < C.top())
					ans = "NO";
				else
					C.push(A[j]);
			}
		}
		cout << ans << endl;
	}
	return 0;
}

Measured memory_bytes: 1204
using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;
using static System.Math;
using System.Numerics;

namespace AtCoder
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
            Solve();
            //Out.Flush();
            Read();
        }

        static void Solve()
        {
            var N = Sarray()[0];
            var ans = 0L;
            for (var i = 0L; i * i <= N; ++i)
                ans = i * i;
            WriteLine(ans);
        }


        static long Mod = (long)1e9 + 7;
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }
        static public (T1 a, T2 b) Slice<T1, T2>()
        {
            var t = ReadLine().Split();
            return (
            (T1)Convert.ChangeType(t[0], typeof(T1)),
            (T2)Convert.ChangeType(t[1], typeof(T2)));
        }
        static public (T a, T b) Slice2<T>()
        {
            var t = ReadLine().Split();
            return (
            (T)Convert.ChangeType(t[0], typeof(T)),
            (T)Convert.ChangeType(t[1], typeof(T)));
        }
        static public (T a, T b, T c) Slice3<T>()
        {
            var t = ReadLine().Split();
            return (
            (T)Convert.ChangeType(t[0], typeof(T)),
            (T)Convert.ChangeType(t[1], typeof(T)),
            (T)Convert.ChangeType(t[2], typeof(T)));
        }
    }
}

Measured memory_bytes: 28212
#include<iostream>
using namespace std;
#include<cstring>
#include<cstdio> 
char s[1010000];
int gs[1010];
int pre[1010];
int main()
{
	while(scanf("%s",s)!=EOF)
	{
		int len=strlen(s);
		memset(gs,0,sizeof(gs));
		memset(pre,0,sizeof(pre));
		int l=-1,r=-1;
		for (int i=0;i<len;i++)
		{
			if (gs[s[i]]!=0)
			{
				if (i-pre[s[i]]<=2)
				{
					l=pre[s[i]]+1;
					r=i+1;
					break;
				}
			}
			gs[s[i]]++;
			pre[s[i]]=i;
		}
		cout<<l<<" "<<r<<endl;
	}
	return 0;
}

Measured memory_bytes: 508
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        if(a < b){
            System.out.println("a < b");
        }else if(a > b){
            System.out.println("a > b");
        }else{
            System.out.println("a == b");
        }
    }
}


Measured memory_bytes: 26268
#include <bits/stdc++.h>
using namespace std;
#define ll long long

int main(){
    char a, b;
    cin >> a >> b;
    if ((a == 'H' && b == 'H') || (a == 'D' && b == 'D')) cout << 'H' << endl;
    else cout << 'D' << endl;
    return 0;
}


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

int main (){

    long long int N,i,ans=1;
    cin >> N;
    long long int a[N];
    map<int,int>m;
    map<int,int>n;
    map<int,int>o;
    for(i = 0; i < N; i++) {
        cin >> a[i];
        m[a[i]]++;
        n[i+1] = a[i];
    }
    long long int tmp = n[1];
    if(tmp == 2) {
        cout << ans << endl;
        return 0;
    }
    o[1]++;
    if(m[2] == 0) {
        cout << -1 << endl;
    }else {
        for(i = 0; i < N; i++) {
            if(o[tmp] != 0) {
                cout << -1 << endl;
                return 0;
            }
            o[tmp]++;
            tmp = n[tmp];
            ans++;
            if(tmp == 2) {
                cout << ans << endl;
                return 0;
            }
        }
    }
    return 0;
}


Measured memory_bytes: 15104
n,d,a = gets.split.map(&:to_i)
monsters = n.times.map{ gets.split.map(&:to_i) } 

monsters.map!{ |xh| xh[1] = (xh[1]+a-1)/a; xh }.sort_by!{ |x,h| x }

deq = []
acc_damage = 0
ans = 0
monsters.each do |x,h|
  
  while deq.size > 0 && deq[0][0] < x do
    acc_damage -= deq.shift[1]
  end
  
  need = h - acc_damage
  need = 0 if need < 0
  
  if need > 0
    acc_damage += need
    ans += need
    deq.push( [x + d*2, need] )
  end
end

puts ans


Measured memory_bytes: 22520
/**
        Bismilla- hir rahma-nir rahi-m
    @uthor Md Hasibur Rahman (Evan)
                JKKNIU
*/


#include<bits/stdc++.h>
#define         ll              long long
#define         FI              freopen("input.txt","r",stdin)
#define         FO              freopen("output.txt","w",stdout)
#define         PrintCase(i)    printf("Case %d: ",i)
#define         sc(a)           scanf("%d",&a)
#define         scl(a)          scanf("%lld",&a)
#define         rep(i,n)        for(int i=0;i<n;i++)
#define         pb              push_back
#define         MAX             1000000
#define         fast            ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define         endl            "\n"


using namespace std;

bool isPrime(ll a)
{
    for(ll i=2;i*i<=a;i++)
        if(a%i==0)
            return false;
    return true;
}






bool isPowerOfTwo(ll a)
{
    if(a==1)
        return true;
    if(a&1)
        return false;
    while(a)
    {
        a/=2;
        if(a!=1 && a&1)
            return false;
        if(a==1)
            return true;
    }
    return true;
}



void Swap(ll &a, ll &b)
{

    a^=b;
    b^=a;
    a^=b;
}



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



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



ll power(ll base, ll exponent)
{
    ll ans = 1;
    for(ll i=1;i<=exponent;i++)
        ans*=base;
    return ans;
}




bool isPowerOfX(ll x, ll value)
{
    if(value==1)
        return true;
    while(value)
    {
        value/=x;
        if(value%x && value!=1)
            return false;
    }
    return true;
}





int main()
{
    fast;
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cout<<"ACL";
    return 0;
}


Measured memory_bytes: 3584
def taco_cal(max, num, min):
  x = int(max / num)
  if max % num > 0:
    x += 1
  sum_time = min * x
  return sum_time

num = list(map(int,input().split()))
time = taco_cal(num[0], num[1], num[2])
print(time)

Measured memory_bytes: 9088
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <cmath>
#include <algorithm>
#include <iomanip>

using namespace std;
#define LOCAL  1
#define UPLOAD 2
#define ll long long
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
template <class T = long long> T input(){T x;cin >> x;return x;}
template <class T> void output(T x){cout << x << endl;}
#define debug(x) cerr << #x<< ": " << x<< '\n';
#define debugBit(x,n) cerr << #x<< ": " << std::bitset<n>(x) << '\n';

int main()
{
#if ENVIRONMENT == LOCAL
    std::ifstream in("input.txt");
    std::cin.rdbuf(in.rdbuf());
#endif
  long X = input();

  if(X == 2){
    output(X);
    return 0;
  }
  
  for(long x=X;;x++){
    if(x%2 == 0)continue;
    bool isSosu = true;
    for(long i=3;i<sqrt(x);i+=2){
      if(x%i == 0){
        isSosu = false;
        break;
      }
    }
    if(isSosu){
      output(x);
      return 0;
    }
  }

  return 0;
}


Measured memory_bytes: 256
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define MOD 1000000007
using namespace std;
int main()
{
    string s;
    getline(cin,s);
    for(int i = 0;i < s.size();i++)
    {
        if(s[i] >= 'a' && s[i] <= 'z')
        {
            s[i] = s[i] - 'a' + 'A';
        }
        else if(s[i] >= 'A' && s[i] <= 'Z')
        {
            s[i] = s[i] - 'A' + 'a';
        }
    }
    cout << s << "\n";

    return 0;
}


Measured memory_bytes: 3216
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const long long MOD=1e9+7;

int main() {
  int n,m;
  cin>>n>>m;
  cout<<(n-1)*(m-1)<<endl;
}


Measured memory_bytes: 256
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
int center=0;

using namespace std;

int binarySearch(int* S, int S_size, int t ){

	int from=0, to=S_size-1;

	while( from <= to ) {
		center=(from+to)/2;

		if( S[center] == t ){
			return 1;
		}else if( t < S[center] ){
			to = center-1;
		}else if( S[center] < t ){
			from = center+1;
		}
	}

	return 0;



//	printf("(from, center, to) = (%d, %d, %d)\n", from, center, to);

	

	

}


	


int main(){

	int *S, *T;
	int S_size, T_size, temp;

	scanf("%d", &S_size);
	S=new int[S_size];
	for( int i=0; i<S_size; i++ ){
		scanf("%d", &temp);
		S[i]=temp;
	}
	scanf("%d", &T_size);
	T=new int[T_size];
	for( int i=0; i<T_size; i++ ){
		scanf("%d", &temp);
		T[i]=temp;
	}

	int ans=0;

	
	for( int i=0; i<T_size; i++ ){

		ans +=binarySearch(S, S_size, T[i]);
	}
	cout<<ans<<endl;

	return 0;
}

Measured memory_bytes: 1796
#include<stdio.h>
int main()
{
    int n,i,in,s=0,t=0,u;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&in);
        t+=in;
        if(in>s)
        s=in;
    }
    u=t-s+(s/2);
    printf("%d\n",u);
    return 0;
}

Measured memory_bytes: 1684
#include <iostream>
#include <cstring>

using namespace std;

int main(){
	int hash[200050];
	int n;
	cin >> n;
	memset(hash, 0, sizeof(hash));
	for (int i = 1; i < n; i++){
		int x;
		cin >> x;
		hash[x]++;
	}
	for (int i = 1; i <= n; i++){
		cout << hash[i] << endl;
	}
	return 0;
}


Measured memory_bytes: 4400
import sys
N = int(input())
A = sorted(list(map(int, sys.stdin.readline().split())))

ans = 1
flag = True
flag_zero = False
for a in A:
    ans *= a
    if ans > 10 ** 18:
        flag = False
        break
    if a == 0:
        flag_zero = True
        break

if flag:
    if not flag_zero:
        print(ans)
    else:
        print(0)
else:
    print(-1)

Measured memory_bytes: 21592
/*
AND Grid
by.YXH_XianYu
   2018.6.20

又是一道神奇的绘图题
https://agc004.contest.atcoder.jp/tasks/agc004_c
 */
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define rep(i,j,k) for(int i=j,lim=k;i<=lim;i++)
#define MXN 503

int n,m;
bool
	a[MXN][MXN],
	b[MXN][MXN];
char ch;

int main(){
	//freopen("AND Grid.in","r",stdin);
	//freopen("AND Grid.out","w",stdout);

	scanf("%d%d%c",&n,&m,&ch);
	
	rep(i,1,n){a[i][1]=1;if(  i&1 )continue;rep(j,2,m-1)a[i][j]=1;}
	rep(i,1,n){b[i][m]=1;if(!(i&1))continue;rep(j,2,m-1)b[i][j]=1;}

	rep(i,1,n){
		rep(j,1,m)
			scanf("%c",&ch),
			a[i][j]|=(ch=='.')?(0):(1),
			b[i][j]|=(ch=='.')?(0):(1);
		scanf("%c",&ch);
	}

	rep(i,1,n){rep(j,1,m)printf("%c",(a[i][j])?('#'):('.'));printf("\n");}
	printf("\n");
	rep(i,1,n){rep(j,1,m)printf("%c",(b[i][j])?('#'):('.'));printf("\n");}

	return 0;
}


Measured memory_bytes: 1280
#include <iostream>
#include<set>
#include<map>
#define INF 1e8
using namespace std;
int main(void){
set<long long> s;
int n;
cin>>n;

for(int i=0;i<n;i++){
    long long a;
    cin>>a;
    if(s.find(a)!=s.end())
        {
            cout<<"NO";
            return 0;
        }
    s.insert(a);
}
cout<<"YES";
}



Measured memory_bytes: 12396
#include <iostream>
#include <vector>
#include <tuple>

class uftree{
  std::vector<int> parent;
  std::vector<long long> ufsize;
  public:
  uftree(int n) : parent(n), ufsize(n, 1) {
    for(int i = 0; i < n; i++){
      parent[i] = i;
    }
  }
  int root(int x){
    std::vector<int> update_node_arr;
    while(parent[x] != x){
      update_node_arr.push_back(x);
      x = parent[x];
    }
    for(const auto& it: update_node_arr) parent[it] = x;
    return x;
  }

  bool same(int x, int y){
    return root(x)==root(y);
  }

  long long size(int x){
    return ufsize[root(x)];
  }

  void unite(int x, int y){
    x = root(x);
    y = root(y);
    if(x==y) return;
    long long xsize = size(x);
    long long ysize = size(y);
    if(xsize < ysize){
      parent[x] = y;
      ufsize[y] += xsize;
    }else{
      parent[y] = x;
      ufsize[x] += ysize;
    }
  }
};

int main(){
  long long N,M;
  std::cin >> N >> M;

  std::vector<std::tuple<int, int>> A_arr(M);
  for(long long i = 0; i < M; i++){
    int A,B;
    std::cin >> A >> B;
    A--;
    B--;
    A_arr[i] = std::make_tuple(A,B);
  }

  long long ans = N*(N-1)/2;
  std::vector<long long> ans_arr(1, ans);
  uftree uf(N);

  for(auto&& it=A_arr.rbegin(); it!=A_arr.rend(); ++it){
    int A,B;
    std::tie(A,B) = *it;
    if(!uf.same(A,B)){
      ans -= uf.size(A)*uf.size(B);
      uf.unite(A,B);
    }
    ans_arr.push_back(ans);
  }

  for(auto&& it=ans_arr.rbegin()+1; it!=ans_arr.rend(); ++it){
    std::cout << *it << "\n";
  }

  return 0;
}



Measured memory_bytes: 4212
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.nextLine();
		/* 一文字目がAかつ3-末尾から2文字目にCが1つ。ほかは小文字。 */
		if (s.matches("A[a-z]+C[a-z]+")) {
			System.out.println("AC");
		} else {
			System.out.println("WA");
		}
	}
}

Measured memory_bytes: 23764
#include <iostream>
//#include <vector>
//#include <string>
//#include <algorithm>
//#include <math.h>
//#include <queue>
//#include <stack>
//#include <iomanip>

// sometimes used
//#include <set>
//#include <map>
//#include <numeric>
//#include <list>
//#include <deque>
//#include <unordered_map>

typedef long long LL;
//typedef long double LD;
using namespace std;
 
//#define MOD 1000000007
//#define MAX 100100
//#define NIL -1

int main() {
    LL n;
    cin >> n;
    for(LL i=1; i<=n; i++){
        LL ans=0;
        for(LL x=1; x<i; x++){
            LL tmp0=x*x;
            for(LL y=1; tmp0+x*y+y*y<i; y++){
                LL tmp1=tmp0+x*y+y*y;
                for(LL z=1; tmp1+y*z+z*z+z*x<=i; z++){
                    LL tmp2=tmp1+y*z+z*z+z*x;
                    if(tmp2==i){
                        ans++;
                    }
                }
            }
        }
        cout << ans << endl;
    }

    return 0;
}


Measured memory_bytes: 3620
#include <bits/stdc++.h>
using namespace std; 
using ll = long long;

int main() {
    ll a, b, c, d;
    cin >> a >> b >> c >> d;
    ll p[] = {a*c,a*d,b*c,b*d};
    cout << *max_element(p,p+4); }


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


int main()
{
    double a,b,x;
    cin>>a>>b>>x;

    //cout<<90-atan(a/k) *180.0/3.1416<<endl;
    /*k=(2*x)/(a*b);
    cout<<atan(k/b) *180.0/3.1416<<endl;*/
    if(a*a*b/2<=x)
    {
        double k=(2*(a*a*b-x))/(a*a);
        printf("%.10lf",90-atan(a/k) *180.0/3.1415926535898);
    }
    else
    {
         double k=(2*x)/(a*b);
          printf("%.10lf",90-atan(k/b) *180.0/3.1415926535898);
    }

    return 0;
}


Measured memory_bytes: 256
// https://atcoder.jp/contests/abc172/submissions/14781083

#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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; }

const int mod = 1000000007;
struct mint{
	ll x;
	mint(ll x = 0):x((x%mod+mod)%mod){}
	mint operator-() const{return mint(-x);}
	mint& operator+=(const mint a){
		if((x += a.x) >= mod) x -= mod;
		return *this;
	}
	mint& operator-=(const mint a){
		if((x += mod-a.x) >= mod) x -= mod;
		return *this;
	}
	mint& operator*=(const mint a){
		(x *= a.x) %= mod;
		return *this;
	}
	mint operator+(const mint a) const{
		mint res(*this);
		return res+=a;
	}
	mint operator-(const mint a) const{
		mint res(*this);
		return res-=a;
	}
	mint operator*(const mint a) const{
		mint res(*this);
		return res*=a;
	}
	mint pow(ll t) const{
		if(!t) return 1;
		mint a = pow(t>>1);
		a *= a;
		if(t&1) a *= *this;
		return a;
	}
	mint inv() const{
		return pow(mod-2);
	}
	mint& operator/=(const mint a){
		return (*this) *= a.inv();
	}
	mint operator/(const mint a) const{
		mint res(*this);
		return res/=a;
	}
	bool operator==(const mint a){
		return x == a.x;
	}
};

// 2^n
mint f(int n){
	if(n == 0) return 1;
	mint x = f(n/2);
	x *= x;
	if(n%2 == 1) x *= 2;
	return x;
}

// nCa
mint choose(int n, int a){
	mint x = 1, y = 1;
	rep(i,a){
		x *= n-i;
		y *= i+1;
	}
	return x / y;
}

struct Combination{
	vector<mint> fact, ifact;
	Combination(int n):fact(n+1),ifact(n+1){
		assert(n < mod);
		fact[0] = 1;
		for(int i = 1; i <= n; i++) fact[i] = fact[i-1]*i;
		ifact[n] = fact[n].inv();
		for(int i = n; i >= 1; i--) ifact[i-1] = ifact[i]*i;
	}
	mint operator()(int n, int k){
		if(k < 0 || k > n) return 0;
		return fact[n]*ifact[k]*ifact[n-k];
	}
    mint p(int n, int k){
        return fact[n] * ifact[n-k];
    }
};

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    mint ans = 0;
    Combination comb(1000005);
    rep(i,n+1){
        mint now = comb(n, i);
        now *= comb.p(m, n);
        now *= comb.p(m-i, n-i);
        if(i & 1) now = -now;
        ans += now;
    }
    cout << ans.x << endl;
    return 0;
}


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

using namespace std;

using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for(ll i=0;i<(ll)(n);i++)
#define rep2(i, m, n) for(ll i=m;i<(ll)(n);i++)
#define rrep(i, n, m) for(ll i=n;i>=(ll)(m);i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG

/**
 * For DEBUG
 * https://github.com/ta7uw/cpp-pyprint
 */
#include "cpp-pyprint/pyprint.h"

#endif

void Main() {
    ll N;
    cin >> N;
    ll ans = 1;
    rep(i, N) {
        ans *= i + 1;
        ans %= MOD;
    }
    cout << ans << '\n';
}

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


Measured memory_bytes: 256
import java.util.*;

public class Main {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        long k = sc.nextInt();

        long num = 7;
        if(k==7 || k==1) {
            System.out.println(1);
            return;
        }
        for(int i=2; i<k+2; i++) {
            num *= 10;
            num += 7;
            num %= k;
            if(num == 0) {
                System.out.println(i);
                return;
            }
        }
        System.out.println(-1);

    }


}

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

int main(){
  int N, k;
  cin >> N >> k;
  int d[k];
  set<int> s;
  for(int i=1; i <= N; i++){
    s.insert(i);
  }
  
  for(int i=0; i < k ; i++){
    cin >> d[i];
    for(int j=0; j < d[i]; j++){
      int b; cin >> b;
      s.erase(b);
    }
  }
  cout << s.size() << endl;
}

    

Measured memory_bytes: 3604
# -*- coding: utf-8 -*-
N = int(input())
S1 = tuple(input())
S2 = tuple(input())

domino = []

c = 0
while c < N:
    if S1[c] == S2[c]:
        domino.append(1)
        c += 1
    else:
        domino.append(0)
        c += 2

if domino[0]:
    res = 3
else:
    res = 6

for n in range(1, len(domino)):
    if domino[n]: # 1
        if domino[n-1]: # 1, 0
            res *= 2
    else:
        if domino[n-1]:
            res *= 2
        else:
            res *= 3
     
print(res%1000000007)

Measured memory_bytes: 3064
#include <iostream>
#include <cstdio>
#include <cstdlib>

const int MAX = 250;

int GetParent(int idx)
{
    return idx / 2;
}

int GetLeft(int idx)
{
    return 2 * idx;
}
int GetRight(int idx)
{
    return 2 * idx + 1;
}

void PrintHeap(int *H, int n)
{
    for (int i = 1; i <= n; i++) {
        std::cout << "node " << i << ": key = " << H[i] << ", ";
        int p_i = GetParent(i);
        int l_i = GetLeft(i);
        int r_i = GetRight(i);
        if (p_i != 0) {
            std::cout << "parent key = " << H[p_i] << ", ";
        }
        if (l_i <= n) {
            std::cout << "left key = " << H[l_i] << ", ";
        }
        if (r_i <= n) {
            std::cout << "right key = " << H[r_i] << ", ";
        }
        std::cout << std::endl;
    }
}

int main(int argc, char *argv[])
{
    int H[MAX + 1];
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &H[i+1]);
    }
    PrintHeap(H, n);
}


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

int main(int argc, char const *argv[])
{
	int n, d; cin >> n >> d;
	int k = 2 * d + 1;
	cout << (n + k - 1) / k << endl;
	return 0;
}


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<(int)n;i++)
#define PI acos(-1)
#define fast_io ios_base::sync_with_stdio(false) ; cin.tie(0); cout.tie(0);
ll mod=1e9+7;

int main(){
    fast_io

    double D, T, S;
    cin>>D>>T>>S;

    if(D/S <= T){
        cout<<"Yes"<<endl;
    } else{
        cout<<"No"<<endl;
    }
    return 0;
}


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

int main() {
  string s;
  cin >> s;
  stack<char> st;
  int removed = 0;

  for (int i = 0; i < s.size(); ++i) {
    if (s[i] == 'T') {
      if (!st.empty() && st.top() == 'S') {
        removed += 2;
        st.pop();
      }
    } else {
      st.push(s[i]);
    }
  }

  cout << s.size() - removed << endl;
}

Measured memory_bytes: 640
/*
   О НЕТ! ОНИ ДОГОНЯЮТ!!!
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
*/

#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>
#include <unordered_map>
#include <iomanip>

using namespace std;

typedef long long ll;

mt19937 rnd(228);

int main()
{
#ifdef ONPC
    freopen("a.in", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    vector <int> a(2 * n);
    for (int &c : a)
    {
        scanf("%d", &c);
    }
    sort(a.begin(), a.end());
    int ans = 0;
    for (int i = 0; i < 2 * n; i += 2) ans += a[i];
    printf("%d\n", ans);
}


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

int main(){
  int n;
  cin >>n;
  vector<int> v(n);
  vector<int> c(n);
  
  for(int i=0; i<n;i++){
    cin >>v.at(i);
  }
  
  for(int i=0; i<n;i++){
    cin >>c.at(i);
  }
  int ans = 0;
  for(int i=0; i<n;i++){
    if(v.at(i) - c.at(i) > 0){
      ans += v.at(i) - c.at(i);
    }
  }
  cout<<ans<<endl;
}

Measured memory_bytes: 256
#include<bits/stdc++.h>
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int mod = 1000000007;

int main() {
  int a, b, c, d;
  cin >> a >> b >> c >> d;
  int cnt = 0;
  while(1) {
    if(cnt % 2 == 0) {
      c -= b;
      if(c <= 0) {
        cout << "Yes" << endl;
        return 0;
      }
    } else {
      a -= d;
      if(a <= 0) {
        cout << "No" << endl;
        return 0;
      }
    }
    cnt++;
  }
}

Measured memory_bytes: 3592
#include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>

#define REP(n) for(int i = 0;i < n;i++)
#define LLREP(n) for(long long int  i = 0;i < n;i++)
typedef long long int ll;
using namespace std;
#define MAX_A 1000000005

int main(){

    ll n,mini=MAX_A;
    cin >> n;

    for(ll i = 1;i*i <= n;i++){

        ll mod = n%i;
        ll ans = n/i;

        if(mod != 0){
            continue;
        }

        if(mod == 0){

            if(i > n/i){
                break;
            }

            string str_a,str_b;

            str_a = to_string(i);
            str_b = to_string(ans);

            ll mini_tmp = max(str_a.length(),str_b.length());
            //cout << mini_tmp << endl;
            mini = min(mini,mini_tmp);
        }
        //cout << mini << endl;
    }

    cout << mini << endl;




    return 0;
}

Measured memory_bytes: 256
import copy
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b.append(0)
tmp = copy.copy(b)
ans = 0
for i in range(0, n):
    ans += min(a[i], b[i])
    b[i + 1] += min(max(b[i] - a[i], 0), tmp[i])
ans += min(a[n], b[n])
print(ans)

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

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

typedef long long ll;
using namespace std;
int mod = 1000000007;

int main(void){
    int N; cin >> N; string S; cin >> S;
    string aim = "ABC";
    int cnt = 0;
    for(int i = 0; i <= N-3; i++){
        if(S[i] == 'A' && S[i+1] == 'B' && S[i+2] == 'C'){
            cnt++;
            i += 2;
        }
    }
    cout << cnt << endl;
    return 0;
}

Measured memory_bytes: 256
#include<iostream>
using namespace std;
int main(void){
  string a,b,c;
  cin >> a >> b >> c;
  if(a[a.length() - 1] == b[0] && b[b.length() - 1] == c[0]){
    cout << "YES" << endl;
  }else {
    cout << "NO" << endl;
  }
  return 0;
}


Measured memory_bytes: 256
<?php
error_reporting(0);
$stdin = file_get_contents('php://stdin');
$line = explode("\n",$stdin);
$fi = 0;
$cnt = 0;
$list = array();
$key = new stdclass();
foreach($line as $l) {
  if (strlen($l)==0) continue;
  if ($fi == 0) {
    $a = explode(" ",$l);
    $key->A = $a;
    $fi++;
    continue;
  }
  if ($fi > 0) {
    $a = explode(" ",$l);
    $key->X[] = $a;
  }
}
$K = $key->A[0];
$S = $key->A[1];
$res = array();
$ret = 0;
for($i=0;$i<=$K;$i++) {
  for($j=0;$j<=$K;$j++) {
    $chk = $S-$i-$j;
    if ($chk >= 0 && $chk <= $K) $ret++;
  }
}
printf("%d\n",$ret);


Measured memory_bytes: 3580
//Don't give up too easy bhai
#pragma GCC optimize("O3")
 
#include<bits/stdc++.h>
using namespace std;
 
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
 
#define forall(i,a,n) for(ll i=a;i<n;i++)
#define pb push_back
#define fs first
#define sec second
#define lb lower_bound
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define minv(a) *min_element(all(a))
#define maxv(a) *max_element(all(a))
#define vll vector<ll>
#define vld vector<ld>
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL)
#define mod 1000000007
#define br cout<<"\n"
#define whatis(x) cerr << ">"<<#x << " ==> " << x << endl;
#define inputv(a) forall(i,0,a.size()) cin>>a[i]
#define outputv(a) for(auto i:a) cout<<i<<" ";br;
#define T ll __t;cin>>__t;while(__t--)

void solve()
{
	
}

int main()
{
	fast;

	ll n,x;cin>>n>>x;
	ll a[n];forall(i,0,n) cin>>a[i];
	sort(a,a+n);
	ll ans = accumulate(a,a+x,0ll);
	cout<<ans;


	return 0;
}

Measured memory_bytes: 3652
#pragma warning(disable:4996)
#include <bits/stdc++.h>

using namespace std;

#define FOR(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()

using ll = long long;
using ull = unsigned long long;
using vb = vector<bool>;
using vi = vector<int>;
using vll = vector<ll>;
using vs = vector<string>;
using vvb = vector<vb>;
using vvi = vector<vi>;
using vvll = vector<vll>;

template<typename A, typename T>void assign2d(A&arr, ll H, ll W, T t) { arr.resize(H); REP(i, H) arr[i].assign(W, t); }
template<class T> ostream &operator<<(ostream &os, const vector<T> &v) { int n = v.size(); REP(i, n)os << v[i] << (i == n - 1 ? "" : " "); return os; }
template <class T = int> inline T IN() { T x; cin >> x; return x; }
template<class T> inline void OUT(const T &x) { cout << x << "\n"; }
void YESNO(bool c) { OUT(c ? "YES" : "NO"); };
void YesNo(bool c) { OUT(c ? "Yes" : "No"); };
void yesno(bool c) { OUT(c ? "yes" : "no"); };
struct pre_ { pre_() { cin.tie(nullptr); ios::sync_with_stdio(false); /*cout << fixed << setprecision(6);*/ } } pre__;

int main() {
	int N, M;
	cin >> N >> M;
	vi ANS(N, 0);
	REP(i, M) {
		int A, B;
		cin >> A >> B;
		A--; B--;
		ANS[A]++;
		ANS[B]++;
	}
	REP(i, N) {
		OUT(ANS[i]);
	}
	return 0;
}

Measured memory_bytes: 256