akhauriyash/Code-Regression huggingface dataset:
import java.util.Scanner;

class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		
		int x = x1 - x2;
		int y = y1 - y2;
		
		int x3 = x2 + y;
		int y3 = y2 - x;
		int x4 = x3 + x;
		int y4 = y3 + y;
				
		System.out.println(x3 + " " + y3 + " " + x4 + " " + y4);
	}
}

Measured memory_bytes: 21844
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 +10;
char str[maxn];
int main(){
	scanf("%s",str);
	if((int)strlen(str)<4)return printf("No")&&0;
	if(str[0]=='Y'&&str[1]=='A'&&str[2]=='K'&&str[3]=='I')printf("Yes");
	else printf("No");
	return 0;
}

Measured memory_bytes: 256
//package Atcoder;

import java.util.*;
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer;

public class Main {
	
	static class IO 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public IO() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
	
	public static void main(String[] args) {
		IO fs = new IO();
		int n = fs.nextInt(),t = fs.nextInt();
		int ans = Integer.MAX_VALUE;
		for(int i = 0; i<n; i++) {
			int cost = fs.nextInt(),time = fs.nextInt();
			if(time <= t)ans = Math.min(ans, cost);
		}
		System.out.println(ans == Integer.MAX_VALUE?"TLE":ans);
	}

}


Measured memory_bytes: 25628
#include <stdio.h>

int main(){
	int a,b,c;
	
	scanf("%d %d", &a,&b);
	
	if(a == 1 && b == 2){
		printf("3\n");
	}
	else if(a == 1 && b == 3){
		printf("2\n");
	}
	else if(a == 2 && b == 3){
		printf("1\n");
	}
	else if(a == 3 && b == 2){
		printf("1\n");
	}
		else if(a == 3 && b == 1){
		printf("2\n");
	}
		else if(a == 2 && b == 1){
		printf("3\n");
	}
	return 0;
}

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

int x, y ;

int solve(int x, int y) {
    x = x % y;
    if (x == 0) return y;
    return solve(y, x);
}
int main() {

    cin >> x>> y;
    if ( x < y) swap (x, y);
    cout << solve(x, y) << endl;

    return 0;
}



Measured memory_bytes: 3092
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public long getBalance(int[] A, int L, int R, long[][] memo) {
        // System.out.println(String.format("L: %d, R: %d", L, R));
        if (L == R) {
            return A[L];
        }
        if (memo[L][R] != Long.MIN_VALUE) {
            return memo[L][R];
        }
        long left = A[L] - getBalance(A, L + 1, R, memo);
        long right = A[R] - getBalance(A, L, R - 1, memo);
        long maxHere = Math.max(left, right);
        if (maxHere > memo[L][R]) {
            memo[L][R] = maxHere;
        }
        return memo[L][R];
    }
    public static void main(String[] args)  {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            br.readLine();
          	Main app = new Main();
            String[] split = br.readLine().split(" ");
            int n = split.length;
            int[] A = new int[n];
            for (int i = 0; i < n; i++) {
               A[i] = Integer.parseInt(split[i]); 
            }
            long[][] memo = new long[n + 1][n + 1];
            for (long[] row: memo) {
                Arrays.fill(row, Long.MIN_VALUE);
            }
            long result = app.getBalance(A, 0, n - 1, memo);
            System.out.println(result);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


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


int main(){
    int n;
    double t, a;
    cin >> n >> t >> a;
    int ans = 0;
    double closest = 1000000.0;
    rep(i,n){
        double h;
        cin >> h;
        if(abs(t-h*0.006 -a) < closest){
            closest = abs(t-h*0.006 -a);
            ans = i+1;
        }
    }
    cout << ans << endl;
}


Measured memory_bytes: 256
s = input().split()
if int(s[0])>0 :
    print("Positive")
else :
    if int(s[1])>=0 :
        print("Zero")
    else :
        if (int(s[0])&1)^(int(s[1])&1) :
            print("Positive")
        else :
            print("Negative")

Measured memory_bytes: 3060
line = []
while True:
    b = list(map(int, input().split()))
    if b[0] == 0 and b[1] == 0:
        break
    else:
        line.append(b)
for i in line:
    for j in range(i[0]):
        for k in range(i[1]):
            if j % (i[0]-1) == 0 or k % (i[1]-1) == 0:
                print("#", end ="")
            else:
                print(".", end = "")
        print()
    print()


Measured memory_bytes: 7008
#include<stdio.h>

int main(void)
{
    char buffer[256];
    int w[30], h[30];
    int counter=0;
    
    while(1)
    {
        fgets(buffer, 256, stdin);
        sscanf(buffer, "%d %d", &h[counter], &w[counter]);
        if(h[counter] == 0 && w[counter] == 0) break;
        counter++;
    }
    
    int i, j, k;
    for(i = 0; i < counter; i++)
    {
        for(j = 0; j < h[i]; j++)
        {
            for(k= 0; k < w[i]; k++)
            {
                putchar('#');
            }
            putchar('\n');
        }
        putchar('\n');
    }
    return(0);
}


Measured memory_bytes: 2056
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ld long double

using namespace std;
ll n, t, sum, mx, mn, m, k;

void solve(){
	cin >> n >> m;
	for(int i = 0; i < m; i++)
	{
		cin >> k;
		sum += k;
	}
	if(sum >= n)
	cout << "Yes";
	else cout << "No";
}

int main()
{
	t = 1;
//	cin >> t;
	while(t--){
		solve();
	}
}


Measured memory_bytes: 256
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <utility>
#include <cmath>
#include <climits>
#define REP(i, n) for(int i = 0; i < n; ++i)
#define FOR(i, a, b) for(int i = a; i < b; ++i)
#define F first
#define S second
#define OUT(x) cout << x << "\n"
using namespace std;

int main() {
    int n;
    while (~scanf("%d", &n)) {
        if (n == 0) break;
        double y, r, maxv = LLONG_MIN;
        int b, t, maxid = INT_MAX;

        scanf("%lf", &y);

        REP (i, n) {
            scanf("%d%lf%d", &b, &r, &t);
            double value;
            if (t == 1) {
                value = (1 + y * r / 100);
            } else {
                value = pow(1 + r / 100, y);
            }

            if (maxv <= value) {
                maxv = value;
                maxid = b;
            }
        }

        OUT(maxid);
    }
    return 0;
}




Measured memory_bytes: 3520
import java.util.Scanner;

//Doctor's Strange Particles
public class Main {

	static int[][] m;
	static int[][] tmp;
	static boolean[][] ans;
	static int[][] move = {{0,1},{0,-1},{1,0},{-1,0},{0,0}};
	
	static boolean dfs(int k){
		if(k==10){
			tmp = new int[10][10];
			for(int i=0;i<10;i++){
				if(ans[0][i]){
					for(int j=0;j<5;j++){
						int ni = 0+move[j][0];
						int nj = i+move[j][1];
						if(0<=ni&&ni<10&&0<=nj&&nj<10)tmp[ni][nj]++;
					}
				}
			}
			for(int i=1;i<10;i++){
				for(int j=0;j<10;j++){
					if((tmp[i-1][j]+m[i-1][j])%2==1){
						ans[i][j] = true;
						for(int v=0;v<5;v++){
							int ni = i+move[v][0];
							int nj = j+move[v][1];
							if(0<=ni&&ni<10&&0<=nj&&nj<10)tmp[ni][nj]++;
						}
					}
					else ans[i][j] = false;
				}
			}
			for(int i=0;i<10;i++){
				for(int j=0;j<10;j++){
					if((tmp[i][j]+m[i][j])%2==1)return false;
				}
			}
			return true;
		}
		else{
			ans[0][k] = false;
			if(dfs(k+1))return true;
			ans[0][k] = true;
			return dfs(k+1);
		}
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t--!=0){
			m = new int[10][10];
			ans = new boolean[10][10];
			for(int i=0;i<10;i++)for(int j=0;j<10;j++)m[i][j]=sc.nextInt();
			dfs(0);
			for(int i=0;i<10;i++){
				for(int j=0;j<10;j++){
					if(j>0)System.out.print(" ");
					System.out.print(ans[i][j]?"1":"0");
				}
				System.out.println();
			}
		}
	}
}

