stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>

int pr[10000001]= {0};

int main()

{

    int i,j,k,s,d,r,n,h,l,x,y,z,g;





    scanf("%d",&g);

    s=0;

   for(h=1; h<=g; h++)

   {

        scanf("%d",&n);





            d=0;

            r=sqrt(n);

            if(n%2==0) d++;

            for(i=3; i<=r; i+=2)

            {

                if(n%i==0) d++;

                if(d>0) break;

            }



            if(n==2) s++;



            else if(d==0) s++;

            







   }

     printf("%d\n",s);





    return 0;



}

// Optimized solution to the same problem (faster):
#include <stdio.h>



bool is_prime(int n)

{

	for (int i = 2; i * i <= n; i++)

		if (n % i == 0)

			return false;

	return true;

}



int main()

{

	int N, n, k = 0;

	scanf("%d", &N);

	while (N--)

	{

		scanf("%d", &n);

		if (is_prime(n))

			k++;

	}

	printf("%d\n", k);



	return 0;

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

using namespace std;

bool f(int n){

    int cnt=0;

    for(int i=2;i<=sqrt(n);i++){

        if(n%i==0)

            cnt++;

    }

    if(cnt==0)

        return true;

    return false;

}

int main(){

    int n,m,cnt=0;

    cin>>n;

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

        cin>>m;

        if(f(m))

            cnt++;

        

    }

    cout<<cnt<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



bool is_prime(int n)

{

	for (int i = 2; i * i <= n; i++)

		if (n % i == 0)

			return false;

	return true;

}



int main()

{

	int N, n, k = 0;

	scanf("%d", &N);

	while (N--)

	{

		scanf("%d", &n);

		if (is_prime(n))

			k++;

	}

	printf("%d\n", k);



	return 0;

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int n,k,t=0;

bool prime(int o)

{

    if(o<2)return false;

    for(int i=2;i*i<=o;i++)if(o%i==0)return false;

    return true;

}

int main()

{

    cin>>n;

    while(n--)

    {

        cin>>k;

        if(prime(k))t++;

    }

    cout<<t<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



bool is_prime(int n)

{

	for (int i = 2; i * i <= n; i++)

		if (n % i == 0)

			return false;

	return true;

}



int main()

{

	int N, n, k = 0;

	scanf("%d", &N);

	while (N--)

	{

		scanf("%d", &n);

		if (is_prime(n))

			k++;

	}

	printf("%d\n", k);



	return 0;

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



bool prime_check(int n, int k)

{

    if(k * k > n) { return true; }



    if(n % k == 0) { return false; }



    return prime_check(n, k + 1);

}



int bool_to_int(bool a)

{

    if(a == true) { return -1; }



    return 0;

}



int main()

{

    const int DATASETS = 10000;



    int n, k = 0, data[DATASETS];



    cin >> n;



    for(int i = 0; i < n; i++) { cin >> data[i]; }



    for(int i = 0; i < n; i++) { k -= bool_to_int(prime_check(data[i], 2)); }



    cout << k << endl;



    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int q, n, c;

int main() {

	scanf("%d", &q);

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

		scanf("%d", &n);

		if(n > 1) c++;

		for(int j = 2; j * j <= n; j++) {

			if(n % j == 0) {

				c--; break;

			}

		}

	}

	printf("%d\n", c);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cmath>

using namespace std;

int n,x,c;

int main(){

	cin>>n;

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

		cin>>x;

		for(int j=2;j<=(int)pow(x,0.5);j++){

			if(x%j==0){

				c++;

				break;

			}

		}

	}

	cout<<n-c<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

using namespace std;

int prime[10000];

int p[10000];

int c[10000];

int main() {

	for (int i = 2; i*i < 10000; i++) {

		for (int j = i*i; j < 10000; j += i) prime[j] = 1;

	}

	int cnt = 0;

	for (int i = 2; i < 10000; i++) {

		if (prime[i] == 0) {

			p[cnt] = i; cnt++;

		}

	}

	int n, q, z = 0;

	scanf("%d", &q);

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

		scanf("%d", &n); bool OK = true;

		for (int j = 0; j < cnt; j++) {

			if (n < p[j]*p[j])break;

			if (n%p[j] == 0)OK = false;

		}

		if (OK == true)z++;

	}

	printf("%d\n", z);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int n,x,c;main(){cin>>n;for(int i=0;i<n;i++){cin>>x;for(int j=2;j<=(int)pow(x,0.5);j++){if(x%j==0){c++;break;}}}cout<<n-c<<endl;}

// Optimized solution to the same problem (faster):
#include<cstdio>

using namespace std;

int prime[10000];

int p[10000];

int c[10000];

int main() {

	for (int i = 2; i*i < 10000; i++) {

		for (int j = i*i; j < 10000; j += i) prime[j] = 1;

	}

	int cnt = 0;

	for (int i = 2; i < 10000; i++) {

		if (prime[i] == 0) {

			p[cnt] = i; cnt++;

		}

	}

	int n, q, z = 0;

	scanf("%d", &q);

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

		scanf("%d", &n); bool OK = true;

		for (int j = 0; j < cnt; j++) {

			if (n < p[j]*p[j])break;

			if (n%p[j] == 0)OK = false;

		}

		if (OK == true)z++;

	}

	printf("%d\n", z);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

const int N=100001;

int r;

int main()

{

	scanf("%d",&r);

	printf("%d\n",3*r*r);

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>



int main()

{

	int r, area;

	

	scanf("%d", &r);

	

	area = 3 * r * r;

	

	printf("%d", area);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

    cout << 3*a*a << endl;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>



int main()

{

	int r, area;

	

	scanf("%d", &r);

	

	area = 3 * r * r;

	

	printf("%d", area);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main(){

int r,s;

cin >> r;

s=3*r*r;

cout << s;

return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n;cin>>n;

    printf("%d\n",(3*n*n));

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int main()

{

     long int area;

    int r;cin>>r;

    area=3*r*r;

    cout<<area;







    return 0;

}




// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main()

{

 int r,area;

 cin>>r;

 area=3*r*r;

 cout<< area<< endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):


#include <bits/stdc++.h>



using namespace std;



int a,b;



int main() {

	cin >> a;

	b= 3*a*a;

	cout <<b<< endl;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int a, luas;



int main () {

cin >> a;

luas=3*a*a;

cout << luas << endl;



}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main() {



    int radius;

    cin>>radius;

    cout<<3*radius*radius<<endl;







    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



typedef long long ll;



#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tt int t; cin>>t; while(t--)

#define nl cout<<"\n";

#define sp cout<<" ";

#define rep(i, a, b) for(long long i=a; i<b; i++)



const int INF = 1e9 + 7;

const int MOD = 1e9 + 7;

double PI = 4*atan(1);



int main()

{

    optimize();



    ll r;

    cin>> r;



    cout<< 3 * r* r;

    nl;



    return 0;

}






// Optimized solution to the same problem (faster):
#include <stdio.h>

int main()

{

	int x;

	scanf("%d",&x);

	printf("%d",3*x*x);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int n;

	

	scanf ("%d",&n);

	printf ("%d",3*n*n);

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int r;



int main () {

	cin >> r;

	cout << 3*r*r << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int n;

	

	scanf ("%d",&n);

	printf ("%d",3*n*n);

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int n;

	

	scanf ("%d",&n);

	printf ("%d",3*n*n);

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

	cout << 3 * r * r << endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main (){

	int n;

	

	scanf ("%d",&n);

	printf ("%d",3*n*n);

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

int area=3*pow(a,2);

cout<<area;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	

	int n;

	scanf("%d", &n);

	

	printf("%d", 3*n*n);

	

	

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream> pre processor directive

#include <string>

#include <iomanip>

#include <cctype>

using namespace std;

int main()

{

    int r;

    cin>>r;

    cout<<3*(r*r)<<endl;



}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	

	int n;

	scanf("%d", &n);

	

	printf("%d", 3*n*n);

	

	

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main(){

	

	int n;

	scanf("%d", &n);

	

	printf("%d", 3*n*n);

	

	

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#include<algorithm>

#include<math.h>

#include<string>

#include<iostream>

#include<vector>

#include<cstdlib>

using namespace std;

 

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

 

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;

}

 

const long long INF = 1LL << 60;

 

using ll = long long;

using db = double;

using st = string;

using ch = char;

using bl = bool;

using vll = V<ll>;

using vpll =V<pair<ll,ll>>;

using vst = V<st>;

using vdb = V<db>;

using vch = V<ch>;

using vbl = V<bl>;

 

 

#define FOR(i,a,b) for(ll i=(a);i<(b);i++)

#define rFOR(i,a,b) for(ll i=(a);i>(b);i--)

#define oFOR(i,a,b) for(ll i=(a);i<(b);i+=2)

#define bgn begin()

#define en end()

#define SORT(a) sort((a).bgn,(a).en)

#define REV(a) reverse((a).bgn,(a).en)

#define M(a,b) max(a,b)

#define rM(a,b) min(a,b)

#define fi first

#define se second

#define sz size()

#define gcd(a,b) __gcd(a,b)

#define co(a) cout<<a<<endl;

#define ci(a) cin>>a;

 



vll dp(100100);



ll sum(ll n) {

  ll m=0;

  FOR(i,0,20){

    m+=n%10;

    n/=10;

    if(n==0){

      break;

    }

  }

  return m;

}

 

 

const int MAX = 510000;

const int MOD = 1000000007;

 

long long fac[MAX], finv[MAX], inv[MAX];

 

void Comuse() {

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for (int i = 2; i < MAX; i++){

        fac[i] = fac[i - 1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;

        finv[i] = finv[i - 1] * inv[i] % MOD;

    }

}

 

 

#define comuse Comuse()

 

ll combi(int n, int k){

    if (n < k) return 0;

    if (n < 0 || k < 0) return 0;

    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;

}

 

 

 

 

ll lcm(ll a,ll b){

  ll n;

  n=a/gcd(a,b)*b;

  return n;

}

 

 

/****************************************\

| Thank you for viewing my code:)        |

| Written by RedSpica a.k.a. RanseMirage |

| Twitter:@asakaakasaka                  | 

\****************************************/

 

 

signed main() {

  ll a;

    ci(a);

  co(a*a*3)

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



int main() {

  int n;

  	cin>>n;

  cout<<n*n*3<<endl;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

	int n,m,l,a,b;

	long long int s;

	while(~scanf("%d",&n))

	{

		 s=n*n*3;

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

	}

	

	 

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	int sisi;

	

	scanf("%d", &sisi);

	printf("%d", 3*sisi*sisi);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

    double a = 3 * pow(r, 2);

    cout << a;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	int sisi;

	

	scanf("%d", &sisi);

	printf("%d", 3*sisi*sisi);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



int main()

{

 int n;cin>>n;

 cout<<3*(n*n);

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	int sisi;

	

	scanf("%d", &sisi);

	printf("%d", 3*sisi*sisi);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

    cout<<area;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	int sisi;

	

	scanf("%d", &sisi);

	printf("%d", 3*sisi*sisi);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>





int main()

{

    int n;

    std::cin >> n;

    std::cout << 3 * n * n;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main() {

	int sisi;

	

	scanf("%d", &sisi);

	printf("%d", 3*sisi*sisi);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

#include<string>

#include<set>



using namespace std;



int n;

int num[5];

int card[11];

set<string> ans;



void serch(int m,int k,int now)

{

	

	for(int i=0;i<m;i++)

	{

		for(int j=i+1;j<m;j++)

		{

			if(num[i]==num[j])

			{

				return;

			}

		}

	}

	

	if(m==k)

	{

		string str;

		char  ch[8];

		for(int i=0;i<m;i++)

		{

			sprintf(ch,"%d",card[num[i]]);

			str+=string(ch);

		}

		ans.insert(str);

		return ;

	}

	

	num[m]=now;

	

	for(int i=0;i<n;i++)

	{

		serch(m+1,k,i);

	}

	

	return ;

}



int main()

{

	int k;

	int i,j;

	

	for(;;)

	{

		cin >> n >> k;

		if(n==0 && k==0)

			break;

		

		ans.clear();

		

		for(i=0;i<n;i++)

			cin >> card[i] ;

		

		for(i=0;i<n;i++)

		{

			serch(0,k,i);

		}

		

		set<string>::iterator it = ans.begin();

		

/*

		for(;it!=ans.end();++it)

		{

			cout << "ans:" << *it << endl;

		}

*/

		

		cout << ans.size() << endl;

	}

	

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<vector>

#include<set>

#include<string>



using namespace std;



int n,m;

vector<int> came;

string str[11];

set<string> ans;



void serch(int loop,string sans)

{

//	cout << "loop:" << loop << endl;

	if(loop==m)

	{

//		cout << "came:" ;

//		for(int i=0;i<came.size();i++)

//			cout <<  came[i] << " " ;

//		cout << endl;

//		cout << sans << endl;;

		ans.insert(sans);

		return ;

	}

	

	for(int i=0;i<n;i++)

	{

		for(int j=0;j<came.size();j++)

		{

//				cout << "j:" << j << " now:" << came[j] << " size:" << came.size() << " " << i << endl;

			if(i==came[j])

			{

				i++;

				j=-1;

			}

		}

		if(i==n)

			break;

//		cout << "next:" << i << endl;

		came.push_back(i);

		serch(loop+1,sans+str[i]);

		came.pop_back();

	}

	return ;

}



int main()

{

	int i,j;

	for(;;)

	{

		cin >> n >> m ;

		if(n==0 && m==0)

			break;

		

		ans.clear();

		

		for(i=0;i<n;i++)

			cin >> str[i] ;

		

		serch(0,"");

		

		cout << ans.size() << endl;

	}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;

long long x,y;

int nr;

int main()

{

    cin>>x>>y;

    nr=1;

    while(x*2<=y){

        nr++;

        x*=2;



    }

    cout<<nr;

    return 0;

}


// Optimized solution to the same problem (faster):
#include<cstdio>



int main(){

    long long x, y;

    scanf("%lld%lld",&x,&y);

    int sum = 0;

    y /= x;

    while(y){

        sum++;

        y>>=1;

    }

    printf("%d\n",sum);

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const LL mod = 1e9 + 7;

const int N = 300005;



int a[N], b[N];

vector<int> G[N];

int val[N << 2];

void update(int u, int l, int r, int x, int v) {

    if (l == r) {

        val[u] += v;

        return;

    }

    int mid = l + r >> 1;

    if (x <= mid)

        update(u << 1, l, mid, x, v);

    else

        update(u << 1 | 1, mid + 1, r, x, v);

    val[u] = max(val[u << 1], val[u << 1 | 1]);

}

int main() {

    int n, m, g;

    scanf("%d%d%d", &n, &m, &g);

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

        int x, y;

        scanf("%d%d", &x, &y);

        a[x]++;

        update(1, 1, m, y, 1);

        G[x].push_back(y);

    }



    int ans = 0;

    for (int i = 1; i <= n; i++) {

        for (auto y : G[i]) update(1, 1, m, y, -1);

        ans = max(ans, a[i] + val[1]);

        for (auto y : G[i]) update(1, 1, m, y, 1);

    }

    cout << ans << endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int INF = 0x3f3f3f3f;

const LL mod = 1e9 + 7;

const int N = 300005;



int a[N], b[N];

vector<int> c, d;

int main() {

    int n, m, g;

    scanf("%d%d%d", &n, &m, &g);

    set<pair<int, int> > se;

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

        int x, y;

        scanf("%d%d", &x, &y);

        se.insert({x, y});

        a[x]++;

        b[y]++;

    }

    int mx1 = 0, mx2 = 0;

    for (int i = 1; i <= n; i++) mx1 = max(mx1, a[i]);

    for (int i = 1; i <= m; i++) mx2 = max(mx2, b[i]);

    for (int i = 1; i <= n; i++)

        if (mx1 == a[i]) c.push_back(i);

    for (int i = 1; i <= m; i++)

        if (mx2 == b[i]) d.push_back(i);

    for (auto x : c) {

        for (auto y : d) {

            if (se.count({x, y}) == 0) {

                printf("%d\n", mx1 + mx2);

                return 0;

            }

        }

    }

    printf("%d\n", mx1 + mx2 - 1);

    return 0;

}


// Fastest known solution for this problem: