akhauriyash/Code-Regression huggingface dataset:
import java.util.*; import java.io.*; import java.math.*;
public class Main{
	//Don't have to see. start------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<String>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			try{
				while((read = br.readLine()) != null){
					inputLine.add(read);
				}
			}catch(IOException e){}
			max = inputLine.size();
		}
		boolean hasNext(){return (index < max);}
		String next(){
			if(hasNext()){
				return inputLine.get(index++);
			}else{
				throw new IndexOutOfBoundsException("There is no more input");
			}
		}
	}
	static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	static PrintWriter out = new PrintWriter(System.out);
	static void flush(){out.flush();}
	static void myout(Object t){out.println(t);}
	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
	static String next(){return ii.next();}
	static boolean hasNext(){return ii.hasNext();}
	static int nextInt(){return Integer.parseInt(next());}
	static long nextLong(){return Long.parseLong(next());}
	static double nextDouble(){return Double.parseDouble(next());}
	static ArrayList<String> nextStrArray(){return myconv(next(), 8);}
	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<Integer> nextIntArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Integer.parseInt(input.get(i)));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Long> ret = new ArrayList<Long>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Long.parseLong(input.get(i)));
		}
		return ret;
	}
	static String myconv(Object list, int no){//only join
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof ArrayList){
			return String.join(joinString, (ArrayList)list);
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//Don't have to see. end------------------------------------------
	static void solve(){//Here is the main function
		ArrayList<Integer> one = nextIntArray();
		int N = one.get(0);
		int D = one.get(1);
		int bD = D * 2 + 1;
		myout((N + bD - 1) / bD);
	}
	//Method addition frame start




	//Method addition frame end
}


Measured memory_bytes: 32716
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,j,k) for(int i=j;i<k;i++)
#define FORD(i,j,k) for(int i=j;i>=k;i--)
#define ll long long
#define ull unsigned long long int
#define ld long double
//Make sure no overflow problems
#define pii  pair<int, int>
#define vi vector<int >
#define pb push_back
#define mp make_pair
#define endl '\n'
#define x first
#define y second
#define VAR(i,n) __typeof(n) i = (n)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();i++)
#define FORDEACH(i,c) for( VAR(i,(c).rbegin()),i!=(c).rend();i++)
#define REP(i,n) FOR(i,0,n)
#define mod 1000000007
#define MEM(a, b) memset(a, (b), sizeof(a))
#define addmod(a,b,mod) (a%mod + b%mod)%mod
#define submod(a,b,mod) (a%mod - b%mod + mod)%mod
//const long long INFLL = (ll)INF * (ll)INF;
const ld EPS = 10e-9;
const int MAX = 1e6;

string solve(string s, string t, int i){
    string temp = s;
    int idx = 0;
    FOR(j,i,i + t.size()){
        if(s[j] == '?')
            temp[j] = t[idx];
        else if(s[j] != t[idx])
            return "";
        idx++;
    }
    return temp;
}

int main(){
    ios_base:: sync_with_stdio(0); 
    cin.tie(0);
    
    string s, t, k;
    vector<string> ans;
    cin >> s >> t;
    if(t.size() <= s.size()){
        FOR(i,0,s.size()-t.size()+1){
            k = solve(s,t,i);
            if(k != ""){
                FOR(j,0,k.size())
                    if(k[j] == '?')
                        k[j] = 'a';
                ans.push_back(k);
            }
        }
    }
    sort(ans.begin(), ans.end());
    if(ans.empty())
        cout << "UNRESTORABLE" << endl;
    else
        cout << ans[0];
    return 0;
}

Measured memory_bytes: 256
import sys
import itertools


def resolve(in_):
    k = int(next(in_))
    a, b = map(int, next(in_).split())
    for v in range(a, b + 1):
        if not v % k:
            return 'OK'
    
    return 'NG'


def main():
    answer = resolve(sys.stdin.buffer)
    print(answer)


if __name__ == '__main__':
    main()

Measured memory_bytes: 9100
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <iomanip>
#include <stack>
#include <queue>
#include <numeric>
#include <map>
#include <unordered_map>
#include <set>
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define mod 1000000007
using ll = long long;
using namespace std;

int main(){
  string S,T;
  cin >> S >> T;
  int ssize = (int)S.size();
  vector<int> scount(26,0);
  vector<int> tcount(26,0);
  rep(i,ssize){
    scount[S[i] - 'a']++;
    tcount[T[i] - 'a']++;
  }
  sort(all(scount));
  sort(all(tcount));
  if(scount==tcount) cout << "Yes" << endl;
  else cout << "No" << endl;
  return 0;
}


Measured memory_bytes: 776
#include<bits/stdc++.h>
#include<stdlib.h>
using namespace std;
int main(){
  int n;
  cin >> n;
  int s[n],i,sum_1=0;
  for(i=0;i<n;i++){
    cin >> s[i];
    sum_1+=s[i];
  }
  int sum_2=0,j,m=sum_1;
  for(i=0;i<n;i++){
    sum_2+=s[i];
    if(m>abs(sum_1-sum_2*2)){
      m=abs(sum_1-sum_2*2);
    }
  }
  cout << m;
}
 
    

Measured memory_bytes: 256
N = int(input())
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
A = prime_factorize(N)
b = {}
for i in A:
    if i not in b:
        b[i] = 1
    elif i in b:
        b[i] += 1
count = 0
for v in b.values():
    if v >= 45:
        count += 9
        continue
    
    elif v >= 36:
        count += 8
        continue
    elif v >= 28:
        count += 7
        continue
    elif v >= 21:
        count += 6
        continue
    
    elif v >= 15:
        count += 5
        continue
    elif v >= 10 :
        count += 4
        continue
    elif v >= 6:
        count += 3
        continue
    elif v >= 3 :
        count += 2
        continue
    elif v >= 1 :
        count += 1
        continue
