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

using namespace std;

using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using P = pair<ll, ll>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);

#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = ll(n - 1); i >= 0; i--)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()

template <class T> ostream &operator<<(ostream &out, const vector<T> &list) {
    ll n = list.size();
    rep(i, n) out << list[i] << ' ';
    return out;
}

template <class T> istream &operator>>(istream &in, vector<T> &list) {
    ll n = list.size();
    rep(i, n) in >> list[i];
    return in;
}

template <class T> ostream &operator<<(ostream &out, const vector<vector<T>> &list) {
    ll n = list.size();
    rep(i, n) out << list[i] << '\n';
    return out;
}

/* ------------- ANSWER ------------- */
/* ---------------------------------- */

void solve() {
    double l;
    cin >> l;
    cout << fixed << setprecision(10) << l / 3 * l / 3 * l / 3 << endl;
}

int main() {
    solve();
    return 0;
}


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

// macros
#define pb emplace_back
#define mk make_pair
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for(int i=((int)(n)-1);i>=0;i--)
#define irep(itr, st) for(auto itr = (st).begin(); itr != (st).end(); ++itr)
#define irrep(itr, st) for(auto itr = (st).rbegin(); itr != (st).rend(); ++itr)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define bit(n) (1LL<<(n))
// functions
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(a > b){a = b; return 1;} return 0;}
template <typename T> istream &operator>>(istream &is, vector<T> &vec){for(auto &v: vec)is >> v; return is;}
template <typename T> ostream &operator<<(ostream &os, const vector<T>& vec){for(int i = 0; i < vec.size(); i++){ os << vec[i]; if(i + 1 != vec.size())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){os << p.first << " " << p.second; return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << itr->first << ":" << itr->second; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << itr->first << ":" << itr->second; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
//  types
using ll = long long int;
using P = pair<int, int>;
// constants
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
const int mod = 1000000007;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
// io
struct fast_io{
  fast_io(){ios_base::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(20);}
} fast_io_;


int main(int argc, char const* argv[])
{
  ll n; cin >> n;
  ll res = linf;
  for(ll i = 1; i * i <= n; i++){
    if(n % i == 0){
      res = min(res, abs(i - 1) + abs(n / i - 1));
    }
  }
  cout << res << endl;
  return 0;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <random>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repp(i,n,m) for (int i = m; i < (n); ++i)
#define repl(i,n) for (long long i = 0; i < (n); ++i)
#define reppl(i,n,m) for (long long i = m; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PL = pair<long long, long long>;
using Pxy = pair<long double, long double>;
using T = tuple<int, int, bool>;
const int INF = 1001001007;
const int MOD = 1000000007;
template <typename AT>
void printvec(vector<AT> &ar){
    rep(i,ar.size()-1) cout << ar[i] << " ";
    cout << ar[ar.size()-1] << endl;
}
template <typename Q>
void printvvec(vector<vector<Q>> &ar){
    rep(i,ar.size()){
        rep(j,ar[0].size()-1) cout << ar[i][j] << " ";
        cout << ar[i][ar[0].size()-1] << endl;
    }
}
template <typename S>
bool range(S a, S b, S x){
    return (a <= x && x < b);
}

int main() {
    int k, x; cin >> k >> x;
    if (k * 500 >= x) cout << "Yes" << endl;
    else cout << "No" << endl;
}

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

  ll K,A,B,C;
  cin>>K>>A>>B;
  if((B-A)>2){
    if(K-1<A){
      printf("%lld\n",K+1);
      return 0;
    }





if((K-(A-1))%2==0)
    printf("%lld\n",A+((K-(A-1))/2)*(B-A));
    else
    printf("%lld\n",A+1+((K-(A-1)-1)/2)*(B-A));

return 0;

  }
  else{
    printf("%lld\n",K+1);
  }
}


Measured memory_bytes: 256
#include<stdio.h>
#define INF 10000000


void matrixChainOrder();
int n,m[100][100],r[100];
  
main(){
  int c[100],i;
  scanf("%d",&n);
  for(i = 0 ; i < n ; i++){
    scanf("%d%d",&r[i],&c[i]);
    if(i == n-1) r[i+1]=c[i];
  }
  matrixChainOrder();
  printf("%d\n",m[1][n]);
  return 0;
}
  
void matrixChainOrder(){
  int i,j,q,k,l;
  for(i = 0 ;  i < n+1 ; i++) {
    m[i][i]=0;
  }

  for(l = 2 ; l < n+1 ;l++){
    for(i= 1 ; i < n-l+2 ; i++){
      j = i + l - 1;
      m[i][j]=INF;
      for(k = i ; k < j ; k++){
	q = m[i][k] + m[k+1][j] + r[i-1] * r[k] * r[j];
	if(m[i][j] > q) m[i][j] = q;
      }
    }
  } 
}

Measured memory_bytes: 632
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
    int a,b,c,d;
    scanf("%d%d%d%d",&a,&b,&c,&d);
    if (abs(a-c)<=d||(abs(a-b)<=d&&abs(b-c)<=d)) printf("Yes\n");
    else printf("No\n");
    return 0;
}


Measured memory_bytes: 764
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i,k,n) for(int (i)=(k);(i)<(n);(i)++)
using namespace std;
typedef long long int ll;

void foreach_permutation(int n, std::function<void(int *)> f) {
    int indexes[n];
    for (int i = 0; i < n; i++) indexes[i] = i+1;
    do {
        f(indexes);
    } while (std::next_permutation(indexes, indexes + n));
}