Measured memory_bytes: 34396
#include <bits/stdc++.h>
#include <cstdio>
#include <string>

using namespace std;

#define INF 100000000
#define YJ 1145141919
#define INF_INT_MAX 2147483647
#define INF_LL_MAX 9223372036854775807
#define EPS 1e-10
#define MOD 1000000007
#define Pi acos(-1)
#define LL long long
#define ULL unsigned long long
#define LD long double

#define int long long

signed main()
{
    int N, M;
    cin >> N >> M;

    vector<int> mm;
    for(int i = 1; i <= sqrt(M); i++) {
        if(M%i == 0) {
            mm.push_back(i);
            mm.push_back(M/i);
        } 
    }

    sort(begin(mm), end(mm));
    for(int i = 0; i < mm.size(); i++) {
        cerr << mm[i] << endl;
    }
    auto it = upper_bound(begin(mm), end(mm), M/N);
    it--;
    cout << *it << endl;

    return 0;
}

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

using LL = long long int;

class Solution {
public:
    vector<int> solve(int n, vector<int> &a) {
        vector<int> b(n);
        for(int i = 0, left = 0, right = n-1; left <= right; ++ left, -- right, ++ i) {
            b[left] = a[n - 1 - i * 2];
            if(left == right) {
                break;
            }
            b[right] = a[n - 2 - i * 2];
        }
        return b;
    }
};

int main() {
    Solution s;
    int n;
    cin >> n;
    vector<int> a(n);
    for(auto &ai : a) {
        cin >> ai;
    }
    for(auto bi : s.solve(n, a)) {
        cout << bi << ' ';
    }
    cout << endl;
//    auto b = s.solve(n, a);
//    for(int i = 0; i < n; ++ i) {
//        if(i) {
//            cout << ' ';
//        }
//        cout << b[i];
//    }
//    cout << endl;
    return 0;
}


Measured memory_bytes: 3712
#include <iostream>
#include <iomanip>
#include <cmath>