#print(b)
print(count)

Measured memory_bytes: 9280
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int MAX_H = 1E+05;

const long long MOD = 1E+09 + 7;

int H, W, A, B;

long long modfac[MAX_H * 2 + 1];
long long modfacinv[MAX_H * 2 + 1];

long long modfactor(long long p);

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> H >> W >> A >> B;

    long long total = (((modfactor(H + W - 2) * modfacinv[H - 1]) % MOD) * modfacinv[W - 1]) % MOD;

    long long wrong = 0;

    for (int i = 1; i <= B; i++) {
        long long path1 = (((modfac[H - A + i - 2] * modfacinv[i - 1]) % MOD) * modfacinv[H - A - 1]) % MOD;
        long long path2 = (((modfac[A + W - i - 1] * modfacinv[A - 1]) % MOD) * modfacinv[W - i]) % MOD;
        wrong += (path1 * path2) % MOD;
        wrong %= MOD;
    }

    cout << (total - wrong + MOD) % MOD << "\n";

    return 0;
}

long long modPow(long long x, long long a)
{
    if (a == 1)
        return x % MOD;
    if (a % 2 == 0) {
        long long t = modPow(x, a / 2);
        return (t * t) % MOD;
    } else {
        return ((x % MOD) * modPow(x, a - 1)) % MOD;
    }
}

long long modfactor(long long p)
{
    if (p == 0) {
        modfacinv[p] = 1;
        return modfac[p] = 1;
    }
    modfac[p] = (p * modfactor(p - 1)) % MOD;
    modfacinv[p] = (modPow(p, MOD - 2) * modfacinv[p - 1]) % MOD;
    return modfac[p];
}


Measured memory_bytes: 13016
#include<iostream>
#include<cmath>
#define MOD 1000000007
using namespace std;
long long a;
int n;
int main(){
    cin>>n;
    a=1;
    for(int i=1;i<=n;i++) a=a*i%MOD;
    cout<<a<<endl;
    return 0;
}


Measured memory_bytes: 256
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ArrayList<Restaurant> li = new ArrayList<Restaurant>();
        for(int i = 0; i < n; i++){
            String s = sc.next();
            int p = sc.nextInt();
            Restaurant r = new Restaurant(s,p,i+1);
            li.add(r);
        }
        Collections.sort(li);
        for(Restaurant r : li){
            System.out.println(r.index);
        }
    }
}

class Restaurant implements Comparable<Restaurant>{
    String town;
    int point;
    int index;
    public Restaurant(String s, int p, int i){
        this.town = s;
        this.point = p;
        this.index = i;
    }
    
    public int compareTo(Restaurant r2) {
        int chk = this.town.compareTo(r2.town);
        if(chk <= -1){ 
          return -1; 
        }else if(chk >= 1){
          return 1;
        }else{
            if(this.point > r2.point){
                return -1;
            }else{
                return 1;
            }
        }
    }
}


Measured memory_bytes: 21716
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int

func main() {
	mod = 1000000007
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := intScanner()
	a := intSliceScanner(n)
	b := 0
	for _, v := range a {
		b ^= v
	}
	ans := make([]int, n)
	for i, v := range a {
		ans[i] = b ^ v
	}
	fmt.Println(strings.Trim(fmt.Sprint(ans), "[]"))
}


Measured memory_bytes: 18140
# C_vacation
N = int( input() )
happiness = list()
for nn in range(N):
    h = [int(x) for x in input().split()]
    happiness.append( h )

dp = [[0]*3 for x in range(N)]
dp[0] = happiness[0]
for nn in range(1, N):
    for ii in range(3): # day nn's choice
        max_reward = 0
        for jj in range(3): # day (nn-1)'s choice
            r = dp[nn-1][jj] + happiness[nn][ii]
            if( ii != jj and r > max_reward ):
                max_reward = r
        dp[nn][ii] = max_reward

ans = 0
for ii in range(3):
    if( dp[-1][ii] > ans ):
        ans = dp[-1][ii]
print( ans )

Measured memory_bytes: 48672
#include <bits/stdc++.h>
using namespace std;
int n;
map<vector<int>,int> bfs(vector<int> A){
  map<vector<int>,int> D;
  queue<vector<int> > Q;
  Q.push(A);
  D[A] = 0;
  while(!Q.empty()){
    vector<int> t = Q.front();Q.pop();
    int cost = D[t];
    if(cost == 4) continue;
    
    for(int i=0;i<n;i++)
      for(int j=i+2;j<=n;j++){
	vector<int> nt = t;
	reverse(nt.begin()+i,nt.begin()+j);
	if(D.count(nt)) continue;
	Q.push(nt);
	D[nt]=cost+1;
    }
  }
  return D;
}


int main(){
  cin>>n;
  vector<int> A(n),B(n);
  for(int i=0;i<n;i++) cin>>A[i],B[i] = i+1;

  
  map<vector<int>,int> X = bfs(A);
  map<vector<int>,int> Y = bfs(B);

  map<vector<int>,int>::iterator it = X.begin();
  int ans = 9;
  
  for(;it!=X.end();it++)
    if(Y.count(it->first))ans = min(ans,it->second+Y[it->first]);
  
  cout<<ans<<endl;
  


  return 0;
}

Measured memory_bytes: 83120
import java.util.*;
import java.lang.*;


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long x = sc.nextLong();
        long y = sc.nextLong();
        long len = 0;
        while (x <= y) {
            x *= 2;
            len++;
        }
        System.out.println(len);
    }
}

Measured memory_bytes: 21844
#include<algorithm>
#include<iostream>
#include<vector>
#include<string>
#include<cstring>
#include<utility>
using namespace std;
#define REP(i, a,b) for(i=a;i<b;i++) 
#define output(x) cout<<x<<endl;
typedef long long int ll;



