akhauriyash/Code-Regression huggingface dataset:
#include <vector>
#include <iostream>
#include <utility>
#include <algorithm>
#include <string>
#include <deque>
#include <queue>
#include <tuple>
#include <queue>
#include <functional>
#include <cmath>
#include <iomanip>
#include <map>
#include <set>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#include <complex>
#include <iterator>
#include <array>
#include <memory>
#include <stack>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define all(in) in.begin(), in.end()
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double,double>pdd;
typedef pair<ll,ll>pll;
int main(){
    vi v(5,0);
    rep(i,5){cin>>v[i]; v[i]<40 ? v[i]=40:v[i]=v[i];}
    rep(i,5)if(i)v[i]+=v[i-1];
    //cout<<v[4]<<endl;
    cout<<v[4]/5<<endl;
}

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


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

    int sum = 0;
    while(s.size() > 1) {
        sum = 0;
        for(int i=0;i<s.size();i++) {
            sum+=s[i] - '0';
        }
        s = to_string(sum);
    }
    if((s[0] - '0') == 9 || s[0] == '0') {
        puts("Yes");
    }
    else {
        puts("No");
    }
    return 0;
}


Measured memory_bytes: 3820
N, M, X, Y = map(int, input().split())
x = [int(i) for i in input().split()]
y = [int(i) for i in input().split()]
f3 = False
for z in range(X+1, Y+1):
    f1 = True
    for i in range(N):
        if x[i] >= z:
            f1=False

    for i in range(M):
        if y[i] < z:
            f1=False

    if f1==True:
        print('No War')
        exit()

print('War')


Measured memory_bytes: 3064
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(ll i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;

int main(){
	cin.tie(0); ios::sync_with_stdio(false);
	
	ll h, a;
	cin >> h >> a;
	print((h+a-1)/a)
	return 0;
}

Measured memory_bytes: 256
#include <cstdio>
using namespace std;
int v[100001];
bool chk[100001];
int main() {
    int n; scanf("%d",&n);
    for(int i=1; i<=n; i++) {
        scanf("%d", &v[i]);
    }
    int x, cnt=0;
    for(int i=1; i<100001; i++) {
        if(chk[i]) continue;
        if(v[i]==i) continue;
        x=v[i];
        if(v[x]==i) {
            chk[x]=chk[i]=true;
            cnt++;
        }
    }
    printf("%d\n", cnt);
    return 0;
}

Measured memory_bytes: 640
#include <sstream>
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <set>
#include <stack>

using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for(ll i = n - 1; i >= 0; i--)
#define repone(i, n) for(ll i = 1; i <= (ll)(n); i++)
#define each(i, mp) for(auto i:mp)
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll half_inf = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);
typedef unordered_map<ll, ll> ump;
typedef pair<ll, ll> P;

ump mp;
int n, a, b, c;
vector<int> l;
ll ans;

void dfs(ll len_a, ll len_b, ll len_c, ll idx, ll mp) {
    if (idx == n) {
        if (len_a * len_b * len_c == 0) return;
        ans = min(ans, mp + abs(len_a - a) + abs(len_b - b) + abs(len_c - c));
        return;
    }
    dfs(len_a + l[idx], len_b, len_c, idx + 1, len_a == 0 ? mp : mp + 10);
    dfs(len_a, len_b + l[idx], len_c, idx + 1, len_b == 0 ? mp : mp + 10);
    dfs(len_a, len_b, len_c + l[idx], idx + 1, len_c == 0 ? mp : mp + 10);
    dfs(len_a, len_b, len_c, idx + 1, mp);
}


void solve() {
    ans = ll_inf;
    dfs(0, 0, 0, 0, 0);
    cout << ans << endl;
}


int main() {
#ifdef MY_DEBUG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-noreturn"
    while (true) {
        mp = ump();
#pragma clang diagnostic pop
#endif
        cin >> n >> a >> b >> c;
        l.resize(n);
        rep(i, n) cin >> l[i];

        solve();

#ifdef MY_DEBUG
    }
#endif
    return 0;
}

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

int main() {
  string s;
  cin >> s;
  vector<bool> app(26,false);
  for(int i=0;s[i]!='\0';++i){
    app[s[i]-'a']=true;
  }
  for(int i=0;i<26;++i){
    if(!app[i]){
      cout << char(i+'a') << endl;
      return 0;
    }
  }
  cout << "None" << endl;
}


Measured memory_bytes: 512
#include<iostream>
#include<queue>
#include<utility>
#include<string>
using namespace std;
typedef pair<int, int>P;

string sand[1005];
int sara[1005][1005];
queue<P>now;
queue<P>nxt;

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

	for (int i = 0;i<h;i++)cin >> sand[i];

	for (int i = 0;i<h;i++) {
		for (int j = 0;j<w;j++) {
			if (sand[i][j] != '.') {
				for (int k = -1;k <= 1;k++) {
					for (int l = -1;l <= 1;l++) {
						if (sand[i + k][j + l] == '.')sara[i][j]++;
					}
				}
			}
		}
	}

	for (int i = 0;i<h;i++) {
		for (int j = 0;j<w;j++) {
			if (sand[i][j] != '.') {
				int a = sand[i][j] - '0';
				if (a <= sara[i][j]) {
					now.push(make_pair(i, j));
				}
			}
		}
	}

	int ans = 0;
	while (now.size()) {
		ans++;
		int a = now.size();
		queue<P>q;

		for (int i = 0;i < a;i++) {
			P p = now.front();
			now.pop();

			int f = p.first, s = p.second;

			if (sand[f][s]!='.'&&(sara[f][s] >= sand[f][s] - '0')) {
				sand[f][s] = '.';

				for (int j = -1;j <= 1;j++) {
					for (int k = -1;k <= 1;k++) {
						if (sand[f + j][s + k] != '.') { q.push(make_pair(f + j, s + k)); }
						sara[f + j][s + k]++;
					}
				}
			}
		}

		int b = q.size();
		for (int i = 0;i < b;i++) {
			P pa = q.front();
			q.pop();
			if ((sand[pa.first][pa.second] != '.') && sara[pa.first][pa.second] >= (sand[pa.first][pa.second] - '0'))nxt.push(pa);
		}

		queue<P>kari;
		now = nxt;
		nxt = kari;

	}

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