int main(int argc, char *argv[])
{
    int a, b, x;
    double ans;
    double pi = std::acos(-1);

    std::cin >> a >> b >> x;

    // 水平時の水の高さ
    double h = static_cast<double>(x) / (a * a);

    if (h <= static_cast<double>(b) / 2) { //中身があまりないとき
        double dx = static_cast<double>(x) / a / b * 2;
        
        ans = std::atan(b/dx) * 180 / pi;
    } else { //中身が結構あるとき
        double toEdge = static_cast<double>(a) / 2.0;

        ans = std::atan((static_cast<double>(b) - h) / toEdge) * 180 / pi;
    }

    std::cout << std::setprecision(15) << ans << std::endl;

    return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
char s[11];
int main() {
	cin >> s;
	if(s[0]=='Y' && s[1] == 'A' && s[2] == 'K' && s[3] == 'I') puts("Yes");
	else puts("No");
	return 0;
}

Measured memory_bytes: 256
import re,functools as f
@f.lru_cache(None)
def d(n,b):return n<1or sum(d(n-1,b[1:]+s)for s in'ACGT'if not re.match('.AGC|.ACG|.GAC|A.GC|AG.C',b+s))%(10**9+7)
print(d(int(input()),'TTT'))

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

using namespace std;
using ll = long long;

int main() {
    int N, K;
    cin >> N >> K;

    priority_queue<ll> kind[N];
    for (int i = 0; i < N; ++i) {
        int t;
        ll d;
        cin >> t >> d;
        kind[t - 1].push(d);
    }

    priority_queue<ll> best, remain;
    // best: 各種類で一番美味しいやつを集めたもの
    // remain : bestの余り
    for (int i = 0; i < N; ++i) {
        if (!kind[i].empty()) {
            best.push(kind[i].top());
            kind[i].pop();

            while (!kind[i].empty()) {
                remain.push(kind[i].top());
                kind[i].pop();
            }
        }
    }

    vector<ll> bsum = {0};
    // bestの累積和 (bsum[i] = bestの先頭からi個の総和)
    while (!best.empty()) {
        bsum.push_back(bsum.back() + best.top());
        best.pop();
    }

    vector<ll> rsum = {0};
    // remainの累積和
    while (!remain.empty()) {
        rsum.push_back(rsum.back() + remain.top());
        remain.pop();
    }

    ll ans = 0;
    for (ll x = 1; x <= K; ++x) {
        // 種類が多すぎるケース
        if (x >= bsum.size()) break;

        // 種類が少なすぎて、余り物が足りないケース
        if (K - x >= rsum.size()) continue;

        // bestからx個、remainからK-x個貪欲に選ぶ
        ans = max(ans, bsum[x] + rsum[K - x] + x * x);
    }

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


Measured memory_bytes: 8820
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]

t = 0

for a_i in a:
    k = 0
    for i, a_ii in enumerate(a_i):
        k += a_ii * b[i]
    if k + c > 0:
        t += 1

print(t)


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

using namespace std;

#define LCM(a,b)                (a / __gcd(a,b) ) *b
#define GCD(a,b)                __gcd(a,b)
#define dist(x1,y1,x2,y2)       sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))
#define distl(x1,y1,x2,y2)      sqrtl((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))
#define fRead(x)                freopen(x,"r",stdin)
#define fWrite(x)               freopen (x,"w",stdout)
#define LL                      long long
#define ULL                     unsigned long long
#define pb                      push_back
#define tcase                   cout<<"Case "<<C++<<": ";
#define all(a)                  a.begin(),a.end()
#define Unique(a)               sort(all(a)),a.erase(unique(all(a)),a.end
#define ABS(x)                  ((x)<0?-(x):(x))
#define min3(a,b,c)             min(a,min(b,c))
#define min4(a,b,c,d)           min(a,min(b,min(c,d)))
#define max3(a,b,c)             max(a,max(b,c))
#define max4(a,b,c,d)           max(a,max(b,max(c,d)))
#define PI                      acos(-1.0)
#define ff                      first
#define ss                      second
#define SP(x,y)                 fixed<<setprecision((y))<<(x)
#define FastRead                ios_base::sync_with_stdio(0);cin.tie(NULL);
#define FOR(x, l, r)            for (int x = l; x<=r; ++x)
#define REP(x,r)                for (int x = 0; x <r; ++x)
#define NN                      cout<<"\n";
#define NNN                     cout<<"\n------------------------------\n";

//***********************************************************************//
//                      SHAHED AHMED, CSE'15, IUT                        //
//***********************************************************************//


vector<int> ad[222];

vector<int> d[222];

int eg[222][222];
int vis[222];
int dis[222];


void bfs(int curr)
{
    queue<int> q;

    q.push(curr);
    dis[curr]=0;
    vis[curr]=1;
    d[0].pb(curr);

    while(!q.empty())
    {
        int curr=  q.front();
        q.pop();

        for(auto u:ad[curr])
        {
            if(vis[u]) continue;

            vis[u]=1;
            dis[u] = dis[curr]+1;
            d[dis[u]].pb(u);
            q.push(u);
        }
    }

}




int isok()
{
    int k=0;
    int ok=1;
    while(d[k].size())
    {

        for(int i=0;i<d[k].size();i++)
        {
            for(int j=i+1;j<d[k].size();j++)
            {
                if(eg[d[k][i]][d[k][j]])
                {
                    ok=0;
                    break;
                }
            }
        }


        d[k].clear();
        k++;
    }

    if(ok==1) return k;
    return -1;


}

int main()
{
    FastRead
    LL n;

    cin>>n;

    char x;

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>x;
            eg[i][j]=x-'0';
            if(x=='1')
            {
                ad[i].pb(j);
            }
        }

    }

    int ans=-1;
    for(int i=1;i<=n;i++)
    {
        bfs(i);
        ans=max(ans, isok());
        memset(vis,0,sizeof vis);
    }

    cout<<ans;



}


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

int main() {
    int n, a, b;
    cin >> n >> a >> b;
    
    int ans = 0;
    int count = 0;
    for (int i=0; i<=n; ++i) {
        int sum = 0;
        string s = to_string(i);
        //sum a character of integer
        for (int j=0; j<s.size(); ++j) {
            string tmp;
            tmp = s[j];
            sum += stoi(tmp);
        }
        if (a <= sum && sum <= b) ans += i;
        
    }

    cout << ans << endl;

    return 0;
}



Measured memory_bytes: 256
#include<stdio.h>
#include<iostream>
#include<string>
#include<math.h>
#include<cmath>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<time.h>
#include<ctime>
#include<functional>
#define int long long
#define INT INT_MAX
#define LONG LLONG_MAX
#define f(i,n) for(int i=0;i<(n);i++)
#define P pair<int,int>
typedef long long ll;
using namespace std;

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

ll LCM(ll a, ll b) {
	return a / GCD(a, b)*b;
}

ll mypow(ll a, ll b, ll c) {
	if (b == 0)return 1;
	if (b % 2)return mypow(a, b - 1, c)*a%c;
	else return mypow(a, b / 2, c)*mypow(a, b / 2, c) % c;
}

signed main() {
	int a, b, x;
	cin >> a >> b;
	char c;
	f(i, a) {
		f(j, b) {
			cin >> c;
			if (c == '#') x++;
		}
	}
	if (x == a + b - 1) puts("Possible");
	else puts("Impossible");
	return 0;
}

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

using namespace std;

using ll = int_fast64_t;
constexpr ll llmax = INT_FAST64_MAX; // std::numeric_limits<int_fast64_t>::max()
constexpr ll llmin = INT_FAST64_MIN; // std::numeric_limits<int_fast64_t>::min()
using ull = uint_fast64_t;
constexpr ull ullmax = UINT_FAST64_MAX; // std::numeric_limits<uint_fast64_t>::max()