int main()
{
	ll  i, j, k, l, m, sum, flag,ans,W,H,N,h,w;
	sum = 0;
	flag = 0;
	cin >> H >> W >> h >> w;
	if (H%h == 0 && W%w == 0) {
		output("No");
		return 0;
	}
	if (W%w != 0) {
		vector<ll>S(W + 1);
		S[0] = 0;
		for (j = 1; j <= w-1; j++) {
			if (W%w == j) {
				S[j] = W / w + 1;
			}
			else {
				S[j] = 100;
			}
		}
		for (j = w; j < W + 1; j++) {
			S[j] = S[j - w] - 1;
		}
		vector<ll>a(W);
		REP(i, 0, W) {
			a[i] = S[i + 1] - S[i];
		}
output("Yes");
		REP(j, 0, H) {
			REP(i, 0, W) {
				cout << a[i] << " ";
			}
			cout << endl;
		}
		return 0;


	}
	vector<ll>S1(H + 1);
	S1[0] = 0;
	for (j = 1; j <= h - 1; j++) {
		if (H%h == j) {
			S1[j] = H / h + 1;
		}
		else {
			S1[j] = 100;
		}
	}
	for (j = h; j < H + 1; j++) {
		S1[j] = S1[j - h] - 1;
	}
	vector<ll>b(H);
	REP(i, 0, H) {
		b[i] = S1[i + 1] - S1[i];
	}
output("Yes");
	REP(i, 0, H) {
		REP(j, 0, W) {
			cout << b[i] << " ";
		}
		cout << endl;
	}

	return 0;
}



Measured memory_bytes: 1408
import java.util.*;
public class Main {
	public static void main(String[] args)  {
		Scanner scan = new Scanner(System.in);
		long x = Long.parseLong(scan.next());

		long ans = x/11;
		x-=ans*11;
		ans*=2;
		if (0 < x && x <= 6)ans+=1;
		else if (6 < x  && x<11)ans+=2;
		System.out.print(ans);
}
}
//end


Measured memory_bytes: 21844
#include<iostream>
#include<cstdio>
#include<cstring>
#include <cstdlib>  
#include <cmath>   
#include<cctype>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include <functional>
#include<vector>
#include<climits>
#include<stack>
#include<queue>
#include <deque>
#include <utility> 

#define rep(i,m,n) for(int i = m;i < n;++i)
using namespace std;
using ll = long long;
using R = double;
const ll inf = 1LL << 50;
const ll MOD = 1e9 + 7;






int main() {
	int h, w, n;
	cin >> h >> w;
	cin >> n;

	vector<vector<int>>a(h,vector<int>(w,0));

	int cnt = 0;
	rep(i, 0, n) {
		int x;
		cin >> x;
		int temp = 0;
		while (temp < x) {
			a[cnt / w][cnt%w] = i + 1;
			temp++;
			cnt++;
		}
	}


	rep(i, 0, h) {
		if (i % 2 == 0) {
			for (int j = 0; j < w; j++) {
				cout << a[i][j] << " ";
			}
		}
		else {
			for (int j = w-1; j >= 0; j--) {
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}


	

	return 0;
}

Measured memory_bytes: 764
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define mod 998244353
#define int long long
#define ll long long
#define EPS 0.00000000000001
#define ld long double
#define inf 1e14
#define N 300001
#define K 33

int32_t main()
{
    IOS;
    #ifndef ONLINE_JUDGE
    freopen("int.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif
    int n;
    cin >> n;
    vector<int> v(n + 1);
    int ans = 0;
    for(int i = 1;i <= n;i++)
    {

        cin >> v[i];
        if( i % 2 == 1 and v[i] % 2 == 1)
            ans++;
    }
    cout << ans;


    
    return 0;    
} 


Measured memory_bytes: 3648
const main = input => {
  let lns = input.split('\n')
  let s = []
  for(let i = 0; i < lns[0]; i++) {
    s.push(lns[i+1])
  }
  return [...(new Set(s))].length
}

console.log(main(require("fs").readFileSync("/dev/stdin", "utf8")))

Measured memory_bytes: 63464
import java.util.*;
import java.util.function.*;
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int u = sc.nextInt();
    int v = sc.nextInt();
    int[] A = new int[N];
    int[] B = new int[N];
    for (int i = 1; i < N; i++) {
      A[i] = sc.nextInt();
      B[i] = sc.nextInt();
    }
    sc.close();

    List<Integer>[] tree = new ArrayList[N + 1];
    for (int i = 1; i < tree.length; i++) tree[i] = new ArrayList<>();
    for (int i = 1; i < N; i++) {
      tree[A[i]].add(B[i]);
      tree[B[i]].add(A[i]);
    }
/*
    IntFunction<int[]> dist = r -> {
      int[] ds = new int[N + 1];
      Deque<Integer> stack = new ArrayDeque<>();
      stack.push(r);
      while (0 < stack.size()) {
        int i = stack.pop();
        for (int t : tree[i])
          if (ds[t] == 0 && t != r) {
            ds[t] = ds[i] + 1;
            stack.push(t);
          }
      }
      return ds;
    };
    int[] dist_u = dist.apply(u);
    int[] dist_v = dist.apply(v);
*/
    int[] dist_u = dist(u, N, tree);
    int[] dist_v = dist(v, N, tree);

    int d = 0;
    for (int i = 1; i < N + 1; i++)
      if (dist_u[i] < dist_v[i] && dist_v[d] < dist_v[i]) d = i;

    long ans = dist_v[d] - 1;
    System.out.println(ans);
  }
  
  private static int[] dist(int r, int N, List<Integer>[] tree) {
      int[] ds = new int[N + 1];
      Deque<Integer> stack = new ArrayDeque<>();
      stack.push(r);
      while (0 < stack.size()) {
        int i = stack.pop();
        for (int t : tree[i])
          if (ds[t] == 0 && t != r) {
            ds[t] = ds[i] + 1;
            stack.push(t);
          }
      }
      return ds;
  }
}

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

using ll = long long int;

const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);