Measured memory_bytes: 8084
#define fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define mem(dp,i) memset(dp,i,sizeof(dp))
#define all(x) begin(x),end(x)
#define pii pair<int,int>
#include <bits/stdc++.h>
#define pll pair<ll,ll>
#define vi vector<int>
#define ld long double
#define ll long long
#define pb push_back
#define mid (l+r)/2
#define S second
#define F first
using namespace std;
const ll mod = 998244353;
int n;
int main(){
    fast,cin>>n;
    ld x = (ld)n/3;
    cout<<fixed<<setprecision(12)<<x*x*x<<endl;
}


Measured memory_bytes: 256
#include <bits/stdc++.h>
#include <stdlib.h>
#include <time.h> 
 
using namespace std;
long long mod=1e9+7;
long long INF=1e7;
double EPS = 1e-12;
typedef long long int lld;
double tick(){static clock_t oldt;clock_t newt=clock();double diff=1.0*(newt-oldt)/CLOCKS_PER_SEC;oldt = newt;return diff;}
#define rep(i,a,n) for(long long int i = (a); i <= (n); ++i)
#define repI(i,a,n) for(int i = (a); i <= (n); ++i)
#define repD(i,a,n) for(long long int i = (a); i >= (n); --i)
#define repDI(i,a,n) for(int i = (a); i >= (n); --i)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define sc(a) scanf("%lld",&a)
#define sc2(a,b) scanf("%lld%lld",&a,&b)
#define sc3(a,b,c) scanf("%lld%lld%lld",&a,&b,&c)
#define scd(a) scanf("%d",&a)
#define scd2(a,b) scanf("%d%d",&a,&b)
#define scd3(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define scf(a) scanf("%lf",&a)
#define scf2(a,b) scanf("%lf%lf",&a,&b)
#define scf3(a,b,c) scanf("%lf%lf%lf",&a,&b,&c)
#define prL(a) printf("%lld\n",a)
#define prS(a) printf("%lld ",a)
#define prdL(a) printf("%d\n",a)
#define prdS(a) printf("%d ",a)
#define all(c) c.begin(), c.end()
#define sz(a) ((int)a.size())
#define Error(x) cout<< #x << " = " << (x) <<endl;
#define Error2(a,b) cout<<"( "<<#a<<" , "<<#b<<" ) = ( "<<(a)<<" , "<<(b)<<" )\n";
#define Error3(a,b,c) cout<<"("<<#a<<" , "<<#b<<" , "<<#c<<" ) = ( "<<(a)<<" , "<<(b)<<" , "<<(c)<<")\n";
#define Error4(a,b,c,d) cout<<"("<<#a<<" , "<<#b<<" , "<<#c<<" , "<<#d<<" ) = ( "<<(a)<<" , "<<(b)<<" , "<<(c)<<" , "<<(d)<<")\n";
#define errop(a) cout<<#a<<" = ( "<<((a).x)<<" , "<<((a).y)<<" )\n";
#define mset(a, v) memset(a, v, sizeof(a))
#define popcount __builtin_popcountll
 
typedef pair<lld,lld> PA;
 
lld powP(lld a,lld b){
    if(b==0) return 1%mod;
    lld k;
    k=powP(a,b/2);
    k=k*k%mod;
    if(b%2==0) return k;
    else return a*k%mod;
}
 
bool bitSet(lld n,lld i){
    if((n&(1LL<<i))!=0) return true;
    else return false;
}
 
lld findGcd(lld a,lld b){
    if(a==0) return b;
    else return findGcd(b%a,a);
}
 
#define lim 500010
#define lim2 200003
#define qqqqqq 210
// inline lld sqr(lld x) { return x * x; }
// unordered_map<lld,lld>::iterator it;
// std::ios::sync_with_stdio(false);
// priority_queue<PA> Q;
// lld dp[1<<18];
// vector<lld> V[lim];
// int X[lim],Y[lim],C[lim];
// string S[lim];
lld A[lim],B[lim];
// map<lld,lld> M;

lld nCr(lld n,lld r){
    if(r > n) return 0;
    else return B[n]*powP(B[r]*B[n-r]%mod,mod-2)%mod;
}
lld M[lim],X[lim];
int main(){
    lld T,i,n,m,p,j,l,e,r,b,c,k,q,a,d,w,x,y,v,z,t,curr,prev,sum,ans,pos,val,countA,indicator;
    B[0] = 1;
    rep(i,1,lim-1) B[i] = B[i-1]*i%mod;
    sc(n);
    rep(i,1,n+1){
        sc(k);
        if(X[k]==1){
            z = i - M[k] + 1;
        }
        X[k] = 1;
        M[k] = i;
    }
    prL(n);
    // Error(z);
    rep(i,2,n+1){
        val = (nCr(n+1,i) - nCr(n+1-z,i-1) + mod)%mod;
        prL(val);
    }
    return 0;
}

Measured memory_bytes: 12288
miu = input().split()

qurare = []

for x in range(int(miu[0])):
	if (x+1) >= int(miu[1]):
		qurare.append(1/int(miu[0]))
		continue

	delphine = 1
	while True:
		if (x+1) * 2 ** delphine >= int(miu[1]):
			qurare.append(1/int(miu[0]) * pow(0.5, delphine))
			break
		delphine += 1

print(sum(qurare))

Measured memory_bytes: 6296
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>

using namespace std;

#define MAX 100000
#define INF 2140000000
#define MOD 1000000007

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

	for (int i = 0; i < (int) s.size(); ++i) {
		cout << "x";
	}

	return 0;
}