#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define RFOR(i, b, e) for (int i = ((e) - 1); (b) <= i; --i)
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define RREP(i, N) for (int i = ((N) - 1); 0 <= i; --i)
#define scanInt(x) int x; scanf("%d", &(x)); getchar();
#define scanLLInt(x) ll x; scanf("%lld", &(x)); getchar();
#define scanVecInt(A, N) vector<int> A(N); REP(i, N){scanf("%d", &(A[i])); getchar();}
#define scanVecLLInt(A, N) vector<ll> A(N); REP(i, N){scanf("%lld", &(A[i])); getchar();}

int main()
{
    scanInt(N);
    scanInt(K);
    const int K_max = (N - 1) * (N - 2) / 2;
    if (K_max < K){
        cout << "-1" << endl;
        return 0;
    }
    vector<pair<int, int>> edges;
    FOR(i, 1, N){
        edges.emplace_back(0, i);
    }
    int K_count = K_max;
    REP(a, N - 2){
        if (K_count == K) break;
        FOR(b, a, N - 2){
            if (K_count == K) break;
            edges.emplace_back(a + 1, b + 2);
            --K_count;
        }
    }
    cout << edges.size() << endl;
    for (auto& e : edges){
        cout << (e.first + 1) << " " << (e.second + 1) << endl;
    }
}


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

int main() {
    string S, T;
    cin >> S;
    cin >> T;
    
    int N = S.size();
    int M = T.size();
    int max = 0;

    if (N == M) {
        for (int i = 0; i < N; i++) {
            if (T.at(i) == S.at(i)) {
                max++;
            }
        }
        cout << M - max << endl;
        return 0;
    }

    for (int i = 0; i < N - M; i++) {
        int count = 0;
        for (int j = 0; j < M; j++) {
            if (T.at(j) == S.at(i + j)) {
                count++;
            }
        }
        if (count > max) {
            max = count;
        }
    }
    cout << M - max << endl;
}

Measured memory_bytes: 3568
def f(h, w):
    t = [input() for _ in range(h)]
    U = [[0] * (w + 2) for _ in range(h + 2)]
    D = [[0] * (w + 2) for _ in range(h + 2)]
    L = [[0] * (w + 2) for _ in range(h + 2)]
    R = [[0] * (w + 2) for _ in range(h + 2)]
    ans = 0
    Ui1 = U[0]
    for i in range(1, 1 + h):
        Ui = U[i]
        Li = L[i]
        ti1 = t[i - 1]
        for j, tk in enumerate(ti1):
            j += 1
            if tk == "#":
                Ui[j] = 0
                Li[j] = 0
            else:
                Ui[j] = Ui1[j] + 1
                Li[j] = Li[j - 1] + 1
        Ui1 = Ui
        Di1 = D[-1]
    for i in range(h, 0, -1):
        Ui = U[i]
        Li = L[i]
        Di = D[i]
        Ri = R[i]
        ti1 = t[i - 1]
        for j in range(w, 0, -1):
            if ti1[j - 1] == "#":
                Di[j] = 0
                Ri[j] = 0
            else:
                Di[j] = Di1[j] + 1
                Ri[j] = Ri[j + 1] + 1
                tmp = Ui[j] + Di[j] + Li[j] + Ri[j]
                if tmp > ans:
                    ans = tmp
        Di1 = Di
    print(ans - 3)

h, w = map(int, input().split())
f(h, w)


Measured memory_bytes: 178308
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO ?????????????????????????????????????????????
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		while(true){
			String tmp = br.readLine();

			if(tmp == null){
				break;
			}

			String[] tmpArray = tmp.split(" ");
			double[] input = new double[6];
			double[] reverse = new double[6];

			for(int i = 0; i < 6 ; i++){
				input[i] = Double.parseDouble(tmpArray[i]);
				reverse[(i + 3) % 6] = input[i];
			}
			
			//??????a = 0???????????????????????\????????????
			if(input[0] == 0){
				for(int i = 0; i < 6; i++){
					input[i] = reverse[i];
				}
			}
			
			//????????§??????????????¬?????¢?????????????????¨?????????
			double k = input[3]/input[0];
			input[3] = 0;
			input[4] -= input[1]*k;
			input[5] -= input[2]*k;

			//?????????????????????
			/*
			for(int i = 0; i < 6; i++){
				System.out.print(input[i]+" ");
				if(i == 2 || i==5){
					System.out.println();
				}
			}*/

			double k2 = input[4];
			input[4] = 1;
			input[5] /= k2;

			//?????????????????????
			/*
			for(int i = 0; i < 6; i++){
				System.out.print(input[i]+" ");
				if(i == 2 || i==5){
					System.out.println();
				}
			}*/
			
			double k3 = input[1];
			input[1] = 0;
			input[2] -= input[5]*k3;

			//?????????????????????
			/*
			for(int i = 0; i < 6; i++){
				System.out.print(input[i]+" ");
				if(i == 2 || i==5){
					System.out.println();
				}
			}*/
			
			input[2] /= input[0];
			input[0] = 1;
			
			//System.out.println(input[2] + " " + input[5]);
			System.out.printf("%.3f %.3f\n", input[2], input[5]);
		}
	}

}

Measured memory_bytes: 24740
#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<ll, ll> 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; }

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    rep(i,3)rep(j,3){
        char c;
        cin >> c;
        if(i == j) cout << c;
    }
    cout << endl;
	return 0;
}

Measured memory_bytes: 256
#include "bits/stdc++.h"
#define rep(i,n) for(int i=0;i<n;i++)
#define ALL(v) (v).begin(),(v).end()
typedef long long LL;
const int INF = 1 << 25;
const LL MOD = 1000000007LL;
using namespace std;
typedef pair<int, int> P;
int A[100000];
int main() {
	int N, T;
	cin >> N >> T;
	rep(i, N) cin >> A[i];
	int max_d = 0;
	int min_A = A[0];
	for (int i = 1; i < N; i++) {
		if (A[i] > min_A) max_d = max(max_d, A[i] - min_A);
		min_A = min(min_A, A[i]);
	}
	min_A = A[0];
	int ans = 0;
	for (int i = 1; i < N; i++) {
		if (A[i] - min_A == max_d) ans++;
		min_A = min(min_A, A[i]);
	}
	cout << ans << endl;
}