int main() {
   int N,M;
   cin >> N >> M;
   int A[N];
   double q = 0;
   int sum = 0;
   int num = 0;
   for(int i=0;i<N;i++){
       cin >> A[i];
       sum += A[i];
   }
   q = sum / (double)(4.0*M);
    for(int i=0;i<N;i++){
        if(A[i]>=q){
            num++;
        }
    }
    if(num>=M){
        cout << "Yes" << endl;
    }else{
        cout << "No" << endl;
    }

}


Measured memory_bytes: 256
using System;
using System.Collections.Generic;
using System.Linq;

namespace myApp
{
    class Program
    {
        static void Main()
        {
            switch(Console.ReadLine())
            {
                case "A":
                    Console.WriteLine("T"); 
                    break;
                case "T":
                    Console.WriteLine("A");
                    break;
                case "G":
                    Console.WriteLine("C");
                    break;
                case "C":
                    Console.WriteLine("G");
                    break;
            }
        }
    }
}

Measured memory_bytes: 11092
#include <iostream>
#include <queue>
#include <string.h>

using namespace std;

class Node{
public:
	int x, y, d, cost;
	Node(int x, int y, int d, int cost) : x(x), y(y), d(d), cost(cost) {}
	bool operator < (const Node &n) const { return cost > n.cost; }
};

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

int main(){
	int w, h;
	int op[4];
	int b[30][30];
	int c[30][30][4];
	while(cin >> w >> h){
		if(!(w||h)) break;
		memset(c, -1, sizeof(c));
		for(int i=0;i<h;i++){
			for(int j=0;j<w;j++) cin >> b[i][j];
		}
		for(int i=0;i<4;i++) cin >> op[i];
		priority_queue<Node> qu;
		qu.push(Node(0,0,0,0));
		while(!qu.empty()){
			Node nd = qu.top(); qu.pop();
			int x = nd.x, y = nd.y, d = nd.d, cost = nd.cost;
			if(c[x][y][d]!=-1) continue;
			c[x][y][d] = cost;
			for(int i=0;i<4;i++){
				int nx = x + dx[i], ny = y + dy[i];
				if(nx<0||nx>=h||ny<0||ny>=w) continue;
				if(b[x][y]!=4&&(b[x][y]+d)%4==i){
					qu.push(Node(nx,ny,i,cost));
				} else {
					qu.push(Node(nx,ny,i,cost+op[(4+i-d)%4]));
				}
			}
		}
		int ans = 9999999;
		for(int i=0;i<4;i++){
			if(c[h-1][w-1][i]!=-1) ans = min(ans,c[h-1][w-1][i]);
		}
		cout << ans << endl;
	}
}

Measured memory_bytes: 1052
import java.util.*

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    val n = sc.nextInt()
    val a = (0 until n).map { sc.next().toInt() }
    println(problem148d(n, a))
}

fun problem148d(n: Int, a: List<Int>): Int {
    var current = 1
    var count = 0
    for (i in 0 until n) {
        if (a[i] != current) {
            count++
        } else {
            current++
        }
    }
    if (count == n) return -1
    return count
}

Measured memory_bytes: 57248
N, M = map(int, input().split())
grp = []
for i in range(0, N):
	lst = []
	for j in range(0, N):
		lst.append(False)
	grp.append(lst)
for i in range(0, M):
	a, b = map(int, input().split())
	grp[a-1][b-1] = True
	grp[b-1][a-1] = True
memo = [False]
goal = [False]
for i in range(1, N):
	memo.append(True)
	goal.append(False)
queue = [[0, memo]]
cnt = 0
while queue != []:
	now = queue.pop(0)
	if now[1] == goal: cnt += 1
	else:
		for i in range(0, N):
			if grp[now[0]][i] and now[1][i]:
				newmemo = []
				for j in range(0, N):
					if i == j: newmemo.append(False)
					else: newmemo.append(now[1][j])
				queue.append([i, newmemo])
print(cnt)

Measured memory_bytes: 43120
// WeirdBugsButOkay

#include <bits/stdc++.h>

#define ll long long
#define ld long double
#define pii pair <int, int>
#define pll pair <ll, ll>
#define mp make_pair
#define pb push_back
#define ff first
#define ss second

using namespace std;

void solve()
{
    ll n, m;
    cin >> n >> m;
    ll x;
    cin >> x;
    ll c[n];
    ll a[n][m];
    for(ll i = 0; i < n; i++)
    {
        cin >> c[i];
        for(ll j = 0; j < m; j++)
            cin >> a[i][j];
    }
    ll lim = 1 << n;
    ll ans = 1e18;
    for(ll mask = 0; mask < lim; mask++)
    {
        ll cost = 0;
        ll val[m] = {0};
        for(ll i = 0; i < n; i++)
        {
            if(mask & (1 << i))
            {
                cost += c[i];
                for(ll j = 0; j < m; j++)
                    val[j] += a[i][j];
            }
        }
        bool cor = true;
        for(ll i = 0; i < m; i++)
            if(val[i] < x)
                cor = false;
        if(cor)
            ans = min(ans, cost);
    }
    if(ans != 1e18)
        cout << ans << endl;
    else cout << -1 << endl;
}

int main()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int q = 1;
    //cin >> q;
    for(int i = 1; i <= q; i++)
    {
    	solve();
    }
    return 0;
}

Measured memory_bytes: 3660
//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;

fn main() {
    let (a,b):(usize,usize);
    input!(a,b);
    let c=std::cmp::min(a,b);
    let d=std::cmp::max(a,b);
    for i in 0..d{
        print!("{}",c);
    }
    println!("");
}


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

using namespace std;

int main(int argc, const char * argv[]) {
    string S,T;
    cin >> S >> T;
    int count=0;
    for(int i=0; i<3; i++){
     if(S.at(i)==T.at(i)){
        count+=1;
    }
    }
    cout << count <<endl;
}
        


Measured memory_bytes: 256
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>

using namespace std;


int main(int argc, char** argv) {
    ios::sync_with_stdio(false);
    cin.tie(0);

    vector<int> A{1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};

    int k;
    cin >> k;
    cout << A[k - 1] << '\n';

    return 0;
}

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


typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef long double ld;

typedef set<int>::iterator sit;
typedef map<int,int>::iterator mit;
typedef vector<int>::iterator vit;

const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 3;

#define _  %  MOD
#define __ %= MOD

#define      each(it,s)        for(auto it = s.begin(); it != s.end(); ++it)
#define      sortA(v)          sort(v.begin(), v.end())
#define      sortD(v)          sort(v.begin(), v.end(), greater<auto>())
#define      fill(a)           memset(a, 0, sizeof (a))

#define      swap(a,b)        {a=a+b;b=a-b;a=a-b;}
#define      rep(i, n)         for(ll i = 0; i < (n); ++i)
#define      repA(i, a, n)     for(ll i = a; i <= (n); ++i)
#define      repD(i, a, n)     for(ll i = a; i >= (n); --i)
#define watch(x) cout << (#x) << " is " << (x) <<endl

#define fi first
#define se second
#define mp make_pair
#define pb push_back

#define fbo find_by_order
#define ook order_of_key

ll gcd(ll a,ll b){if(b==0) return a; else return gcd(b,a%b);}
ll power(ll x,ll y){ll res=1; while(y>0){if(y&1) res=res*x;y=y>>1;x=x*x;}return res;} // modular exponent

int main()
{
    ios_base::sync_with_stdio(false); // don't use printf and scanf
    cin.tie(NULL); // cout<<fixed<<setprecision
    ll a,b,c,k;
    cin>>a>>b>>c>>k;
    if(k<=a)
    {
        cout<<k<<'\n';
    }
    else if(k<=(a+b))
    {
        cout<<a<<'\n';
    }
    else
    {
        ll temp;
        temp=k-(a+b);
        cout<<a-temp<<'\n';
    }
    return 0;
}
// JUST ASK YOURSELF DID YOU GIVE YOUR BEST ? ISSE ZYADA
// KUCH KAR BHI NAHI SAKTE !! ENJOY AND GIVE YOUR BEST!!


Measured memory_bytes: 3652
#include<bits/stdc++.h>
#define ll long long int
#define pragi(a,b) for(ll i = a;i<b;i++)
#define pragj(a,b) for(ll j = a;j<b;j++)
#define pragk(a,b) for(ll k = a;k>=b;k--)
#define all(v) (v.begin(),v.end())
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define MP make_pair
#define MT make_tuple
#define F first
#define S second
#define KAKA ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
const int mod = 1e9 + 7;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<bool> vb;
typedef long double ld;
typedef pair<int, int> pii;
//typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef pair<ll, ll> pll;

int main()
{
    KAKA
    ll a,b,c,k;
    cin>>a>>b>>c>>k;
    if(k <= a) cout<<k<<"\n";
    else if(k <= (a + b)) cout<<a<<"\n";
    else if(k <= (a + b + c)) cout<<(2 * a) + b - k<<"\n";
}

Measured memory_bytes: 3636
#include <iostream>
#include <algorithm>
#include <string>
#include <cstdint>
#include <cmath>

int main() {
	std::int64_t x;
	std::cin >> x;

	std::int64_t a = 100, ans = 0;
	while (a < x) {
		a = a * 1.01;
		++ans;
	}

	std::cout << ans << std::endl;
}

Measured memory_bytes: 3636
n=int(input())
l=list(map(int,input().split()))
d=[0,0,0]
for i in l:
  if i%4==0:d[2]+=1
  elif i%2==0:d[1]+=1
  else:d[0]+=1
f=0
if d[-1]>=n//2:f=1
if d[0]<=d[-1]:f=1
print("Yes" if f else "No")


Measured memory_bytes: 15020
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
const ll Mod = 1000000007;
int main() {
  ll N;
  cin >> N;
  ll ans = 0;
  for (ll a = 1; a < N; a++) {
    ans += (N-1) / a;
  }
  cout << ans << endl;
  return 0;
}


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

using namespace std;

#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define ALL(r) r.begin(), r.end()
#define YES puts("YES")
#define Yes puts("Yes")
#define NO puts("NO")
#define No puts("No")
#define IMP puts("IMPOSSIBLE")
#define Imp puts("Impossible")
#define imp puts("impossible")
#define M1 puts("-1")
#define pb push_back