Measured memory_bytes: 256
// luogu-judger-enable-o2
#include <bits/stdc++.h>
using namespace std;
long long st;
long long n,x,y,z;
int state;
const long long si=1e9+7;
long long dp[45][1<<17];
int main()
{
	scanf("%d%d%d%d",&n,&x,&y,&z);
	long long ans=1;
	for (int i=1;i<=n;i++)
	ans=(ans*10)%si;
	st=(1<<z-1)|(1<<z+y-1)|(1<<(x+y+z-1));
	state=(1<<x+y+z)-1;
	dp[0][0]=1;
	for (int i=1;i<=n;i++)
	  for (int j=0;j<=state;j++)
	    {
		  if (dp[i-1][j]==0)
		   continue;
		  for (int k=1;k<=10;k++)
		    {
			int noww=(j<<k)|(1<<k-1);
			noww=noww&state;
			if ((noww&st)!=st)
			 dp[i][noww]=(dp[i][noww]+dp[i-1][j])%si; 
			}
		}
	for (int i=0;i<=state;i++)
	  ans=(ans-dp[n][i]+si)%si;
	cout<<ans<<endl;
	return 0;
}


Measured memory_bytes: 41216
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (int)(n);i++)
using ll = long long;
const ll MOD=1000000007;
//const ll MOD=998244353;
const long long INF = 1LL << 60;
const double pi=acos(-1.0);
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};

template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }

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

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

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  // cout << fixed << setprecision(15);

  ll N,K; cin>>N>>K;
  vector<ll> A(N); rep(i,N) cin>>A[i];
  
  ll G=A[0]; rep(i,N) G=gcd(G,A[i]);
  ll M=*max_element(A.begin(),A.end());
  
  cout<<(M>=K&&K%G==0?"POSSIBLE":"IMPOSSIBLE")<<'\n';
  
  return 0;
}

Measured memory_bytes: 3932
#include <bits/stdc++.h>
using namespace std;
int main(){
    int n, l;
    cin >> n >> l; vector<string> v;
    while(n--){
        string s; cin >> s;
        v.push_back(s);
    }
    sort(v.begin(), v.end());
    for (int i = 0; i < v.size(); i++)
        cout << v[i];
    return 0;
}


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

using namespace std;

typedef long long ll;

int main () {
	ll n, y;
	ll i, j;
	bool flag =0;
	ll ret;
	
	cin >> n >> y;
	
	for ( i=0;i<=n;i++) {
		for (j=0;j<=(n-i);j++) {
			ret = 10000*i+5000*j+1000*(n-i-j);
			if (ret == y) {
				cout << i << " " << j << " " << (n-i-j) << endl;
				flag = 1;
				break;
			}
		}
		if (flag == 1) {
			break;
		}
	}
	
	if (flag == 0) {
		cout << -1 << " " << -1 << " " << -1 << endl;
	}
	
	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <limits>
#include <queue>
#include <iomanip>
#include <set>
//#include <bits/stdc++.h>

template<typename T> bool chmax(T &a,T b){
    if(a<b){
        a=b;
        return true;
    }
    return false;
}

template<typename T> bool chmin(T &a,T b){
    if(a>b){
        a=b;
        return true;
    }
    return false;
}

using namespace std;
#define ALL(X) X.begin(),X.end()
using ll = long long int;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
const int MOD=1000000007;
//const int MOD=998244353;
const int INTMAX=2147483647;
const ll LLMAX=9223372036854775807;


int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    ll N,x;
    cin>>N>>x;
    vll a(N);
    for(ll i=0;i<N;i++)cin>>a[i];
    
    ll ans=0;
    for(ll i=0;i<N;i++){
        if(a[i]>x){
            ans+=a[i]-x;
            a[i]=x;
        }
    }
    
    for(ll i=1;i<N;i++){
        if(a[i]+a[i-1]>x){
            ans+=a[i]+a[i-1]-x;
            a[i]-=a[i]+a[i-1]-x;
        }
    }
    cout<<ans<<endl;
    
    return 0;
}


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

int main(){
  int n;
  cin >> n;
  string s, t;
  cin >> s >> t;
  string ans = "";
  rep(i,n) {
    ans += s[i]; ans += t[i];
  }
  cout << ans << endl;
  return 0;
}

Measured memory_bytes: 256
#include<cstdio>
#include<iostream>
#include<string>
#include<stack>
#include<algorithm>
#include<cstdio>
#include<map>
#include<cmath>
#include<queue>
#include<iomanip>
#include<cstring>
#include<list>
#include<typeinfo>
#include<vector>

using namespace std;
const int maxn = 2e5+10;
int ans1,ans2,a[maxn],b[maxn],r[maxn],MAX;
int sc[maxn];
int xc[maxn];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i]>>b[i];
        sc[a[i]]++;
        xc[b[i]]++;
        r[a[i]]++;
        r[b[i]]--;
        MAX = max(MAX, b[i]);
    }
    for(int i = 1;i<= MAX;i++)
    {
        sc[i]+= sc[i-1];
        xc[i]+= xc[i-1];
    }
    for(int i=1; i<=n;i++)
        ans1=max(ans1,sc[b[i]-1]-xc[a[i]]);
    for(int i=1;i<=MAX;i++)
    {
        r[i]+=r[i-1];
        ans2 = max(ans2,r[i]);
    }
    cout<<ans1<<' '<<ans2<<endl;

    return 0;
}



Measured memory_bytes: 5852
#include <stdio.h>  
#include <algorithm>  
#include <assert.h>
#include <bitset>
#include <cmath>  
#include <complex>  
#include <deque>  
#include <functional>  
#include <iostream>  
#include <limits.h>  
#include <map>  
#include <math.h>  
#include <queue>  
#include <deque>
#include <set>  
#include <stdlib.h>  
#include <string.h>  
#include <string>  
#include <time.h>  
#include <unordered_map>  
#include <unordered_set>  
#include <vector>  
#include <chrono>
#include <random>
#include <time.h>
#include <fstream>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define all(c) begin(c),end(c)
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
void print(vec v){for(auto e:v)cout<<e<<" ";cout<<endl;}
void print(vecll v){for(auto e:v)cout<<e<<" ";cout<<endl;}
void print(map<int,int> mp){for(auto e:mp)cout<<e.first<<" "<<e.second<<endl;cout<<endl;}


#define INF 1e9+7
#define LLINF 1e18+7
const ll MOD=1e9+7;
const int N=500000;