Measured memory_bytes: 640
#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    int h[n];
    for(int i=0;i<n;i++)
    cin>>h[i];
    int cost[n];
    cost[0]=0;cost[1]=abs(h[1]-h[0]);
    for(int i=2;i<n;i++)
    {
        int a,b;
        a=abs(h[i]-h[i-1])+cost[i-1];
        b=abs(h[i]-h[i-2])+cost[i-2];
        cost[i]=min(a,b);
    }
    cout<<cost[n-1]<<endl;
    return 0;
}

Measured memory_bytes: 1024
n=int(input())

ans =0
for i in range(2,int(n**0.5)+5):
    cnt = 0
    while n%i==0:
        n//=i
        cnt += 1
    s=1
    while cnt-s>=0:
        cnt -= s
        s +=1
        ans += 1
if n!=1:ans+=1
print(ans)


Measured memory_bytes: 63764
package main

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

func main() {
	scanner := makeWordScanner()
	n := eGetInt(scanner)
	k := eGetInt(scanner)
	count := 0
	for n > 0 {
		n /= k
		count++
	}
	fmt.Println(count)
}

////////////////////////////////////////////////////////////////////////////////
// ライブラリ
////////////////////////////////////////////////////////////////////////////////
func makeScanner(maxByte int) *bufio.Scanner {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]uint8, 0, 8192), maxByte)
	return scanner
}
func makeCharScanner() *bufio.Scanner {
	scanner := makeScanner(8192)
	scanner.Split(bufio.ScanRunes)
	return scanner
}
func makeWordScanner() *bufio.Scanner {
	scanner := makeScanner(8192)
	scanner.Split(bufio.ScanWords)
	return scanner
}
func eGetLine(r *bufio.Scanner) string {
	if r.Scan() {
		return r.Text()
	}
	err := r.Err()
	if err != nil {
		log.Fatal(err)
	}
	// EOF
	return ""
}
func eGetInt(r *bufio.Scanner) int {
	line := eGetLine(r)
	return eAtoi(line)
}
func eGetInt64(r *bufio.Scanner) int64 {
	line := eGetLine(r)
	return eAtoInt64(line)
}
func eGetFields(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Fields(line)
}
func eGetInts(r *bufio.Scanner) []int {
	fields := eGetFields(r)
	ints := make([]int, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoi(fields[i])
	}
	return ints
}
func eGetInt64s(r *bufio.Scanner) []int64 {
	fields := eGetFields(r)
	ints := make([]int64, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoInt64(fields[i])
	}
	return ints
}
func eGetChars(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Split(line, "")
}
func eAtoi(s string) int {
	n, err := strconv.Atoi(s)
	if err != nil {
		log.Fatal(err)
	}
	return n
}
func eAtoInt64(s string) int64 {
	n, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		log.Fatal(err)
	}
	return n
}
func pow(a, n int) int {
	return int(math.Pow(float64(a), float64(n)))
}
func countBitOfOn(i, numbits int) int {
	count := 0
	var bit uint64
	for bit = 0; bit < uint64(numbits); bit++ {
		t := 1 << bit
		if i&t > 0 {
			count++
		}
	}
	return count
}


Measured memory_bytes: 640
#include <iostream>
#include <string>
#include <cmath>
#include <ctime>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;

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

    for(int i = 0; i < s.size(); i += 2){
        cout << s[i];
    }

    cout << endl;

}

Measured memory_bytes: 512
#include <bits/stdc++.h>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define REP(i,n) for(int i=0;i<n;i++)
#define FOR(i,n1,n2) for(int i=n1;i<n2;i++)
#define bFOR(i,n1,n2) for(int i=n1;i>=n2;i--)
#define speed_up    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

typedef long long int ll;
typedef pair<ll,ll> Pi;
const int INF=(ll)(1LL<<30)-1;
const double INFd=100000000000.0;
const ll INFl=(ll)9223372036854775807;
const int MAX=10000;
const ll MOD=(ll)1e9+7;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a, b)*b;}
int dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};

template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
    std::fill( (T*)array, (T*)(array+N), val );
}

int n,r,l;
int a[55];