ll a, b;

vector<ll> store;

ll ans = 0;

/////////////////////////////////////////////////////////////
ll mypow_core(ll x, int n, ll result) {
  if (n == 0) {
    return result;
  }

  if (n % 2 == 0) {
    return mypow_core(x * x, n / 2, result);
  }
  else {
    return mypow_core(x, n - 1, x * result);
  }
}

ll mypow(ll x, int n) {
  return mypow_core(x, n, 1);
}
/////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////
ll count_one(int k, ll x) {
  ll band = mypow(2, k + 1);

  ll part = (x + 1) / band;

  ll num = mypow(2, k) * part;

  ll cut = (x + 1) % band;

  if (cut == 0) {
    return num;
  }
  else {
    if (cut >= (band / 2) + 1) {
      return num + cut - ((band / 2) + 1) + 1;
    }
    else {
      return num;
    }
  }
}
/////////////////////////////////////////////////////////////

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

  int size = log2(b) + 1;

  for (int i = 0; i <= size; ++i) {
    ll bottom = count_one(i, a - 1);
    ll top = count_one(i, b);

    ll num_one = top - bottom;

    if (num_one % 2 == 0) {
      store.push_back(0);
    }
    else {
      store.push_back(1);
    }
  }

  for (int i = 0; i < store.size(); ++i) {
    ans += mypow(2, i) * store[i];
  }

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

  return 0;
}


Measured memory_bytes: 764
#include <cstdio>

int main()
{
	int K;
	scanf("%d", &K);
	int x = 0;
	int ans = -1;
	for (int i = 0; i < K; ++i) {
		x = (10 * x + 7) % K;
		if (x == 0) {
			ans = i + 1;
			break;
		}
	}
	printf("%d\n", ans);
	return 0;
}


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

#define   ll             long long int
#define   pb             push_back
#define   mp             make_pair
#define   fast           ios_base::sync_with_stdio(false);cin.tie(NULL);
#define   ff             first
#define   ss             second
#define   nil           -10e+9
#define   initial         0
#define   waiting         1
#define   visit           2
#define   inf            10e+9
#define   mx             200005
#define   mxx            1000005
#define   mod            1000000007
#define   pr             pair<ll,ll>
#define   pp_queue       priority_queue<pr,vector<pr>, greater<pr> >
#define   dp_queue       priority_queue<int,vector<int>, greater<int> >
#define   sp_queue       priority_queue<int>
#define   fr(i,p,q)      for(int i=p;i<q;++i)
#define   frr(i,p,q)     for(int i=p;i<=q;++i)
#define   mem(a,b)       memset(a,b,sizeof(a))
#define   len(a)         (int)a.size()
#define   input          freopen("input.txt", "r", stdin);
#define   output         freopen("output.txt", "w", stdout);
#define   debug(arr,j,n) fr(i,j,n) cout<<arr[i]<<" ";

ll power(ll a,ll b){ll aa=1;while(b){if(b&1){aa=aa*a;aa%=mod;}a=a*a;a%=mod;b/=2;}return aa;}

using namespace std;

int main()
{
  int n;
  cin>>n;
  int a[n];
  fr(i,0,n) cin>>a[i];
  int cnt=0,maxm=0;

  fr(i,0,n-1){
    if(a[i]>=a[i+1]){
      cnt+=1;
    }
    else{
      maxm=max(cnt,maxm);
      cnt=0;
    }

  }
  maxm=max(cnt,maxm);
  cout<<maxm<<"\n";

  return 0;
}


Measured memory_bytes: 640
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vb=vector<bool>;
using vvb=vector<vb>;
using vd=vector<double>;
using vvd=vector<vd>;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using tll=tuple<ll,ll>;
using tlll=tuple<ll,ll,ll>;
using vs=vector<string>;

#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define rep(i,n) range(i,0,n)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define range(i,a,n) for(ll i=(a);i<(n);i++)

#define LINF ((ll)1ll<<60)
#define INF ((int)1<<30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout<<setprecision(a)<<fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384

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

template<class T>bool chmax(T&a,T b){if(a<b){a=b; return true;}return false;}
template<class T>bool chmin(T&a,T b){if(a>b){a=b; return true;}return false;}
template<class S>S acm(vector<S>&a){return accumulate(all(a),S());}
template<class S>S max(vector<S>&a){return *max_element(all(a));}
template<class S>S min(vector<S>&a){return *min_element(all(a));}
void YN(bool b){cout<<(b?"YES":"NO")<<"\n";}
void Yn(bool b){cout<<(b?"Yes":"No")<<"\n";}
void yn(bool b){cout<<(b?"yes":"no")<<"\n";}
int sgn(const double&r){return (r>EPS)-(r<-EPS);} // a>0  : sgn(a)>0
int sgn(const double&a,const double&b){return sgn(a-b);} // b<=c : sgn(b,c)<=0

ll max(int a,ll b){return max((ll)a,b);} ll max(ll a,int b){return max(a,(ll)b);}
template<class T>void puta(T&&t){cout<<t<<"\n";}
template<class H,class...T>void puta(H&&h,T&&...t){cout<<h<<' ';puta(t...);}
template<class S,class T>ostream&operator<<(ostream&os,pair<S,T>p){os<<"["<<p.first<<", "<<p.second<<"]";return os;};
template<class S>auto&operator<<(ostream&os,vector<S>t){bool a=1; for(auto s:t){os<<(a?"":" ")<<s;a=0;} return os;}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	ll n,k,s;
	cin>>n>>k>>s;
	ll tar=(s<n*10?s+1:s-1);
	vl ans;
	rep(i,n){
		ans.push_back((i<k?s:tar));
	}
	puta(ans);
}