main(){
    int n=in();
    string s;cin>>s;
    for(auto c:s){
        cout<<(char)('A'+(c-'A'+n)%26);
    }
}

Measured memory_bytes: 256
#include<iostream>
#include<algorithm>
#include<vector>
#include<numeric>
#include<string>
#include<cmath>
#include<set>
#include<queue>
#include<deque>
#include<bitset>
#include<iomanip>
#include<cctype>
#include<map>
#include<cstring>

#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep2(i,a,b) for (int (i)=a;(i)<(b);(i)++)
#define all(x) (x).begin(),(x).end()

using namespace std;
using ll = long long int;

const int inf = 1001001000;
const long long int Inf = 1001001001001001000;



void print(vector<vector<int>> a){
	for (int i = 0; i < a.size(); i++)
	{
		for (int j=0;j<a[i].size();j++){
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
}

void print(vector<vector<long long int>> a){
	for (int i=0;i<a.size();i++){
		for (int j=0;j<a[i].size();j++){
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
}

void print(vector<int> a){
    int n = a.size();
    for (int j=0;j<n;j++) {
        if (j != n-1) cout << a[j] << " ";
        else cout << a[j] << endl;
    }
}

void print(vector<long long int> a){
    int n = a.size();
    for (int j=0;j<n;j++) {
        if (j != n-1) cout << a[j] << " ";
        else cout << a[j] << endl;
    }
}

void print(set<int> a){
	for (auto x:a)
		cout << x << " ";
	cout << endl;
}


int main()
{
	int n;
	cin >> n;
	vector<int> a(n-1);
	vector<int> ans(n, 0);
	rep(i, n-1) cin >> a[i];
	rep(i,n-1){
		ans[a[i] - 1]++;
	}
	rep(i, n) cout << ans[i] << endl;

	return 0;
}

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

using namespace std;

using ll = long long;

inline bool IsACGT(char c) {
    return (c == 'A' || c == 'C' || c == 'G' || c == 'T');
}

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

    string s;
    cin >> s;

    int max_n = 0;
    for (int i = 0; i < s.size(); ++i) {
        for (int j = i; j < s.size(); ++j) {
            bool is_acgt = true;
            for (int k = i; k <= j; ++k)
                if (!IsACGT(s[k])) {
                    is_acgt = false;
                    break;
                }
            if (is_acgt) max_n = max(max_n, j - i + 1);
        }
    }
    cout << max_n << endl;

    return 0;
}


Measured memory_bytes: 256
def solve(n, a, b, c): 
    dp = [[0,0,0] for i in range(n)]
    v = [[a[i], b[i], c[i]] for i in range(n)]
    for i in range(3):
        dp[-1][i] = v[-1][i]
    for i in range(n-2, -1, -1):
        for j in range(3):
            for k in range(3):
                if j != k:
                    dp[i][j] = max(dp[i][j], dp[i+1][k] + v[i][j])
    return max(dp[0])

n = int(input())
a = [0] * n 
b = [0] * n 
c = [0] * n 
for i in range(n):
    a[i], b[i], c[i] = map(int, input().split())
print(solve(n, a, b, c)) 

Measured memory_bytes: 44852
#include <bits/stdc++.h>
#define MOD 1000000007
#define INF 1000000000
#define LINF 1000000000000000000
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define bit(n) (1LL<<(n))
using namespace std;

typedef pair<int, int> P;
typedef pair<long long, long long> LLP;

int main() {

    int N, M;
    cin >> N >> M;
    
    vector<int> a(M), b(M), d(M, 0);
    vector< vector<int> > c;
    rep(i,M) {
        cin >> a[i] >> b[i];
        vector<int> ci(b[i]);
        rep(j,b[i]) cin >> ci[j];
        rep(j,b[i]) ci[j]--;
        rep(j,b[i]) d[i] += bit(ci[j]);
        c.push_back(ci);
    }
    
    long long dp[M][bit(N)];

    rep(i,M) rep(j,bit(N)) dp[i][j] = j == 0 ? 0 : LINF;

    dp[0][d[0]] = a[0];
    for (int i = 1; i < M; i++) {
        for (int j = 0; j < bit(N); j++) dp[i][j] = dp[i - 1][j];
        for (int j = 0; j < bit(N); j++) {
            dp[i][j | d[i]] = min(dp[i][j | d[i]], min(dp[i - 1][j | d[i]], dp[i - 1][j] + a[i]));
        }
    }
    if (dp[M - 1][bit(N) - 1] >= LINF) cout << -1 << endl;
    else cout << dp[M - 1][bit(N) - 1] << endl;

    return 0;
}

Measured memory_bytes: 32384
using System;
using System.Linq;

namespace arc090_a
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[] x1 = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int[] x2 = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int ret = x1[0] + x2.Sum();
            int b = ret;
            for (int i = 1; i < n; i++)
            {
                int a = b - x2[i - 1] + x1[i];
                ret = Math.Max(ret,a);
                b = a;
            }
            Console.WriteLine(ret);
        }
    }
}

Measured memory_bytes: 13396
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int x, t;
    cin >> x >> t;
    if(t&1 or t < x*2 or t> x*4) {
        cout << "No" << endl;
    } else {
        cout << "Yes" << endl;
    }
}

Measured memory_bytes: 3644
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <iterator>
#include <functional>
#include <utility>
#include <algorithm>
#include <numeric>
#include <typeinfo>

using namespace std;

#define dump(n) cout<<"# "<<#n<<"="<<(n)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,n) repi(i,0,n)
#define iter(c) __typeof((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();++i)
#define allof(c) (c).begin(),(c).end()
#define mp make_pair

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int,int> pii;

int main()
{
	for(int q1,b,c1,c2,q2;cin>>q1>>b>>c1>>c2>>q2 && q1;){
		int a1=min(b/c1,q2);
		for(;;){
			if(a1==0){
				cout<<"NA"<<endl;
				break;
			}
			int a2=(b-a1*c1)/c2;
			if(a1+a2>=q1){
				cout<<a1<<" "<<a2<<endl;
				break;
			}
			a1--;
		}
	}
	
	return 0;
}

Measured memory_bytes: 0
import java.util.Scanner;