template <typename T>
ostream &operator<<(ostream &os, vector<T> &v)
{
    os << "{";
    rep(i, v.size()) os << v[i] << (i == (int)v.size() - 1 ? "" : ", ");
    os << "}";
    return os;
}
template <typename T>
T dup(T x, T y)
{
    return (x + y - 1) / y;
};
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) { std::fill((T *)array, (T *)(array + N), val); }
struct in
{
    const size_t n = 0;
    in() = default;
    in(size_t n) : n(n){};
    template <typename T>
    operator T()
    {
        T ret;
        cin >> ret;
        return ret;
    }
    template <typename T>
    operator vector<T>()
    {
        assert(n != 0);
        vector<T> ret(n);
        for (auto &x : ret)
            cin >> x;
        return ret;
    }
};

using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;

constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;

void Main()
{
    string s = in();
    string t;
    rep(i, s.size())
    {
        if (i % 2 == 0)
            t.pb(s[i]);
    }
    cout << t << endl;
}

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


Measured memory_bytes: 592
def main():
    r, D, x_2000 = [int(ele) for ele in input().split()]
    last_year = x_2000
    kotoshi = 0
    for i in range(2001, 2011):
        kotoshi = r * last_year - D
        print(kotoshi)
        last_year = kotoshi


if __name__ == "__main__":
    main()


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

int main(){
    int a,b,c;
    cin >> a >> b >> c;
  	int d;
    d = c - (a - b);
    if(d > 0){
        cout << d << endl;
    }
    else
    {
        cout << 0 << endl;
    }
    
}

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

int main() {
    string n, ans = "No";
    cin >> n;
    if (n[0] == n[1] && n[1] == n[2]) ans = "Yes";
    else if (n[1] == n[2] && n[2] == n[3]) ans = "Yes";
    cout << ans << endl;

    return 0;
}

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

const long long mod = 1e9 + 7;

using ll = long long;
using pii  = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>

#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)

#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()

#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair

#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)

ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }

int main(){
    int h, w;
    cin >> h >> w;
    vector<vi> c(10, vi(10));
    rep(i, 10) rep(j, 10) cin >> c[i][j];
    vector<vi> a(h, vi(w));
    rep(i, h) rep(j, w) cin >> a[i][j];
    vector<vpii> g(10);
    rep(i, 10) rep(j, 10) g[i].emplace_back(j, c[j][i]);
    priority_queue<pii, vpii, greater<pii>> q;
    vi dist(10, INF);
    q.emplace(0, 1);
    dist[1] = 0;
    while (!q.empty()) {
        auto p = q.top(); q.pop();
        int d = p.first, v = p.second;
        if (d > dist[v]) continue;
        for (auto t : g[v]) {
            int nt = t.first, nd = d + t.second;
            if (nt == v) continue;
            if (dist[nt] <= nd) continue;
            q.emplace(nd, nt);
            dist[nt] = nd;
        }
    }
    int ans = 0;
    rep(i, h) rep(j, w) {
        if (a[i][j] == -1) continue;
        ans += dist[a[i][j]];
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 3824
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define zero_pad(num) setfill('0') << std::right << setw(num)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;

int main() {
    int h, w;
    cin >> h >> w;
    vector<vector<int>> a(h, vector<int>(w));
    vector<vector<int>> b(h, vector<int>(w));
    rep(i, h)rep(j, w)cin >> a[i][j];
    rep(i, h)rep(j, w)cin >> b[i][j];
    int N = 160 * 160;
    vector<vector<vector<int>>> dp(h, vector<vector<int>>(w, vector<int>(N+1, 0)));
    rep(i, h)rep(j, w){
        if(i == 0 && j == 0){
            dp[i][j][N/2+a[i][j]-b[i][j]] = 1;
            dp[i][j][N/2+b[i][j]-a[i][j]] = 1;
        }else{
            if(j > 0){
                rep(k, N+1){
                    if(dp[i][j-1][k]){
                        dp[i][j][k+a[i][j]-b[i][j]] = 1;
                        dp[i][j][k-a[i][j]+b[i][j]] = 1;
                    }
                }
            }
            if(i > 0){
                rep(k, N+1){
                    if(dp[i-1][j][k]){
                        dp[i][j][k+a[i][j]-b[i][j]] = 1;
                        dp[i][j][k-a[i][j]+b[i][j]] = 1;
                    }
                }
            }
        }
    }
    int ans = 1001001001;
    rep(k, N+1){
        if(dp[h-1][w-1][k]){
            ans = min(ans, abs(k-N/2));
        }
    }
    cout << ans << endl;
}

Measured memory_bytes: 648704
function Main(input) {
  const lines = input.split('\n');
  const line = lines[0].split(' ').map(i => parseInt(i));
  const N = line[0];
  const X = line[1];
  const T = line[2];
  let answer = Math.ceil(N / X) * T
  console.log(answer);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


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

void compress(vector<int>& a) {
	vector<int> tmp = a;
	sort(tmp.begin(), tmp.end());
	tmp.resize(unique(tmp.begin(), tmp.end()) - tmp.begin());
	for(int& x : a) {
		int j = lower_bound(tmp.begin(), tmp.end(), x) - tmp.begin();
		x = j;
	}
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	int n;
	cin >> n;
	vector<int> a(n);
	for(int& x : a) cin >> x;
	compress(a);
	reverse(a.begin(), a.end());
	vector<int> lis(n+1, INT_MAX);
	int ans = 1;
	lis[0] = -1;
	for(int i = 0; i < n; i++) {
		int x = a[i];
		
		int lo = 0, hi = n-1;
		while(lo < hi) {
			int mid = lo + (hi - lo + 1)/2;
			if(lis[mid] <= x) {
				lo = mid;
			} else {
				hi = mid-1;
			}
		}
		lis[lo+1] = min(lis[lo+1], x);
		ans = max(ans, lo+1);
	}
	
	cout << ans << endl;
}


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

#define rep(X,N) for(ll X = 0; X < (N); X++)
#define PI (acos(-1.0))
#define pback push_back
#define mpair make_pair
#define MODN 1000000007
#define ALL(V) (V).begin(),(V).end()
#define INT_MAX_HALF (INT_MAX / 2)
#define EPS (1e-10)

using namespace std;
typedef long long ll;

int main(){
    
    int n, m;
    cin >> n >> m;

    vector<int> h(n + 1);

    rep(i, n){
        cin >> h[i + 1];
    }

    vector<vector<int>> edge(n + 1);

    rep(i, m){
        int a,b;
        cin >> a >> b;

        edge[a].pback(b);
        edge[b].pback(a);
    }

    int ans = 0;

    for(int i = 1; i <= n; i++){
        int size = edge[i].size();
        bool higher = true;

        rep(j, size){
            if(h[i] <= h[edge[i][j]]){
                higher = false;
                break;
            }
        }

        if(higher) ans++;
    }

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


Measured memory_bytes: 8800
def wa(y):
  if y <= 1911:
    return "M" + str(y - 1867)
  elif y  <= 1925:
    return "T" + str(y - 1911)
  elif y <= 1988:
    return "S" + str(y - 1925)
  else:
    return "H" + str(y - 1988)
def sei(e, y):
  if e == 1:
    return y + 1867
  elif e == 2:
    return y + 1911
  elif e == 3:
    return y + 1925
  else:
    return y + 1988 
e, y = map(int, input().split())
if e == 0:
  print(wa(y))
else:
  print(sei(e, y))


Measured memory_bytes: 5600
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;

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

int PT[10] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 2};
int QT[10] = {1, 1, 1, 2, 2, 3, 2, 2, 3, 3};
int RT[10] = {2, 3, 4, 3, 4, 4, 3, 4, 4, 4};

int main()
{
    int N, D, X;
    cin >> N >> D >> X;
    int A[N];
    REP(i,N)
    {
        cin >> A[i];
    }
    int ans = 0;
    int temp;
    REP(i,N)
    {
        temp = 0;
        temp = (D - 1) / A[i];
        ++temp;
        ans += temp;
    }
    cout << ans + X << endl;
}

Measured memory_bytes: 256
fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

#[derive(Clone, Copy, Eq, PartialEq)]
enum State {
    Unvisited,
    Visiting,
    Visited,
}

fn main() {
    use std::cmp::{max, min};
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let n: usize = scan(tokens);
    let mut dag: Vec<Vec<Vec<(usize, usize)>>> = vec![vec![Vec::new(); n + 1]; n + 1];
    for i in 1..n + 1 {
        let mut a_prev: usize = scan(tokens);
        for _ in 2..n {
            let a_next: usize = scan(tokens);
            dag[min(i, a_prev)][max(i, a_prev)].push((min(i, a_next), max(i, a_next)));
            a_prev = a_next;
        }
    }
    let mut state = vec![vec![State::Unvisited; n + 1]; n + 1];
    let mut height = vec![vec![0; n + 1]; n + 1];
    let mut ans = 0;
    for i in 1..n + 1 {
        for j in i + 1..n + 1 {
            if state[i][j] == State::Unvisited {
                if let Some(h) = dfs((i, j), &mut state, &mut height, &dag) {
                    ans = max(ans, h);
                } else {
                    println!("-1");
                    return;
                }
            }
        }
    }
    println!("{}", ans);
}

fn dfs(
    (i, j): (usize, usize),
    state: &mut Vec<Vec<State>>,
    height: &mut Vec<Vec<usize>>,
    dag: &Vec<Vec<Vec<(usize, usize)>>>,
) -> Option<usize> {
    match state[i][j] {
        State::Unvisited => {
            state[i][j] = State::Visiting;
            let mut ans = 1;
            for &kl in &dag[i][j] {
                if let Some(h) = dfs(kl, state, height, dag) {
                    ans = std::cmp::max(ans, h + 1);
                } else {
                    return None;
                }
            }
            state[i][j] = State::Visited;
            height[i][j] = ans;
            Some(ans)
        }
        State::Visiting => None,
        State::Visited => Some(height[i][j]),
    }
}


Measured memory_bytes: 78328
#include<iostream>
int main()
{
	int n = 0, m = 0;
	int countAC = 0;
	int countsumWA = 0;
	int temp = 0;
	std::cin >> n >> m;
	bool* test = new bool[n + 1];
	int* countWA = new int[n + 1];
	for (int i = 0; i <= n; i++)
	{
		test[i] = 0;
		countWA[i] = 0;
	}
	for (int i = 0; i < m; i++)
	{
		int temp_th = 0;
		std::string s1;
		std::cin >> temp_th >> s1;
		if (test[temp_th]==0)
		{
			if (s1 == "AC")
			{
				countAC++;
				test[temp_th] = 1;
			}
			else
			{
				countWA[temp_th]++;
			}
		}
	}
	for (int i = 1; i <= n; i++)
	{
		if (test[i] == 1)
		{
			countsumWA += countWA[i];
		}
	}
	std::cout << countAC << ' ' << countsumWA;
	return 0;
}

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

#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T>
T gcd(T a, T b) { return ((a % b == 0) ? b : gcd(b, a % b)); }
template <typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;

namespace Problem {
using namespace std;
struct UnionFind {
  vector<int> par;  //par: -1*elements(root)  par(not root)
  UnionFind(int n) { par = vector<int>(n, -1); }
  int root(int x) { return par[x] < 0 ? x : (par[x] = root(par[x])); }
  void unite(int x, int y) {
    x = root(x);
    y = root(y);
    if (x != y) {
      if (par[x] < par[y]) swap(x, y);
      par[y] += par[x];
      par[x] = y;
    }
  }
  bool is_root(int x) { return root(x) == x; }
  bool same(int x, int y) { return root(x) == root(y); }
  int size(int x) { return -par[root(x)]; }
};

class Solver2 {
 public:
  int n, m;
  UnionFind uf;
  Solver2(LL n, LL m) : n(n), m(m), uf(n){};

  void solve() {
    for (int i = 0; i < m; ++i) {
      int x, y, z;
      cin >> x >> y >> z;
      uf.unite(--x, --y);
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
      if (uf.is_root(i)) ans++;
    }
    cout << ans << endl;
  }
};
}  // namespace Problem

int main() {
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(false);
  // std::cout << std::fixed << std::setprecision(12);
  long long n = 0, m = 0;
  std::cin >> n >> m;

  Problem::Solver2 sol(n, m);
  sol.solve();
  return 0;
}


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

int main(){
    int n,m;
    cin >> n >> m;
    int l,r;
    l=0;
    r=100000;
    for(int i=0; i<m; i++){
        int p,q;
        cin >> p >> q;
        l = max(l, p);
        r = min(r,q);
    }
    cout << max(0,r-l+1) << endl;
}

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

int main() {
  int A,B;
  string op;
  cin >> A >> op >> B ;
  
  if ( op=="+" ) {
    cout << A+B <<endl;
  }
  else if ( op=="-" ) {
    cout << A-B <<endl;
  }
}


Measured memory_bytes: 3620
#include <iostream>
#include <bitset>
#include <string>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <numeric>
#include <array>
#include <queue>
#include <set>
#include <iomanip>
#include <limits>
#include <type_traits>
using namespace std;
using ll = long long int;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
#define REP(i,n) for(int i=0;i<n;i++)

int main()
{
  ll L, R;
  cin >> L >> R;

  ll MOD = 2019;
  ll ans = 2019;

  if (R - L > 5000)
  {
    cout << 0 << endl;
  }
  else
  {
    for (ll i = L; i < R; i++)
    {
      for (ll j = i+1; j <= R; j++)
      {
        chmin(ans, i*j % MOD);
      }
    }

    cout << ans << endl;
  }
}

Measured memory_bytes: 256
/**
 * @author ayaankhan98
 */
#include <bits/stdc++.h>

using namespace std;

#define INF ULLONG_MAX
#define FIO                                                                    \
  ios_base::sync_with_stdio(0);                                                \
  cin.tie(0);                                                                  \
  cout.tie(0);
#define setz(x) memset(x, 0, sizeof(x))
#define seto(x) memset(x, 1, sizeof(x))
#define PI 3.1415926535897932384626

#define logs(a)                                                                \
  {                                                                            \
    cout << #a << " : [";                                                      \
    for (auto &x : a)                                                          \
      cout << x << ", ";                                                       \
    cout << "]\n";                                                             \
  }

#define loga(a)                                                                \
  {                                                                            \
    cout << #a << " :\n[\n";                                                   \
    for (auto x : a)                                                           \
      cout << "  " << x.first << " : " << x.second << "\n";                    \
    cout << "]\n";                                                             \
  }

#define debug(...) (debugPrint(#__VA_ARGS__ " : ", __VA_ARGS__))
template <typename... Args>
void debugPrint(const char *label, Args &&... args) {
  cout << "\n[";
  auto l = [](auto &&arg) {
    std::cout << std::forward<decltype(arg)>(arg) << ", ";
  };
  std::cout << label;
  (l(std::forward<Args>(args)), ...);
  cout << "\b\b]\n";
}

auto ONLINE = []() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
};

void solve() {
  /// write your code here
  string s;
  cin >> s;
  if (s[s.length() - 1] != 's') {
    s.append(1, 's');
    cout << s;
    return;
  }
  s.append("es");
  cout << s;
}

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


Measured memory_bytes: 3664
n = int(input())
h = list(map(int,input().split()))

res = []
count = 0
for i in range(n-1):
  if h[i] >= h[i+1]:
    count += 1
    if i == (n-2):
      res.append(count)
  else:
    if count != 0: 
      res.append(count)
    count = 0

if len(res) == 0:
  print(0)
else:
  print(max(res))

Measured memory_bytes: 14252
#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main(void){
    char w[10] ; 
    char t[1000] ;
    int i ;
    int count = 0 ;
    
    scanf("%s" , w) ;
    
    while(1){
        scanf("%s" , t) ;
        if(strcmp(t , "END_OF_TEXT") == 0){
            break;
        }
        else{
            for(i = 0 ; t[i] != '\0' ; i++){
                if(t[i] >= 'A' && t[i] <= 'Z'){
                    t[i] = tolower(t[i]) ;
                }
            }
            if(strcmp(t , w) == 0){
                count++;
            }
        }
    }
    printf("%d\n" , count) ;
    
    return 0;
}


Measured memory_bytes: 2052
s = input()
t = input()
alp = "abcdefghijklmnopqrstuvwxyz"
S = ""
T = ""
for i in range(len(alp)):
    for j in range(len(s)):
        if alp[i] == s[j]:
            S += s[j]
for i in range(len(alp)):
    for j in range(len(t)):
        if alp[i] == t[j]:
            T += t[j]
TT = T[::-1]
if S < TT:
    print("Yes")
else:
    print("No")

Measured memory_bytes: 3064
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <vector>

using namespace std;

int64_t calc_bit_in_period(int64_t a, int64_t b, int64_t d)
{
    const int64_t m = 1ll << d;
    if (b < m)
    {
        return 0;
    }
    else
    {
        return b - max(a, m) + 1;
    }
}

int64_t calc_bit(int64_t a, int64_t b, int64_t d)
{
    const int64_t period = 2ll << d;
    const int64_t la = (a / period) * period;
    const int64_t ra = la + period;
    if (la <= b && b < ra)
    {
        return calc_bit_in_period(a % period, b % period, d) % 2;
    }
    else
    {
        const int64_t a1 = calc_bit_in_period(a % period, period - 1, d);
        const int64_t a2 = calc_bit_in_period(0, b % period, d);

        if (d == 0)
        {
            const int64_t num_range = b / period - a / period - 1;
            return (a1 + a2 + num_range) % 2;
        }
        else
        {
            return (a1 + a2) % 2;
        }
    }
}

int main()
{
    int64_t a, b;
    cin >> a >> b;
    int64_t ans = 0;
    for (int d = 0; d <= 50; d++)
    {
        ans += (calc_bit(a, b, d) << d);
    }
    cout << ans << endl;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
 
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef int ftype;
 
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second 
#define debug(x)  do{cerr<<#x<<": "<<x<<"\n";}while(0)
#define debugv(x) do{cerr<<#x<<": ";for(auto&e: (x))cerr<<e<<" ";cerr<<"\n";}while(0)
#define fori(i, n) for (int i = 0; i < (int)(n); ++i)
#define forn(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n); i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define RETURN(x) do{cout << x << '\n'; return 0;}while(0)
#define FIRSTWIN do{cout << "Monocarp\n"; return 0;}while(0)
#define SECONDWIN do{cout << "Bicarp\n"; return 0;}while(0)

const int MAXN = 2e3+5;
const int MOD = 1e9+7;
const LL INF = 1e18+1;

int N;
int L[MAXN];
int ans;

int main() {
#ifdef OJ
    freopen("input.txt", "rt", stdin);
    //freopen("output.txt", "wt", stdout);
#endif
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> N;
    fori(i,N) cin >> L[i];
    sort(L,L+N);

    fore(i,2,N-1) {
        int j = 0;
        int k = i-1;
        while(j < i-1) {
            while(k > j && L[j]+L[k] > L[i]) --k;
            ans += i-max(k,j)-1;
            ++j;
        }
    }

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


Measured memory_bytes: 256
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#include <bits/stdc++.h>
 
#if DEBUG
    #include "debug.h"
#else
    #define debug(args...)
#endif    

using namespace std;

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


#define M 1000000 
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define fill(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
#define FOR(i,a,b) for(int i = a; i<=b; ++i)
#define NFOR(i,a,b) for(int i = a; i>=b; --i)
#define fast ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int INF = INT_MAX;
const int mod = 1e9+7;

const int N = 2e5 + 10;
inline int add(int x,int y){
  x += y;
  if(x >= mod) x -= mod;
  return x;
}
inline int mul(int x,int y){
  x = (1LL * x * y) % mod;
  return x;
}
clock_t time_p=clock();



int32_t main(){
  fast;

  //freopen("in.txt","r",stdin);
  //freopen("out.txt","w",stdout);

  string s;
  cin >> s;
  if(s[2] == s[3] and s[4] == s[5])cout << "Yes\n";
  else cout << "No\n";


  time_p=clock()-time_p;
  cerr<<"\nTime Taken : "<<(float)(time_p)/CLOCKS_PER_SEC<<"\n";

  return 0;
}

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

int main(){
  ll N,A,B;
  cin>>N>>A>>B;
  vector<ll> X(N);
  for(int i=0;i<N;i++){
    cin>>X.at(i);
  }

  ll ans=0;
  for(int i=1;i<N;i++){
    ans+=min(B,A*(X.at(i)-X.at(i-1)));
  }
  cout<<ans<<endl;
}


Measured memory_bytes: 1024
<?php
  list($n,$k) = explode(" ", trim(fgets(STDIN)));

  $l=[];
  $r=[];
  $s=[];
  for ($i=0; $i<$k; $i++) {
    list($l[],$r[]) = explode(" ", trim(fgets(STDIN)));
  }

  $ans=array_fill(0,$n+1,0);
  $ans[1]=1;
  $range=array_fill(0, $k, 0);
  for ($j=0; $j<$k; $j++){
    if($l[$j]<=1 && $r[$j]>=1){
      $range[$j]=1;
    }
  }
  for ($i=2; $i<=$n; $i++) {
    for ($j=0; $j<$k; $j++){
      $ans[$i]+=$range[$j];
      $ans[$i]%=998244353;
    }
    for ($j=0; $j<$k; $j++){
      if($i-$l[$j]+1>=1){
        $range[$j]+=$ans[$i-$l[$j]+1];
        $range[$j]%=998244353;
      }
      if($i-$r[$j]>=1){
        $range[$j]-=$ans[$i-$r[$j]];
        if($range[$j]<0){
          $range[$j]+=998244353;
        }
      }
//      echo $range[$j]." ";
    }
//    echo PHP_EOL;
  }
//  var_dump($ans);
  echo $ans[$n];

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

#define rep(i,n) for(long long int (i)=0;(i)<(int)(n);(i)++)
#define rrep(i,a,b) for(long long int i=(a);i<(b);i++)
#define rrrep(i,a,b) for(long long int i=(a);i>(b);i--)
#define all(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
#define P pair<int,int>
#define Abs(a,b) max(a,b)-min(a,b)
#define YES(condition) if(condition){cout << "YES" << endl;}else{cout << "NO" << endl;}
#define Yes(condition) if(condition){cout << "Yes" << endl;}else{cout << "No" << endl;}
#define Cout(x) cout<<(x)<<endl

typedef long long ll;

using namespace std;

const int INF = 1e9,MOD = 1e9 + 7;
const ll LINF = 1e18;

//while(x!=0){
            //sum+=x%10;
           // x/=10;
        //}
        //各桁の和

//pair<int,int> p[100000];
//P r[100000];
//cin >> tmp;
//p[i]=make_pair(tmp,i);
//cout << p[i].second+1 << endl;//ペアの右側つまりiを出力

//s.find(w[i])==string::npos
//findの使い方

//for(int i=0;i<n;i++){
   // b[i]=x%2;
    //x/=2;
  //}二進数

long long int n=1,cnt=0,ans=0,a,b,c,cmp,data,m,h,x,y,xcmp=0,ycmp=0,sum=0;

string s,w;

vector<int> z;

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

       cin >> n;
       cout << "ABC" << n << endl;
return 0;
}


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

int main() {
  int N;
  cin >> N;
  vector<int> moti(N);
  for (int i=0; i<N ; i++){
    cin >> moti.at(i);
  }
  int count=1;
  sort(moti.begin(),moti.end());
  for (int i=1; i<N ;i++){
    if (moti.at(i-1)!=moti.at(i)){
      count=count+1;
    }
  }
  cout << count << endl;

}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//typedef __int128 lll;
#define print(i) cout << "debug: " << i << endl
#define close() ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define mem(a, b) memset(a, b, sizeof(a))
const ll mod = 1e9 + 7;
const int maxn = 5e5 + 10;
const int inf = 0x3f3f3f3f;
struct node
{
    int l, r, sum;
    node(int l = 0, int r = 0, int sum = 0) : l(l), r(r), sum(sum){};
}t[maxn * 50];
int root[maxn];
int tot;

void build(int &tar, int l, int r)
{
    tar = ++tot;
    t[tar].sum = 0;
    if(l == r) return;
    int mid = l + r >> 1;
    build(t[tar].l, l, mid), build(t[tar].r, mid + 1, r);
}

void update(int pre, int &now, int l, int r, int pos, int val)
{
    now = ++tot;
    t[now] = t[pre];
    t[now].sum += val;
    if(l == r) return;
    int mid = l + r >> 1;
    if(pos <= mid) update(t[pre].l, t[now].l, l, mid, pos, val);
    else update(t[pre].r, t[now].r, mid + 1, r, pos, val);
}

int query(int posl, int tar, int l, int r)
{
    if(l == r) return t[tar].sum;
    int mid = l + r >> 1;
    if(posl <= mid) return t[t[tar].r].sum + query(posl, t[tar].l, l, mid);
    else return query(posl, t[tar].r, mid + 1, r);
}
map<int, int> vis;

int main()
{
    close();
    int n, q; scanf("%d%d", &n, &q);
    
    build(root[0], 1, n);
    for(int i = 1; i <= n; i++)
    {
        int x; scanf("%d", &x);
        if(!vis[x]) vis[x] = i, update(root[i - 1], root[i], 1, n, i, 1);
        else update(root[i - 1], root[i], 1, n, vis[x], -1), vis[x] = i, update(root[i], root[i], 1, n, i, 1);
    }
    while(q--)
    {
        int l, r; scanf("%d%d", &l, &r);
        cout << query(l, root[r], 1, n) << endl;
    }
}

Measured memory_bytes: 322692
n = int(input())
#a, b, c, x, y = map(int, input().split())
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
s = list(input())
ans = 0


for i in range(1000):
    t = ''
    t += str(i % 10)
    t += str((i//10) % 10)
    t += str(i//100)
    t = t[::-1]
    i = 0
    j = 0
    while i < n and j < 3:
        if s[i] == t[j]:
            j += 1
        i += 1
    if j == 3:
        ans += 1
print(ans)


Measured memory_bytes: 71756
#include<stdio.h>
int left[4];
int right[4];
int main(){
	double a,b;
	while(~scanf("%lf%lf",&a,&b)){
		if(a<0.2)left[3]++;
		else if(a<0.6)left[2]++;
		else if(a<1.1)left[1]++;
		else left[0]++;
		if(b<0.2)right[3]++;
		else if(b<0.6)right[2]++;
		else if(b<1.1)right[1]++;
		else right[0]++;
	}
	for(int i=0;i<4;i++)printf("%d %d\n",left[i],right[i]);
}

Measured memory_bytes: 0