Measured memory_bytes: 3060
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main(){
    long long int n;

    while(cin>>n){
        if(n==0)break;
        else{
            long long int ans=1000001;

            vector<long long int> v;

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

            sort(v.begin(),v.end());
            
            for(int i=0;i<n-1;i++){
                ans=min(ans,v[i+1]-v[i]);
            } 
            
            cout<<ans<<endl;

        }
    }

    return 0;
}

Measured memory_bytes: 3172
#include <iostream>
#include <vector>
#include <string>
#include <utility>
#include <algorithm>
#include <set>
#include <map>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;

int abs(int x) {
	if (x < 0) return -x;
	return x;
}

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

	int n;
	cin >> n;
	vector<int> a(n+2);
	int total = 0;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		total += abs(a[i] - a[i-1]);
	}
	total += abs(a[n+1] - a[n]);

	for (int i = 1; i <= n; i++) {
		int x = total + abs(a[i+1] - a[i-1]) - abs(a[i] - a[i-1]) - abs(a[i+1] - a[i]);
		cout << x << "\n";
	}
}


Measured memory_bytes: 1664
#include<iostream>
#include<bits/stdc++.h>
#define int long long
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
int32_t main()
{
 int n,m;
 cin>>n>>m;
 int a[m+1];
 int sum=0;
 for(int i=0;i<m;i++)
 {
 	cin>>a[i];
 	sum=sum+a[i];
 }
 if(sum>n)
 {
 	cout<<"-1";
 }
 else
 { int z=n-sum;
 	cout<<z;
 }
}


Measured memory_bytes: 3700
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <cstdio>

using namespace std;

vector<int> a[100005];
map<pair<int, int>, int> m;

class HOGE
{
public:
      int p;
      int y;
};

HOGE b[100005];

int main()
{
    int N, M;

    cin >> N >> M;
    int P, Y;

    for (int i = 0; i < M;i++)
    {
        cin >> P >> Y;
        a[P].push_back(Y);
        b[i].p = P;
        b[i].y = Y;
    }
    for (int i = 1; i <= N;i++)
    {
        if(a[i].size() > 0 )
        {
            sort(a[i].begin(), a[i].end());
            for (int j = 0; j < a[i].size();j++)
            {
                m.insert(make_pair(make_pair(i, a[i][j]), j + 1));
            }
        }
    }

    for (int i = 0;i < M;i++)
    {
        int p = b[i].p;
        int y = b[i].y;

        int num = m[make_pair(p, y)];
        printf("%06d%06d\n", p, num);
    }

    return 0;
}

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

int main() {
  bool foundC = false;
  string s;
  cin >> s;
  REP(i, s.length()) {
    if (s[i] == 'C') foundC = true;
    if (foundC && s[i] == 'F') {
      cout << "Yes" << endl;
      return 0;
    }
  }
  cout << "No" << endl;
  return 0;
}

Measured memory_bytes: 256
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF (1<<30)
#define INFLL (1ll<<60)
typedef pair<int, int> P;
typedef pair<int, P> E;
#define MOD (1000000007ll)
#define l_ength size

void mul_mod(ll& a, ll b){
	a *= b;
	a %= MOD;
}

void add_mod(ll& a, ll b){
	a += b;
	a %= MOD;
}

int main(void){
	ll a,b,t;
	cin >> a >> b >> t;
	cout << ((t/a)*b) << endl;
	return 0;
}


Measured memory_bytes: 256
import java.util.Scanner;

public class Main {
    public static int MAX = 100000;
    public static int n, k;
    public static long[] T = new long[MAX];

    // 最大積載量Pのk題のトラックで何個の荷物を積めるか
    public static int check(long P) {
        int i = 0;
        for(int j = 0; j < k; j++) {
            long s = 0;
            while(s + T[i] <= P)
            {
                s += T[i];
                i++;
                if(i == n) return n;
            }
        }
        return i;
    }

    public static int solve() {
        long left = 0;
        long right = 100000 * 10000;
        long mid;
        while(right - left > 1)
        {
            mid = (left + right) / 2;
            int v = check(mid);
            if(v >= n) right = mid;
            else left = mid;
        }
        return (int)right;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        k = sc.nextInt();
        for(int i = 0; i < n; i++) T[i] = sc.nextInt();
        long ans = solve();
        System.out.println(ans);
    }
}



Measured memory_bytes: 73104
#include <stdio.h>

int main()
{
    int a, b, c, t;
    int sa, sb, sc;
 
    sa = sb = sc = 0;
    while (5645647) {
        scanf("%d%d%d", &a, &b, &c);
        if (a + b <= c || b + c <= a || c + a <= b) break;
        if (c < a) t = c, c = a, a = t;
        if (c < b) t = c, c = b, b = t;
        t = a*a + b*b;
        if      (c*c == t) sa++;
        else if (c*c <  t) sb++;
        else               sc++;
    }
    printf("%d %d %d %d\n", sa+sb+sc, sa, sb, sc);
    return 0;
}


Measured memory_bytes: 2060
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <string.h>
#include <iomanip>
#include <limits>
using namespace std;

const int MAX_N=10000;
string s[3];

int main(){
	for(int i=0;i<3;i++) cin >> s[i];
	
	for(int i=0;i<3;i++) cout << (char)(s[i][0]+('A'-'a'));
	
	cout << endl;
	return 0;
}


Measured memory_bytes: 256
#include <stdio.h>
#include<string.h>

int main(void){
  int n,i,j,k,l,point=0;
  char str[1030],ans[51];
  
  scanf("%d%*c",&n);
  
  for(i=0;i<n;i++){
    scanf("%s%*c",str);
    point=0;
    for(j=0;j<51;j++) ans[j]='0';
    l=((strlen(str)-1)/3);
    ans[25]=str[0];
    for(j=0;j<l;j++){
      if(str[3*j+2]=='>'){
	point++;
      }else{
	point--;
      }
      ans[25+point]=str[3*(j+1)];
    }
    
    for(k=0;k<51;k++){
      if(ans[k]!='0'){
	printf("%c",ans[k]);
      }
    }
    printf("\n");
  }
  
  return 0;
}

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