public class Main {

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

		if (K % 2 == 0) {
			System.out.println(K * K / 4);
		} else {
			System.out.println((K + 1) * (K - 1) / 4);
		}

		return;
	}
}


Measured memory_bytes: 20948
N = input()
A,B = list(map(int,input().split()))
P = list(map(int,input().split()))
c1 = [1 if x<=A else 0 for x in P]
c2 = [1 if (x>A and x<=B) else 0 for x in P]
c3 =[1 if x>B else 0 for x in P]
c1 = sum(c1)
c2 = sum(c2)
c3 = sum(c3)
print(min([c1,c2,c3]))

Measured memory_bytes: 3064
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000           // 2000000000
#define LINF 1000000000000000000 // 9000000000000000000
#define DINF 1000000000000000.0
#define PI 3.14159265358979

//.size()はunsigned int　0-1をするとオーバーフローする

using namespace std;
typedef long long int ll;
typedef pair<long long int, long long int> P;

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

int main(void) {
    long long int n,k,q;

    cin>>n>>k>>q;
    vector<long long int > a(q+1);
    vector<long long int > dp(n+1,0);
    FOR(i,1,q){
        cin>>a[i];
        dp[a[i]]++;
    }
    FOR(i,1,n){
        if(k-(q-dp[i])>0){
            cout<<"Yes"<<endl;
        }else{
            cout<<"No"<<endl;
        }
    }
}


Measured memory_bytes: 2176
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<iomanip>
#include<map>
#include<set>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;
#define DEBUG(x) cout<<#x<<"="<<x<<endl
#define DEBUG2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl
typedef long long ll;
// #define LOCAL
const int MAXN=2e5+10;
int N;
ll A[MAXN];
ll dp[MAXN];
ll opre[MAXN];
void solve()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>N;
    for(int u=1;u<=N;u++)cin>>A[u];
    for(int u=1;u<=N;u+=2){
        if(u==1)opre[u]=A[u];
        else opre[u]=opre[u-2]+A[u];
    }
    for(int u=1;u<=N;u++){
        if(u==1){
            dp[u]=0;
        }
        else if(u==2){
            dp[u]=max(A[u],A[u-1]);
        }
        else if(u&1){
            dp[u]=max(dp[u-1],dp[u-2]+A[u]);
        }
        else {
            dp[u]=max(dp[u-2]+A[u],opre[u-1]);
        }
    }
    cout<<dp[N];
}
int main()
{
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif
    solve();
}

Measured memory_bytes: 8268
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;



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

	int N, K,tmp=-1;
	cin >> N >> K;
	if (N == 2) {
		if (K == 0) {
			cout << 1 << endl;
			cout << 1 << " "<<2 << endl;
			return 0;
		}
		else {
			cout << -1 << endl;
			return 0;
		}
	}
	vector<pair<int, int> >ans;
	ans.push_back(make_pair(1, 2));


	int i = 1, cnt = 0;
	while (i<N-1) {
		tmp = (i + cnt) - K;
		ans.push_back(make_pair(2, i + 2));
		//cout << K-i-cnt << endl;
		//cout << i <<" "<< cnt << endl;
		cnt += i;
		i++;
		//cout << K << endl;
		//tmp = (i + cnt) - K;
	}
	//cout << tmp << endl;
	if (tmp < 0) {
		cout << -1 << endl;
		return 0;
	}
	if (tmp == 0) {
		cout << ans.size() << endl;
		REP(i, ans.size()) {
			cout << ans[i].first << " " << ans[i].second << endl;
		}
		return 0;
	}
	eFOR(i, 3, N) {
		ans.push_back(make_pair(1, i));
		tmp--;
		if (tmp == 0) {
			cout << ans.size() << endl;
			REP(i, ans.size()) {
				cout << ans[i].first << " " << ans[i].second << endl;
			}
			return 0;
		}
	}
	FOR(i, 3, N) {
		eFOR(j, i + 1, N) {
			ans.push_back(make_pair(i, j));
			tmp--;
			if (tmp == 0) {
				cout << ans.size() << endl;
				REP(i, ans.size()) {
					cout << ans[i].first << " " << ans[i].second << endl;
				}
				return 0;
			}
		}
	}

	cout << -1 << endl;
	
	/*REP(i, ans.size()) {
		cout << ans[i].first << " " << ans[i].second << endl;
	}*/
	return 0;
}



Measured memory_bytes: 512
# -*- coding: utf-8 -*-
"""
B - Uneven Numbers
https://atcoder.jp/contests/abc136/tasks/abc136_b

"""
import sys


def solve(N):
    return sum(len(str(i)) % 2 for i in range(1, N+1))


def main(args):
    N = int(input())
    ans = solve(N)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])


Measured memory_bytes: 3064
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const ll INF = 1LL << 60; //MAX 9223372036854775807

ll ans = 1;
const ll mo = 1000000007;
auto mod = [](ll modx) {modx%=mo;modx+=mo;modx%=mo;return modx; };

int main()
{
ll n , k ;
cin >> n >> k ;
vector<ll> a(n);
rep(i, n){
  cin >> a[i];
}
sort(a.begin(),a.end());
if(n==k){
  ll b=1;
  rep(i,n)b=mod(b*a[i]);
  cout << b << endl;
  return 0;
}
if(a[n-1]<0&&k%2){
  ll b=1;
  rep(i,k)b=mod(b*a[n-1-i]);
  cout << b << endl;
  return 0;
}
vector<ll> s;
vector<ll> f;
rep(i,n){
  if(a[i]<0)f.push_back(-a[i]);
  else s.push_back(a[i]);
}
sort(f.begin(),f.end());
sort(s.begin(),s.end());
reverse(f.begin(),f.end());
reverse(s.begin(),s.end());
ll nums=0,numf=0;
if(k%2){ans=s[0];nums++;}
while(k>numf+nums){
  if(nums+1<s.size()&&numf+1<f.size()){
    if(s[nums]*s[nums+1]>f[numf]*f[numf+1]){ans=mod(ans*mod(s[nums]*s[nums+1]));nums+=2;}
    else{ans=mod(ans*mod(f[numf]*f[numf+1]));numf+=2;}
  }
  else if(nums+1<s.size()){ans=mod(ans*mod(s[nums]*s[nums+1]));nums+=2;}
  else {ans=mod(ans*mod(f[numf]*f[numf+1]));numf+=2;}
}
cout << ans << endl;
return 0;
}