int main(){
	while(1){
		cin>>n>>l>>r;
		if(n==0&&l==0&&r==0)break;
		REP(i,n)cin>>a[i];
		int ans=0;
		for(int i=l;i<r+1;i++){
			for(int j=0;j<n;j++){
				if(i%a[j]==0){
					if(j%2==0){
						ans++;
					}
					break;
				}
				if(j==n-1){
					if(n%2==0)ans++;
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}


Measured memory_bytes: 3084
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

use std::cmp::{max, min};
use std::collections::BTreeMap;
use std::collections::BinaryHeap;

fn main() {
  let n = read::<i64>();
  let m = read::<i64>();
  // let mut map: BTreeMap<i64, BinaryHeap<i64>> = BTreeMap::new();
  let mut vec = vec![];

  for _ in 0..n {
    let a = read::<i64>();
    let b = read::<i64>();
    vec.push(vec![a, b]);
  }

  vec.sort_by(|a, b| a[0].cmp(&b[0]));
  let mut q = BinaryHeap::new();
  let mut idx = 0;
  let mut ans = 0;

  for k in 1..m + 1 {
    while idx < n && vec[idx as usize][0] <= k {
      q.push(vec[idx as usize][1]);
      idx += 1;
    }

    ans += match q.pop() {
      Some(b) => b,
      _ => 0,
    };

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

}



Measured memory_bytes: 10232
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) 
{ 
    if (b == 0) return a; 
    return gcd(b, a % b);  
} 
int main()
{
	int x;
  	cin>>x;
  	cout<<360/gcd(360,x)<<endl;
}
      	

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

using ll = long long int;

ll n, m;

ll ans;

int main(void) {
  // Here your code !
  scanf("%lld %lld", &n, &m);

  if (n == 1 && m == 1) ans = 1;
  else if (n == 1 && m > 1) ans = (m - 2);
  else if (n > 1 && m == 1) ans = (n - 2);
  else ans = (n - 2) * (m - 2);

  printf("%lld\n", ans);

	return 0;
}


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

void solve() {

    int a, b, c, k;
    cin >> a >> b >> c >> k;
    int ans = 0;
    ans += min(k, a);
    k -= min(k, a);
    k -= min(k, b);
    ans -= min(k, c);
    cout << ans << endl;

}

int main(){

    solve();
	return 0;
}


Measured memory_bytes: 3624
#include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>
#include <algorithm>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
using namespace std;
const int N = 2e5 + 5;

int main()
{
    int n;
    cin >> n;
    int a[100001];
    for (int x = 1; x < 101; ++x)
    {
        for (int y = 1; y < 101; ++y)
        {
            for (int z = 1; z < 101; ++z)
            {
                ll sum = (x * x) + (y * y) + (z * z) + (x * y) + (y * z) + (z * x);
                if (sum <= n)
                {
                    a[sum]++;
                }
            }
        }
    }
    for (int i = 1; i < n + 1; ++i)
    {
        cout << a[i] << endl;
    }
}

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

int Binary_Search(int kye,int a[],int n);

const int NOT_FOUND=-1;

int main(){
  int n,q;
  int s[100001];
  int t[50001];
  cin>>n;
  for(int i=0;i<n;i++){
    cin>>s[i];
  }
  cin>>q;
  for(int i=0;i<q;i++){
    cin>>t[i];
  }
  int ans=0;
  for(int i=0;i<q;i++){
    if(Binary_Search(t[i],s,n)!=NOT_FOUND)ans++;
  }
  cout<<ans<<endl;
}

int Binary_Search(int kye,int a[],int n){
  int left,right,mid;
  left=0;
  right=n;
  while(left<right){
    mid=(left+right)/2;
    if(a[mid]==kye)return mid;
    else if(a[mid]<kye)left=mid+1;
    else if(a[mid]>kye)right=mid;
  }
  return NOT_FOUND;
}
  

Measured memory_bytes: 1744
module Main where

import Data.List
import Control.Monad
import Debug.Trace
import qualified Data.ByteString.Char8 as BC
import Data.Maybe (fromJust)

import qualified Data.Map.Strict as M
import Control.Arrow ((>>>))
import Data.Monoid (mconcat)

newtype PQ a =  PQ {getPQ :: M.Map a Int}

enqueuePQ :: Ord a => a -> PQ a -> PQ a
enqueuePQ a = PQ . M.alter (Just . maybe 1 (+1)) a . getPQ

dequeuePQ :: Ord a => PQ a -> (Maybe a, PQ a)
dequeuePQ (PQ pq) = 
    if pq == M.empty then (Nothing, PQ M.empty)
    else
        let
            maxVal = fst $ M.findMax pq
            newPQ = M.alter (>>= (subtract  1 >>> \n -> if n > 0 then Just n else Nothing)) maxVal pq
        in
            (Just maxVal, PQ newPQ)

modifyFirst :: Ord a => (a -> a) -> PQ a -> PQ a
modifyFirst f pq = let
    (maxVal, newPQ) = dequeuePQ pq
    in
        case maxVal of 
            Just n -> enqueuePQ (f n) newPQ
            Nothing -> pq

fromListPQ :: Ord a => [a] -> PQ a
fromListPQ = foldr enqueuePQ emptyPQ

emptyPQ :: Ord a => PQ a
emptyPQ = PQ M.empty


toListPQ :: Ord a => PQ a -> [a]
toListPQ pq = let
    (mayVal, newPQ) = dequeuePQ pq
    in
        case mayVal of
            Nothing -> []
            Just v -> v : toListPQ newPQ

readTuple2 :: IO (Int, Int)
readTuple2 = do
    [a, b] <- map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine
    return (a, b)

readTuple3 :: IO (Int, Int, Int)
readTuple3 = do
    [a, b, c] <- map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine
    return (a, b, c)

readInt :: IO Int
readInt = fst . fromJust . BC.readInt <$> BC.getLine

readInts :: IO [Int]
readInts = map (fst . fromJust . BC.readInt) . BC.words <$> BC.getLine

split :: (a -> Bool) -> [a] -> [[a]]
split f [] = []
split f as = let
    (fo, la) = span f as
    las = case la of
        [] -> []
        xs -> split f $ tail xs
    in
        case fo of
            [] -> las
            xs -> xs : las

solve :: [Int] -> Int -> Int
solve as waribiki = let
    pq = fromListPQ as
    pq' = foldr (\_ q -> modifyFirst (`div` 2) q) pq [1..waribiki]
    in
        sum $ toListPQ pq'

main = do
    (n, m) <- readTuple2
    as <- readInts
    print $ solve as m


Measured memory_bytes: 38268
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef set<int> si;
typedef pair<int,int> pii;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define per(i,a,b) for(int i=(b)-1; i>=(a); --i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define F first
#define S second
const int INF = 987654321;
const ll MOD = 1000000007;
//const long double PI = (acos(-1));
//const long double EPS = 0.0000000001;
int dy[2] = {0, 0};
int dx[2] = {-1, 1};

int main(void) {
	ios_base::sync_with_stdio(false); 
	cin.tie(NULL); 
	cout.tie(NULL);
	//freopen("in.txt", "r", stdin);
	string s;
	cin >> s;
	if(s == "SAT") {
		cout << 1 << endl;
	} else if(s == "FRI") {
		cout << 2 << endl;
	} else if(s == "THU") {
		cout << 3 << endl;
	} else if(s == "WED") {
		cout << 4 << endl;
	} else if(s == "TUE") {
		cout << 5 << endl;
	} else if(s == "MON") {
		cout << 6 << endl;
	} else if(s == "SUN") {
		cout << 7 << endl;
	}
	return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define llint int64_t
#define MAXN 200002

void solve() {
    llint a, b, c = 0;
    cin >> a >> b;
    for (llint e = a; e <= b; e *= 2) {
        c += 1;
    }
    cout << c << "\n";
}

int main() {
//    freopen("main.in", "r", stdin);
    ios::sync_with_stdio(0);
    solve();
}

Measured memory_bytes: 256
N,K = map(int,input().split())

import math
ss = pow(10,9)+7
for i in range(1,K+1):
    if(N-K-i+1 == 0):
        print((math.factorial(K-1)//(math.factorial(K-i)*math.factorial(i-1)))%ss)
    elif(N-K-i+1 < 0):
        print(0)
    else:
        print(((math.factorial(K-1)*math.factorial(N-K+1))//(math.factorial(i)*math.factorial(N-K-i+1)*math.factorial(K-i)*math.factorial(i-1)))%ss)
        

Measured memory_bytes: 3316
n = int(input())

ans = n
for i in range(1, n//2+1):
    A = str(i)
    B = str(n-i)
    c = 0
    for a in A:
        c += int(a)
    for b in B:
        c += int(b)
    ans = min(ans, c)
print(ans)


Measured memory_bytes: 3060
using System;

class Pg
{
    static void WhileInt(Action<int> action) { int n; while (int.TryParse(Console.ReadLine(), out n)) { action(n); } }
    static void Main() => new Pg().Run();
    void Run()
    {
        var cnt = new Count();
        WhileInt(sum=> Console.WriteLine(cnt.Comb(sum, 4)));
    }
}
class Count
{
    static void Repeat(int n, Action<int> action) { for (var i = 0; i <= n; ++i) { action(i); } }
    const int MAX = 9;
    internal int Comb(int targetNum, int paramNum)
    {
        if (targetNum > paramNum * MAX || paramNum == 0 || targetNum < 0)
            return 0;

        if (targetNum == 0 || paramNum == 1)
            return 1;

        int sum = 0;
        Repeat(MAX, i => sum += Comb(targetNum - i, paramNum - 1));
        return sum;
    }
}


Measured memory_bytes: 15980
def main():
    n=int(input())
    l=list(map(int,input().split()))
    ans=0
    for i in range(n):
        for k in range(i+1,n):
            for j in range(k+1,n):
                temp=[l[i],l[k],l[j]]
                if len(set(temp))==len(temp):
                    temp.sort()
                    if temp[0]+temp[1]>temp[2]:
                        ans+=1
    print(ans)
if __name__ == "__main__":
    main()

Measured memory_bytes: 68148
#include<bits/stdc++.h>
#define vi vector<int>
#define vvi vector<vector<int> >
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
using ll = long long;
using ld =long double;
//#define int ll
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define all(in) in.begin(), in.end()
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<int,pii> piii;
#define mp make_pair
signed main(){
    int n,Y;cin>>n>>Y;
    rep(x,2001)rep(y,2001){
        int z=n-x-y;
        if(z<0||x+y+z!=n)continue;
        if(10000*x+5000*y+1000*z==Y){
            cout<<x<<" "<<y<<" "<<z<<endl;
            return 0;
        }
    }
    cout<<"-1 -1 -1"<<endl;
}


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

using namespace std;

typedef long long ll;
typedef vector<int> pi;
typedef pair<int,int> vi;

#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i=a; i < b; i++)


int main() {
	int N;
	cin >> N;
	int result = 0;
	while(N != 1){
		N = N >> 1;
		++result;
	}
	cout << pow(2, result) << "\n";
}


Measured memory_bytes: 256
import sys
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

N = int(input())
if N == 1:
    print(0)
    sys.exit()
a = factorization(N)
ans = 0

for i in range(len(a)):
    k = a[i][1]
    cnt = 1
    while k-cnt>=0:
        k -= cnt
        cnt += 1
    ans += cnt-1
    
    
print(ans)

Measured memory_bytes: 9416
#include <stdio.h>
int main(){
    int n;
    scanf("%d",&n);
    int b[n-1];
    for(int c=0;c<n-1;c++){scanf("%d",&b[c]);}
    int a[n];
    a[0]=b[0];
    for(int d=0;d<n-1;d++){
        if(b[d]>b[d+1]){a[d+1]=b[d+1];}
        else{
        if(a[d]!=b[d]){a[d+1]=b[d];}
        else if(a[d]==b[d]){a[d+1]=a[d];}
        else{}}
    }
    if(a[n-2]!=b[n-2]){a[n-1]=b[n-2];}
    else{a[n-1]=a[n-2];}
    int sum;
    sum=0;
    for(int e=0;e<n;e++){
        sum+=a[e];
    }
    printf("%d\n",sum);
    return 0;
}

Measured memory_bytes: 128
#pragma region
#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define debug(x) cerr << #x << ": " << x << '\n'
#define INF 1e9
using namespace std;
template <class T = int>
T in() {
  T x;
  cin >> x;
  return (x);
}

typedef long long ll;
template <class T>
bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}

#pragma endregion

int main() {
  int a = in(), b = in(), c = in(), x = in(), y = in();

  ll min = INF;
  min = a * x + b * y;
  ll tmp, tmp2;
  if (x > y) {
    tmp = 2 * c * y + (x - y) * a;
    tmp2 = 2 * c * x;
    chmin(tmp, tmp2);
  } else if (x == y) {
    tmp = 2 * c * x;
  } else {
    tmp = 2 * c * x + (y - x) * b;
    tmp2 = 2 * c * y;
    chmin(tmp, tmp2);
  }
  chmin(min, tmp);

  cout << min << endl;
  return 0;
}


Measured memory_bytes: 256
package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"

)


func main() {
	solve(os.Stdin, os.Stdout)
}

type ReaderEx struct {
	baseScanner *bufio.Scanner
	words       []string
	nextWordIdx func() int
	initWordIdx func(int)
}

func NewScannerEx(stdin io.Reader) *ReaderEx {
	var this ReaderEx
	var idx int
	var wordsCnt int
	this.baseScanner = bufio.NewScanner(stdin)
	this.baseScanner.Buffer(make([]byte, 0), 1E+11)
	this.nextWordIdx = func() int {
		cur := idx
		idx = (idx + 1) % wordsCnt
		return cur
	}
	this.initWordIdx = func(wc int) {
		idx = 0
		wordsCnt = wc
	}
	return &this
}

func (me *ReaderEx) Scan(doSplit bool) (isScanned bool) {
	isScanned = me.baseScanner.Scan()
	if doSplit {
		me.words = strings.Fields(me.baseScanner.Text())
	} else {
		me.words = []string{me.baseScanner.Text()}
	}
	me.initWordIdx(len(me.words))
	return
}

func (me *ReaderEx) nextBytes() []byte {
	return []byte(me.words[me.nextWordIdx()])
}
func (me *ReaderEx) nextString() string {
	return me.words[me.nextWordIdx()]
}

type StringArray []string

func (me *ReaderEx) nextStringArray() StringArray {
	return me.words[me.nextWordIdx():]
}

func (me StringArray) toStrings() []string {
	return me
}

func (me StringArray) toInts() []int {
	strValues := me.toStrings()
	values := make([]int, len(strValues))
	for i, v := range strValues {
		n, err := strconv.Atoi(v)
		if err != nil {
			panic(err)
		}
		values[i] = n
	}
	return values
}
func (me *ReaderEx) nextInt() int {
	n, err := strconv.Atoi(me.words[me.nextWordIdx()])

	defer func() {
		if err != nil {
			panic(fmt.Sprintf("getInt(%d)", n))
		}
	}()
	return n
}

func pow(x, y, mod int) (ans int) {

	ans = 1
	for bit := 1 << uint(math.Floor(math.Log2(float64(y)))); ; bit >>= 1 {
		if y&bit != 0 {
			ans *= x
			if mod > 0 {
				ans %= mod
			}
		}
		if bit <= 1 {
			return
		}
		ans *= ans
		if mod > 0 {
			ans %= mod
		}
	}
}

type factType struct {
	prime int
	count int
}

func fact(n int) (facts []*factType) {

	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			fa := factType{prime: i}
			for n%fa.prime == 0 {
				n /= fa.prime
				fa.count++
			}
			facts = append(facts, &fa)
		}
	}
	if n > 1 {
		facts = append(facts, &factType{prime: n, count: 1})
	}
	return facts
}
func dec2bin(n int) (ret []bool) {
	for bit := 1 << uint(math.Floor(math.Log2(float64(n)))); ; bit >>= 1 {
		ret = append(ret, n&bit != 0)

		if bit <= 1 {
			return
		}
	}

}

func abs(v int) int {
	if v < 0 {
		v = -v
	}
	return v
}

func b2i(b bool) (i int) {
	if b {
		i = 1
	} else {
		i = 0
	}
	return
}

func solve(stdin io.Reader, stdout io.Writer) {

	r := NewScannerEx(stdin)
	r.Scan(true)
	n, m := r.nextInt(), r.nextInt()

	fmt.Fprintln(stdout, []string{"No", "Yes"}[b2i(m >= n)])
}


Measured memory_bytes: 640
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
  long long n, a;
  vector<long long> v;
  
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> a;
    v.push_back(a);

  }
  vector<long long>::iterator it = v.begin();
  vector<long long>::iterator it_end = v.end();

  while (it != it_end) {
    if (*it % 2 != 0) {
      cout << "first" << endl;
      return 0;
    }
    it++;
  }

  cout << "second" << endl;

  return 0;
}

    
  


Measured memory_bytes: 1528
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
import bisect
mod=10**9+7
a.sort()
b.sort()
ans=1
flag=True
if len(set(a))!=n or len(set(b))!=m:
    flag=False
    print(0)
def find(X,lists):
    return bisect.bisect_right(lists,X)!=bisect.bisect_left(lists,X)
    
if flag:
    for i in range(n*m,0,-1):
        #n*m-i+1番目の値をたす.
        if find(i,a):
            if find(i,b):
                pass    
            else:
                ans*=(m-bisect.bisect_left(b,i))
                ans=ans%mod
            
        else:
            if find(i,b):
                ans*=(n-bisect.bisect_right(a,i))
                ans=ans%mod
                
            else:
                ans*=((n-bisect.bisect_left(a,i))*(m-bisect.bisect_left(b,i))-(n*m-i))
                ans=ans%mod
    print(ans)             



Measured memory_bytes: 47880
import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

def combination(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

sys.setrecursionlimit(10000)

mod = 1000000007

"""
# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]

# 標準入力取得
## 文字列
    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())

## 数値
    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき
"""

if __name__ == "__main__":
    N = 10
    H, W = map(int, sys.stdin.readline().split())
    C = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]  # 二次元配列入力　二次元マップみたいな入力のとき
    A = [list(map(int,list(sys.stdin.readline().split()))) for i in range(H)]  # 二次元配列入力　二次元マップみたいな入力のとき

    for k in range(N):
        for i in range(N):
            for j in range(N):
                if C[i][j] > C[i][k] + C[k][j]:
                    C[i][j] = C[i][k] + C[k][j]

    ans = 0
    for h in range(H):
        for w in range(W):
            x = A[h][w]
            if x != -1:
                ans += C[x][1]
    print(ans)



Measured memory_bytes: 63064
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n, c, k; cin >> n >> c >> k;
    int t[n];
    for (int i = 0; i < n; ++i) {
        cin >> t[i];
    }
    sort(t, t + n);
    /*
    for (int i = 0; i < n; ++i) {
        cout << t[i] << " ";
        if (i == n - 1) cout << endl;
    }
     */
    int cnt = 1;
    int ans = 1;
    int st = t[0];
    for (int i = 1; i < n; ++i) {
        if (t[i] - st > k) { //time out
            cnt = 1;
            st = t[i];
            ans++;
            //cout << i << " " << cnt << endl;
            continue;
        }
        if (cnt < c) {
            cnt++;
        } else { //定員over
            cnt = 1;
            st = t[i];
            ans++;
            //cout << i << " " << cnt << endl;
            continue;
        }
        //cout << i << " " << cnt << endl;
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 640