int h, n, a;

int main(){
	cin >> h >> n;
	for (int i = 0; i < n; ++i){
		cin >> a;
		h -= a;
	}
	if(h <= 0)	cout << "Yes" << endl;
	else		cout << "No" << endl;
	return 0;
}

Measured memory_bytes: 256
#include<iostream>
#include<vector>
#include<utility>
#include<array>
#include<limits>
#include<algorithm>

int main() {
	static constexpr int MI = ::std::numeric_limits<int>::lowest();
	static const ::std::array<int, 10> t = { 0,2,5,5,4,5,6,3,7,6 };
	int n, m;
	::std::cin >> n >> m;
	::std::vector<int> a(m);
	for (auto &e : a) {
		::std::cin >> e;
	}
	::std::sort(a.begin(), a.end());
	::std::vector<int> dp(n + 1, MI);
	dp[0] = 0;
	for (int i = 1;i != n + 1;++i) {
		for (const auto &e : a) {
			if (t[e] <= i&&dp[i] < dp[i - t[e]] + 1) {
				dp[i] = dp[i - t[e]] + 1;
			}
		}
	}
	::std::vector<int> ans;
	while (n) {
		ans.push_back(0);
		int cur = MI;
		for (const auto &e : a) {
			if (n >= t[e] && cur <= dp[n - t[e]]) {
				ans.back() = e;
				cur = dp[n - t[e]];
			}
		}
		n -= t[ans.back()];
	}
	for (const auto &e : ans) {
		::std::cout << e;
	}
	::std::cout << ::std::endl;
}


Measured memory_bytes: 384
#include<bits/stdc++.h>
#define FOR(i,a,b) for (register int i=a;i<=b;i++)
#define mem(i,j) memset(i,j,sizeof(i))
#define GO(u) for (register int j=f[u];j!=-1;j=nxt[j])
using namespace std;
typedef long long ll;
ll a,Ans;
ll read()
{
	ll x=0,f=1;
	char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') {x=(x<<1)+(x<<3)+c-'0';c=getchar();}
	return f*x;
}
int main()
{
	a=read();
	Ans=3*a*a;
	printf("%lld",Ans);
	return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
#define ll long long //10^18
#define ull unsigned long long //10^19
using namespace std;
int main() {
  //ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
  int a,b;cin>>a>>b;
  int ar[3]={0,0,0};
  ar[a-1]=true;ar[b-1]=true;
  for(int i=0;i<3;i++)if(!ar[i])cout<<i+1;
  return 0;
}


Measured memory_bytes: 256
using namespace std;

#define visual

#ifdef visual
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#include <assert.h>
#include <functional>
#include <math.h>
#include <string>
#include <ctime>
#endif
#ifndef visual
#include <bits/stdc++.h>
#endif

typedef long long ll;


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

    int n;
    cin >> n;

    vector<pair<pair<int, int>, int>> v;
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        v.push_back({ {x, y}, i });
    }


    sort(v.begin(), v.end());
    int curstart = -1;
    int curmin = 20000000;
    vector<int> ans(n);
    for (int a = 0; a < v.size(); a++) {
        curmin = min(curmin, v[a].first.second);
        if (curmin == n - a) {
            int x = a - curstart;
            while (curstart < a) {
                curstart++;
                ans[v[curstart].second] = x;
            }
        }
    }


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







}


Measured memory_bytes: 6376
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    n, a, b, c, d = LI_()
    s = S()
    flg = False
    for i in range(a, c-1):
        if s[i] == "#" and s[i + 1] == "#":
            print("No")
            return
    for i in range(b, d-1):
        if s[i] == "#" and s[i + 1] == "#":
            print("No")
            return
    if c > d:
        for i in range(b,d+1):
            if s[i] == "." and s[i + 1] == "." and s[i - 1] == ".":
                flg = True
                break
        if not flg:
            print("No")
            return
    print("Yes")
    return

#B
def B():
    s = S()
    i = len(s) - 1
    state = 0
    ans = 0
    bc = 2
    while i >= 0:
        if state == 0:
            if s[i] == "C":
                state += 1
        elif state == 1:
            if s[i] == "B":
                state += 1
            else:
                state = 0
        elif state == 2:
            if s[i] == "A":
                ans += 1
            elif s[i] == "B":
                state = 0
            else:
                state += 1
        elif state == 3:
            if s[i] == "B":
                state += 1
            elif s[i] == "C":
                state = 1
            else:
                state = 0
        else:
            if s[i] == "A":
                ans += bc
            elif s[i] == "B":
                state = 0
                bc = 2
            else:
                bc += 1
                state = 3
        #print(state,s[i])
        i -= 1
    print(ans)

    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()


Measured memory_bytes: 62960
import collections

n=int(input())
S=collections.Counter(list(input()))
S0=list(S.items())
L=len(S0)
for i in range(L):
    S0[i]=list(S0[i])

for i in range(1,n):
    temp=list(input())
    for j in range(L):
        h=temp.count(S0[j][0])
        if h<S0[j][1]:
            S0[j][1]=h


ans=[]

for i in range(L):
    if S0[i][1]!=0:
        for j in range(S0[i][1]):
            ans.append(S0[i][0])

ans.sort()
print("".join(ans))



Measured memory_bytes: 3316
using System;

namespace c_sharp_test
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = "";
            string output = "";
            input = Console.ReadLine();
            switch (input)
            {
                case "Sunny":
                    output = "Cloudy";
                    break;
                case "Cloudy":
                    output = "Rainy";
                    break;
                case "Rainy":
                    output = "Sunny";
                    break;
            }
            Console.WriteLine(output);
        }
    }
}