Measured memory_bytes: 7192
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
constexpr ll mod = 998244353;
const ll INF = mod * mod;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);

ll mod_pow(ll x, ll n, ll m) {
	ll res = 1;
	while (n) {
		if (n & 1)res = res * x % m;
		x = x * x % m; n >>= 1;
	}
	return res;
}
struct modint {
	ll n;
	modint() :n(0) { ; }
	modint(ll m) :n(m) {
		if (n >= mod)n %= mod;
		else if (n < 0)n = (n % mod + mod) % mod;
	}
	operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint& a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint& a, modint b) { a.n = ((ll)a.n * b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
	if (n == 0)return modint(1);
	modint res = (a * a) ^ (n / 2);
	if (n % 2)res = res * a;
	return res;
}

ll inv(ll a, ll p) {
	return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }

const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
	fact[0] = modint(1);
	for (int i = 0; i < max_n - 1; i++) {
		fact[i + 1] = fact[i] * modint(i + 1);
	}
	factinv[max_n - 1] = modint(1) / fact[max_n - 1];
	for (int i = max_n - 2; i >= 0; i--) {
		factinv[i] = factinv[i + 1] * modint(i + 1);
	}
}
modint comb(int a, int b) {
	if (a < 0 || b < 0 || a < b)return 0;
	return fact[a] * factinv[b] * factinv[a - b];
}

void solve() {
	ll n, d; cin >> n >> d;
	int ans = 0;
	rep(i, n) {
		ll x, y; cin >> x >> y;
		if (x * x + y * y <= d * d)ans++;

	}
	cout << ans << "\n";
}




signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	//cout << fixed << setprecision(10);
	//init_f();
	//cout << grandy(2, 3, false, false) << "\n";
	//int t; cin >> t; rep(i, t)
		solve();
	return 0;
}


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

using namespace std;

int main(){
  int N;
  string S;
  cin >> N >> S;
  
  int count = 0;
  for(int i=0; i<N-2; i++){
    int pos = S.find("ABC", i);
    if (pos == i) ++count;
  }
  
  cout << count;
  
  return 0;
}

Measured memory_bytes: 256
import math
A,B = map(int,input().split())
#print(A/0.08)
#print(B/0.1)
ga = math.ceil(A/0.08)
gb = math.ceil(B/0.1)

small = min(ga,gb)
big = max(ga,gb)

for i in range(small,big+1):
  #print(math.floor(i*0.08) ,math.floor(i*0.1))
  if math.floor(i*0.08) == A and math.floor(i*0.1) == B:
    print(i)
    exit()
print(-1)

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

int seg[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66,
	0x6d, 0x7d, 0x27, 0x7f, 0x6f};

int main() {
	int n;
	while(cin >> n, n != -1) {
		int status = 0;
		for(int i = 0; i < n; i++) {
			int in;
			cin >> in;
			status ^= seg[in];
			for(int i = 6; i >= 0; i--) {
				cout << !!(status & (1 << i));
			}
			cout << endl;
			status = seg[in];
		}
	}
}

Measured memory_bytes: 1160
//#include<bits/stdc++.h>
#include<iostream>
#include<string>
#include<algorithm>
#include <unordered_map>
using namespace std;

int main() {
	int q;
	cin >> q;
	unordered_map <string, int> d;
	for (int i = 0; i < q; i++) {
		string s;
		cin >> s;
		sort(s.begin(), s.end());
		if (d.find(s) == d.end()) {
			d[s] = 1;
		}
		else {
			d[s]++;
		}
	}
	long long res = 0;
	for (auto i : d) {
		long long t = i.second;
		res += t * (t - 1) / 2;
	}
	cout << res;
	return 0;
}


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

class Program
{
    static void Main()
    {
        string[] arr = Console.ReadLine().Split(' ');
        int H = int.Parse(arr[0]);
        int N = int.Parse(arr[1]);
        string[] A = Console.ReadLine().Split(' ');

        for(int i = 0; i < N; i++)
        {
            int Ai = int.Parse(A[i]);
            H -= Ai;
            if(H <= 0)
            {
                break;
            }
        }

        Console.WriteLine(H <= 0 ? "Yes" : "No");
    }
}

Measured memory_bytes: 16480
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <functional>
#include <numeric>
#include <limits>
#include <iomanip>
#include <queue>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const long long INF = 1LL << 60;
using pll = pair<long long, long long>;
#define min(a, b) ((a) < (b) ? (a) : (b))



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

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

int main() {
	int N, M;
	cin >> N >> M;
	priority_queue<long long> que;
	long long tmp;
	for (int i = 0; i < N; i++) {
		cin >> tmp;
		que.push(tmp);
	}

	for (int i = 0; i < M; i++) {
		long long t = que.top();
		que.pop();
		que.push(t / 2);
	}

	long long res = 0;
	while (!que.empty()) {
		res += que.top();
		que.pop();
	}

	cout << res << endl;
}


Measured memory_bytes: 1400
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);

const int N = 2e5+5, M = 1e6+6, OO = 0x3f3f3f3f;
int tc;
int a[N], b[N];
int main()
{
    FIO
    int n; 
    cin>>n;
    for (int i = 0; i < n; i++)
    {
        cin>>a[i]>>b[i];
    }
    sort(a, a + n);
    sort(b, b + n);
    if(n%2)
        cout<< b[n/2] - a[n/2] + 1 <<endl;
    else
        cout<<b[n/2] + b[(n/2) - 1] - a[n/2] - a[n/2 - 1] + 1;
    return 0;
}

Measured memory_bytes: 5168
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <iomanip>
#include <stack>
#include <fstream>
#include <cstdint>
#include <cmath>
#include <algorithm>
#include <utility>
#include <numeric>
#include <functional>
using namespace std;