Measured memory_bytes: 11092
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		String S = scan.next();
		
        Map<String, String> map = new HashMap<>();
        map.put("Sunny", "Cloudy");
        map.put("Cloudy", "Rainy");
        map.put("Rainy", "Sunny");
		
		System.out.println(map.get(S));
		
		scan.close();
	}

}


Measured memory_bytes: 21712
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <string>
#include <map>
#include <set>
#include <locale.h>
#include <vector>
#include <iomanip>
#include <cassert>
#include <list>
#include <unordered_map>
#include <cstring>

#define all(x) x.begin(), x.end()
#define sz(x) (int)(x.size())
#define pb push_back

#define onlycin ios_base::sync_with_stdio(false); cin.tie(0)
#define mp make_pair
#define endl "\n"
#define rep(i,x,y) for(int i = x; i <= y; ++i)
#define repr(i,x,y) for(long long i = x; i >= y; --i)
#define y1 wearsdfasdf
#define fi first
#define se second

typedef long long ll;

const int N = (100000) + 322;
const int INF = (ll)(1e9) + 7;

using namespace std;

ll pr[N], a[N], n, pos[N], m, d[111][111], cost[111][111];

struct edge {
  int x, y, cost;
};
vector <edge> e;

bool get(int x, int y, int cost) {
  rep(i, 1, n) {
    rep(j, i, n) {
      if (d[i][j] == d[i][x] + d[y][j] + cost || d[i][j] == d[i][y] + d[j][x] + cost) return 1;
    }
  }
  return 0;
}

int main () {
  ios_base::sync_with_stdio(false);
  cin >> n >> m;
  rep(i, 1, n) rep(j, 1, n) if (i != j) d[i][j] = INF;
  
  rep(i, 1, m) {
    int x, y, c; cin >> x >> y >> c;
    e.pb({x, y, c});
    d[x][y] = c;
    d[y][x] = c;
  }
  for (int k=1; k<=n; ++k)
    for (int i=1; i<=n; ++i)
      for (int j=1; j<=n; ++j)
        d[i][j] = min (d[i][j], d[i][k] + d[k][j]);
  int cnt = 0;
  for(auto it : e) {
    cnt += get(it.x, it.y, it.cost);
  }
  
  cout << m - cnt;
  return 0;
}


Measured memory_bytes: 384
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int count = 0;
		int[] input = new int[N];
		boolean[] flag = new boolean[N];
		for(int i = 0; i < N; i++) {
			input[i] = sc.nextInt();
			flag[i] = checkEqual(i, input[i]);
		}

		while(checker(flag)) {
			for(int i = 0; i < N; i++) {
				if(flag[i]) {
					if(i != 0 && i != N - 1) {
						int c = input[i];
						input[i] = input[i+1];
						input[i+1] = c;
						count++;
						flag[i] = checkEqual(i, input[i]);
						flag[i+1] = checkEqual(i+1, input[i+1]);
					} else if (i == 0){
						int c = input[i];
						input[i] = input[i + 1];
						input[i+1] = c;
						count++;
						flag[i] = checkEqual(i, input[i]);
						flag[i+1] = checkEqual(i+1, input[i+1]);

					} else {
						int c = input[i];
						input[i] = input[i-1];
						input[i-1] = c;
						count++;
						flag[i] = checkEqual(i, input[i]);
						flag[i-1] = checkEqual(i-1, input[i-1]);
					}
				}
			}
		}

		System.out.println(count);

	}

	public static boolean checkEqual(int index, int input) {
		index += 1;
		if(index == input) {
			return true;
		} else {
			return false;
		}
	}

	public static boolean checker(boolean[] flag) {
		for(int i = 0; i < flag.length; i++) {
			if(flag[i]) {
				return true;
			}
		}
		return false;
	}

}

Measured memory_bytes: 50852
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    X, Y = LI()

    ans = 0
    num = X
    while num <= Y:
        ans += 1
        num *= 2

    print(ans)

if __name__ == '__main__':
    resolve()


Measured memory_bytes: 10108
#include <bits/stdc++.h> 
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
#define MOD 1000000007
#define INF 1000000000
#define mp make_pair
#define pb push_back
#define ss second
#define ff first
#define endl '\n'
#define pl cout<<endl;
void fast() { ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL); }
const long long INFll=1ll*INF*INF;
const long double PI=3.141592653589793238462643383279502884197169399375105820974944;
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/gcd((a),(b))
#define debug(x) cout << x << endl;
#define sz(a) int((a).size())
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    //unordered_map<long long, int, custom_hash>
    //gp_hash_table<long long, int, custom_hash>
};
long long genrand(long long L,long long R)
{
	return uniform_int_distribution<long long>(L, R)(rng);
}
int mul(int a, int b,int mod = MOD) {
	return int(a * 1ll * b % mod);
}
int norm(int a,int mod = MOD) {
	while(a >= mod) a -= mod;
	while(a < 0) a += mod;
	return a;
}
int powmod(int x,int y,int mod = MOD){
	int res = 1;
	while(y>0)
	{
		if(y&1)
			res = mul(res,x,mod);
		x = mul(x,x,mod);
		y=y>>1;
	}
	return res;
}
int inv(int a,int mod = MOD) {
	return powmod(a, mod - 2);
}
int main() {
	
	long double r; cin>>r;
	long double ans = 2 * PI * r;
	cout<<fixed<<setprecision(10)<<ans<<endl;
	
	return 0;
}

Measured memory_bytes: 3796
#include<bits/stdc++.h>
#define endl              "\n"
#define fast               ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
int main()
{
    long long  i=0,j,n,c=0,d=0,e=0,f=0,a,b;
    string s,t,u;
    cin>>s>>t;
    cin>>a>>b;
    cin>>u;
    if(u==s)
    {
        a-=1;
    }
    else if(u==t)
    {
        b-=1;
    }
    cout<<a<<" "<<b;
}


Measured memory_bytes: 256
#include <iostream>
#include <string>
#include <stdlib.h>
#include <cmath>
#include <vector>

#define rep(i, s, N) for(int i = s; i < N; i++)
#define YesNo(result) do {if (result) std::cout << "Yes" << '\n'; else std::cout << "No" << '\n';} while(0)
#define resetarr(arr, val) for(int i = 0; i < sizeof(arr) / 4; i++){ arr[i] = val; }

int main(int argc, char const *argv[]) {
  std::string s;
  std::cin >> s;
  int list[3];
  resetarr(list, 0);
  rep(i, 0, 3) {
    if(s[i] == 'a') list[0]++;
    else if(s[i] == 'b') list[1]++;
    else list[2]++;
  }
  bool res = true;
  rep(i, 0, 3) {
    if(list[i] != 1) res = false;
  }
  YesNo(res);
  return 0;
}


Measured memory_bytes: 888
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func main(){
    sc.Split(bufio.ScanWords)
    monsterLife := nextInt()
    attack := nextInt()
    
    if (monsterLife % attack > 0) {
        fmt.Println(monsterLife / attack + 1)
    } else {
        fmt.Println(monsterLife / attack)
    }
}


Measured memory_bytes: 640
/*
    Author: Alam Khan
    AUST CSE 40th Batch

*/

#include<bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;

typedef long long ll;
typedef pair<ll,ll> pll;
typedef vector<ll> vl;
typedef deque<ll> dl;
typedef stack<ll> stl;
typedef set<ll> sl;
typedef map<string, ll> msl;
typedef map<ll,ll> mll;
typedef tree<ll,null_type,less_equal<ll>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
#define sf(n)     scanf("%lld",&n)
#define sff(n,m)     scanf("%lld %lld",&n,&m)
#define sfff(n,m,r)     scanf("%lld %lld %lld",&n,&m,&r)
#define sfs(n)     scanf("%s",n)
#define pf(n)     printf("%lld\n",n)
#define pff(n,m)     printf("%lld %lld\n",n,m)
#define pfff(n,m,r)     printf("%lld %lld %lld\n",n,m,r)
#define pfs(n)     printf("%s\n",n)
#define pfcs(i,n)     printf("Case %lld: %lld\n",i,n)
#define pb     push_back
#define prf     printf
#define inf     2e18
#define low     -1000000000000
#define PI        acos(-1.0)
#define rep1(i,n) for(i=1;i<n;i++)
#define rep0(i,n) for(i=0;i<n;i++)
#define rep(i,a,n) for(i=a;i<n;i++)
#define repe1(i,n) for(i=1;i<=n;i++)
#define repe0(i,n) for(i=0;i<=n;i++)
#define repe(i,a,n) for(i=a;i<=n;i++)
#define endl  "\n"
#define FAST  ios_base::sync_with_stdio(false);cin.tie(NULL);
#define fr freopen("input.txt","r",stdin)
#define fw freopen("output.txt","w",stdout)
ll N = 1000000000000001;
vector<ll> v;
int main()
{
    ll i,n,t,k,j,x=0,y=0,m;
    cin>>n;
    x = 26;
    v.pb(0);
    v.pb(x);
    while(1)
    {
        y = v.size()-1;
        x = x*26;
        k = x+v[y];
        if(k>N)
        {
            v.pb(k);
            break;
        }

        v.pb(k);
    }
    x = -1;
    for(i=0;i<v.size();i++)
    {
        if(n<=v[i])
        {
            x = i;
            break;
        }
    }
    n-= v[x-1]+1;
    string str;
    for(i=1;i<=x;i++)
    {
        str.pb((n%26)+97);
        n = n/26;
    }
    reverse(str.begin(),str.end());
    cout<<str<<endl;
    return 0;
}



Measured memory_bytes: 3628
import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int a, b;
			a = sc.nextInt();
			b = sc.nextInt();
			System.out.println(GCD(a, b));
		}
	}

	private static int GCD(int a, int b) {
		if (b > a) {
			int t = b;
			b = a;
			a = t;
		}
		
		int r = b % a;
		while (r > 0) {
			b = a;
			a = r;
			r = b % a;
		}
		return a;
	}
}

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

int main(int argc, const char * argv[]) {
    //cout << "a";
    int A,B;
    cin >> A >> B;
    //make a map
    if((A*B)%2){
      cout <<"Yes"<< endl;
    }else{
        cout <<"No"<< endl;
    }
    return 0;
}


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

int main(){
  int x;
  cin>>x;
  if(x==1) cout<<0<<endl;
  else cout<<1<<endl;
}

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

#define dk23      ios_base :: sync_with_stdio(false);
#define inp       freopen("input.txt","r",stdin);

int main()
{
    dk23

    int n,i,j;
    cin>>n;
    int temp=0;
    for(i=1;i<=9;i++){
        for(j=1;j<=9;j++){
            if(i*j==n){
                temp=1;
                break;
            }
        }
    }
    if(temp==1){
        cout<<"Yes"<<endl;
    }
    else{
        cout<<"No"<<endl;
    }
    return 0;
}


Measured memory_bytes: 256
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
    int N, cnt = 10e7; cin >> N;
    for (int i = 0; i < N; ++i) {
        int x, t = 0; cin >> x;
        while (x % 2 == 0) {
            x /= 2, t++;
        }
        cnt = min(cnt, t);
    }
    printf("%d\n", cnt);
}


Measured memory_bytes: 3668
def count(n):
	N = []
	while n > 0:
		N.append(n % 10)
		n = n // 10

	if N[0] == N[4] and N[1] == N[3]:
		return 1
	else:
		return 0

A, B= map(int,input().split())
ans = 0

for i in range(A, B + 1):
	if count(i) == 1:
		ans += 1


print(int(ans))

Measured memory_bytes: 3060