constexpr int INF       = 1000000000;/* 1e+9a */
constexpr int MODULO    = 1000000007;

#define int int64_t

#define REP(i,f,n) for(int i=(f); i < (n); ++i)
#define PER(i,f,n) for(int i=(n-1); i >= f; --i)

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

template<typename STL> inline void print_STL(STL c, string ab = ""){
	cout << ab << '\n';
	for(auto t : c) cout << t << ' '; cout << '\n';}

template<typename VEC> inline void import_VEC(VEC& c, int n){
	typename VEC::value_type tmp;
	for(int i = 0; i < n; ++i){	cin >> tmp; c.push_back(tmp);} }

#define SPRE(x) setprecision(x) // 精度を指定

template<class T>	using Matrix = vector<vector<T>>;

bool solve(string s)
{
	set<string> t = {"dream", "dreamer", "erase", "eraser"};
	int i = s.size() - 1;
	while(i > 0)
	{
		bool check = false;
		REP(k, 0, 3)
		{
			if(i-4-k < 0)
				return false;
			/* cerr << s.substr(i-4-k, 5+k) << '\n'; */
			if(t.count(s.substr(i-4-k, 5+k)))
			{
				/* cerr << "YES" << '\n'; */
				check = true;
				i = i-5-k;
				break;
			}
		}
		if(!check)
			return false;
	}
	return true;
}

signed main()
{
	cin.tie(0);
    ios::sync_with_stdio(false);
	string s;
	cin >> s;

	cout << (solve(s) ? "YES\n" : "NO\n") ;

}



Measured memory_bytes: 512
import java.util.Scanner;

public class Main {

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

        int A = sc.nextInt();
        int B = sc.nextInt();
        int C = sc.nextInt();
        
        boolean isKawaisou = false;
        if(A == B && B!= C) {
            isKawaisou = true;
        }
        if(B == C && C!= A) {
            isKawaisou = true;
        }
        if(C == A && A!= B) {
            isKawaisou = true;
        }
        
        System.out.println(isKawaisou? "Yes" : "No");
    }


}


Measured memory_bytes: 22224
package main

import "fmt"

func main()  {
	var w, h, x, y, r int
	fmt.Scan(&w, &h, &x, &y, &r)
	if ((r <= x) && (x <= w-r)) && ((r <= y) && (y <= h-r)) {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


Measured memory_bytes: 1180
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#define int long long
using namespace std;
signed main() {
	string s; cin >>s>> s;
	int r; cin >> r;
	for (int i = 0; i < s.size(); i++) {
		cout << (s[i] == s[r - 1] ? s[i] : '*');
	}
	cout << endl;
}

Measured memory_bytes: 256
import java.math.BigInteger;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		BigInteger A = new BigInteger(scan.nextLine());
		BigInteger B = new BigInteger(scan.nextLine());
		if(A.compareTo(B) == 1) {
			System.out.println("GREATER");
		} else if(A.compareTo(B) == -1){
			System.out.println("LESS");
		} else if(A.compareTo(B) == 0) {
			System.out.println("EQUAL");
		}
		scan.close();

	}

}


Measured memory_bytes: 21460
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
inline LL read()
{
    LL x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int main()
{
    int a,b,c;
    scanf("%1d%1d%1d",&a,&b,&c);
    printf("%d%d%d\n",10-a,10-b,10-c);
    return 0;
}


Measured memory_bytes: 256
#include <iostream>
#include <iomanip>
#include <vector>
#include <utility>
#include <map>
#include <algorithm>
#include <queue>
#include <cmath>
#include <numeric>
#include <set>

using namespace std;
struct aaa{aaa(){cin.tie(nullptr); ios::sync_with_stdio(false); cout<<fixed<<setprecision(20);};}aaa;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v){o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
#define debug(v) {cerr<<"\033[1;36m[debug]\033[m "<<#v<<" : "<<v<<endl;}

using int64 = long long;
using P = pair<int,int>;

void bfs(const int s, vector<vector<int>>& g, vector<int>& ans) {
    queue<P> q;
    q.emplace(s, 0);
    while(!q.empty()) {
        auto [u, p] = q.front(); q.pop();
        if (ans[u] >= 0) continue;
        ans[u] = p;
        for (auto v : g[u]) q.emplace(v, u);
    }
}

int main() {
    int n,m;
    cin >> n >> m;
    vector<vector<int>> g(n+1);
    for (int i=0; i<m; i++) {
        int a,b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }

    vector<int> ans(n+1, -1);
    bfs(1,g,ans);

    if (all_of(ans.begin()+1, ans.end(), [](const int& x){return x >= 0;})) {
        cout << "Yes" << endl;
        for (int i = 2; i <= n; i++) {
            cout << ans[i] << endl;
        }
    } else {
        cout << "No" << endl;
    }
}

Measured memory_bytes: 11792
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int pow = (int)Math.pow(2,m);
        System.out.println((m*1900+(n-m)*100)*pow);
    }
}

Measured memory_bytes: 22996
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>

using namespace std;

#define INF (1 << 30)
#define INFL (1LL << 62)
#define MOD7 1000000007
#define MOD9 1000000009
#define EPS 1e-10

#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pul pair<ull, ull>
#define all(a) (a).begin(), (a).end()
#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);--i)
#define REP(i,n) for (int i=0;i<(n);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)

void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void yes() { cout << "yes" << endl; }
void no() { cout << "no" << endl; }
void Taka() { cout << "Takahashi" << endl; }
void Aoki() { cout << "Aoki" << endl; }
void digit(int d) { cout << fixed << setprecision(d); }
void IOup() { cin.tie(0); ios::sync_with_stdio(false); }

int main() {
	int a, b;
	while (cin >> a >> b) {
		cout << a - b << endl;
	}

	return 0;
}

Measured memory_bytes: 3104
import java.util.Scanner;

class Main
{
    public static void main(String[] agrs)
    {
        Scanner input = new Scanner(System.in);
        while(input.hasNext())
        {
            int a = input.nextInt();
            int b = input.nextInt();
            String s = Integer.toString(a + b);
            System.out.println(s.length());
        }
    }
}

Measured memory_bytes: 26608
#include <bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	int res=0;
	scanf("%d",&n);
	if(n&1)
	{
		res=n/2;
	}
	else
	{
		res=n/2-1;
	}
	printf("%d",res);
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 1000000007

int main() {
	ll n;
	cin>>n;
	long double x[52],y[52];
	for(ll i=0;i<n;i++){
		cin>>x[i]>>y[i];
	}
    long double l = 0;
    long double r = 1010;
    long double ans=inf;
    ll cnt2=0;
    /* どんな二分探索でもここの書き方を変えずにできる！ */
    while (cnt2!=100) {
    	cnt2++;
    	long double c1=(l*2+r)/3;
    	long double r1=0;
    	ll cnt=0;
    	long double ly1=0;
    	long double ry1=1010;    	
    	while(cnt!=100){
    		cnt++;
    		long double d1=(ly1*2+ry1)/3;
    		long double R1=0;
    		for(ll i=0;i<n;i++){
    			long double now=(x[i]-c1)*(x[i]-c1)+(y[i]-d1)*(y[i]-d1);
    			now=sqrt(now);
    			R1=max(now,R1);
    		}
    		long double d2=(ly1+ry1*2)/3;
    		long double R2=0;
    		for(ll i=0;i<n;i++){
    			long double now=(x[i]-c1)*(x[i]-c1)+(y[i]-d2)*(y[i]-d2);
    			now=sqrt(now);
    			R2=max(now,R2);
    		}
    		if(R1<R2){
    			ry1=d2;
    		}
    		else{
    			ly1=d1;
    		}
    		if(cnt==100){
    			r1=min(R1,R2);
    		}
    	}
    	
    	long double c2=(l+r*2)/3;
    	long double r2=0;
    	cnt=0;
    	long double ly2=0;
    	long double ry2=1010;    	
    	while(cnt!=100){
    		cnt++;
    		long double d1=(ly2*2+ry2)/3;
    		long double R1=0;
    		for(ll i=0;i<n;i++){
    			long double now=(x[i]-c2)*(x[i]-c2)+(y[i]-d1)*(y[i]-d1);
    			now=sqrt(now);
    			R1=max(now,R1);
    		}
    		long double d2=(ly2+ry2*2)/3;
    		long double R2=0;
    		for(ll i=0;i<n;i++){
    			long double now=(x[i]-c2)*(x[i]-c2)+(y[i]-d2)*(y[i]-d2);
    			now=sqrt(now);
    			R2=max(now,R2);
    		}
    		if(R1<R2){
    			ry2=d2;
    		}
    		else{
    			ly2=d1;
    		}
    		if(cnt==100){
    			r2=min(R1,R2);
    		}
    	} 
    	
    	if(r1<r2){
    		r=c2;
    	}
    	else{
    		l=c1;
    	}
    	if(cnt2==100){
    		ans=min(r1,r2);
    	}
    	//printf("%.10Lf\n",l);
    	//printf("%.10Lf\n\n",r);
    }
    printf("%.10Lf",ans);
	// your code goes here
	return 0;
}

Measured memory_bytes: 3824
#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <set>
#include <algorithm>
#include <iomanip>
#include <string.h>

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

typedef long long lint;

using namespace std;

int main(){
  lint a,b,c,d;
  cin>>a>>b>>c>>d;
  lint ans=-2e18;
  ans=max(ans,a*c);
  ans=max(ans,a*d);
  ans=max(ans,b*c);
  ans=max(ans,b*d);
  cout<<ans<<endl;
  return 0;
}


Measured memory_bytes: 3624
#include<bits/stdc++.h>
using namespace std;
int main(){
	int n;
	cin>>n;
	string s[n];
	for(int i=0;i<n;i++){
	//	string s;
		cin>>s[i];
	}
	map<string,string>m;
	for(int i=0;i<n;i++){
		m[s[i]];
	}
	cout<<m.size()<<endl;
}

Measured memory_bytes: 31604
#include <iostream>
#include <string>
#include <string.h>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <stdio.h>
#include <vector>
#include <thread>
#include <atomic>
#include <mutex>
#include <future>
#define int long long
#define endre getchar();getchar();return 0
#define INF 1000000007
#define rep(i,n) for(int i=0;i<n;i++)
#define input() for(int i=0;i<n;i++)cin>>a[i];
#define P pair<int,int>
#define prique priority_queue<int,vector<int>,greater<int>>
using namespace std;
bool prime(int n) {
	for (int i = 2; i <= sqrt(n); i++) {
		if (n%i == 0)return false;
	}
	return n != 1;
}
int gcd(int x, int y) {
	if (x < y)swap(x, y);
	if (y == 0)return x;
	return (y, x%y);
}
int lcm(int x, int y) {
	return x * y / gcd(x, y);
}
int kai(int n) {
	if (n == 0)return 1;
	return (kai(n - 1)*n) % INF;
}
int mod_pow(int x, int y, int mod) {
	int res = 1;
	while (y > 0) {
		if (y & 1) {
			res = res * x%mod;
		}
		x = x * x%mod;
		y >>= 1;
	}
	return res;
}
int mystoi(string s) {
	int cnt = 0;
	for (int i = 0; i < s.size(); i++) {
		cnt += (int)(s[i] - '0') * pow(10, s.size() - i - 1);
	}
	return cnt;
}
int n, W, w[105], v[105], dp[105][100005], ans;
signed main() {
	cin >> n >> W;
	for (int i = 0; i < n; i++)cin >> w[i] >> v[i];
	for (int i = 0; i <= n; i++) {
		for (int j = 0; j <= 100005; j++)dp[i][j] = INF;
	}
	dp[0][0] = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= 100005; j++) {
			if (dp[i][j] != INF) {
				dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
				if (j + v[i] <= 100000) {
					dp[i + 1][j + v[i]] = min(dp[i + 1][j + v[i]], dp[i][j] + w[i]);
				}
			}
		}
	}
	for (int i = 0; i <= 100000; i++) {
		if (dp[n][i] <= W)ans = i;
	}
	cout << ans << endl;
	endre;
}

Measured memory_bytes: 80128