stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<stdio.h>

#include<algorithm>

#include<math.h>

using namespace std;

int a[10001];

int main()

{

    int n,b,c,m=0;

    scanf("%d",&n);

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

        scanf("%d",&a[i]);

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

 {   if(a[i]==1)continue;

   else

   {

     int t=0;

    b=sqrt(a[i]);

    for(int j=2;j<=b;j++)

    if(a[i]%j==0)t++;

    if(t==0)m++;

   }

 }

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

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.184140778246141x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#include<iostream>

#include<stdio.h>

#include<string.h>

using namespace std;



bool isprime(int k)

{

    if(k<2) return 0;

    else if(k==2) return 1;

    if(k%2==0) return 0;

    for(int i=3;i*i<=k;i+=2)

    {

        if(k%i==0) return 0;

    }

    return 1;

}



int main()

{

	int n,m,ans=0;

	scanf("%d",&n);

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

	{

		scanf("%d",&m);

		if(isprime(m)) ans++;

	}

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.142243501659601x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#include<iostream>

#include<vector>

#include <algorithm>



using namespace std;

vector<int> n;



int main(void)

{

    int count,temp,ans=0,rant=0;



    cin>>count;

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

    {

        cin>>temp;

        rant=rant>temp?rant:temp;

        n.push_back(temp);

    }



  vector<bool> pri(++rant,0);



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

  {

      if(!pri.at(i))

         {



             for(int j=i;j*i<rant;j++)

                {

                   pri[i*j]=true;

                }

         }

  }



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

    {

        if(!pri.at(n.at(i)))

            ans++;

    }



  cout<<ans<<endl;

return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.272444517896449x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#include<stdio.h>

#include<iostream>

#include<math.h>

using namespace std;

int n,tot=0,temp;

bool m[10005];

bool pri(int mt){

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

		if(mt%i==0){

			return 0;

		}

	}

	return 1;

}

int main(void){

	scanf("%d",&n);

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

		scanf("%d",&temp);

		if(temp>2){

			if(pri(temp)){

				tot++;

			}

		}

		else if(temp==2){

			tot++;

		}

		else if(temp==1||temp==0){

		}

	}

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.182012450246626x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#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;



}

// Faster C++ solution for the same problem (measured speedup: 5.182474302941772x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.2085463597541x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.169574681929464x):
#include<stdio.h>

#include <malloc.h>

bool sushu(int a)

{



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

	

		if((a%i)==0)

	return false;

	

		return true;

 

}



int main()

{

	int N,count=0;

	scanf("%d",&N);

	//int A[10000];

	int *A;

	A=(int*)malloc(sizeof(int)*N);



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

	{

		scanf("%d",&A[i]);

		

		if(sushu(A[i]))

			count++;

	}



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

	return 0;



}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.2160185492980204x):
#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);

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.213378340260301x):
#include <stdio.h>

int q, n, c;

int modpow(int a, int b, int m) {

	int ret = 1;

	for(int i = 30; i >= 0; i--) {

		ret = 1LL * ret * ret % m;

		if(b & (1 << i)) ret = 1LL * ret * a % m;

	}

	return ret;

}

bool issprp(int x, int a) {

	int d = x - 1, s = 0;

	while(d % 2 == 0) d /= 2, s++;

	int p = modpow(a, d, x);

	if(p == 1) return true;

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

		if(p == x - 1) return true;

		p = 1LL * p * p % x;

	}

	return false;

}

bool slowprime(int x) {

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

		if(x % i == 0) return false;

	}

	return true;

}

bool isprime(int x) {

	if(x < 30000) return slowprime(x);

	return issprp(x, 2) && issprp(x, 7) && issprp(x, 61);

}

int main() {

	scanf("%d", &q);

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

		scanf("%d", &n);

		if(n > 1 && isprime(n)) c++;

	}

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

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 3.1249835553161356x):
#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;

}
// Slower C++ solution:
#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;}

// Faster C++ solution for the same problem (measured speedup: 3.1249835553161356x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 2.623660416713356x):
#include<cstdio>

#include<cmath>

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++;

		}

	}

	for(int i=2;i<10000;i++)c[i]=c[i-1]+(1-prime[i]);

	int n, q, z = 0;

	scanf("%d", &q);

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

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

		int L=sqrt(n);

		for (int j = 0; j < c[L]; j++) {

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

		}

		if (OK == true)z++;

	}

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

	return 0;

}
// Slower C++ solution:
#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;}

// Faster C++ solution for the same problem (measured speedup: 2.623660416713356x):
#include<cstdio>

#include<cmath>

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++;

		}

	}

	for(int i=2;i<10000;i++)c[i]=c[i-1]+(1-prime[i]);

	int n, q, z = 0;

	scanf("%d", &q);

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

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

		int L=sqrt(n);

		for (int j = 0; j < c[L]; j++) {

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

		}

		if (OK == true)z++;

	}

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

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.203524218426807x):
#include <cstdio>

#include <cstdlib>

using namespace std;

#define ll long long

int main()

{

	ll a;

	scanf("%lld",&a);

	a=3*a*a;

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

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include<stdio.h>



int main()

{

	int r, area;

	

	scanf("%d", &r);

	

	area = 3 * r * r;

	

	printf("%d", area);

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include<stdio.h>



int main()

{

	int r, area;

	

	scanf("%d", &r);

	

	area = 3 * r * r;

	

	printf("%d", area);

	

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include <stdio.h>



int main() {

	int dod;

	scanf("%d", &dod);

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

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include <stdio.h>



int main() {

	int dod;

	scanf("%d", &dod);

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

	

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include <stdio.h>

int main (){

	int a, area;

	scanf ("%d", &a );

	area= 3*a*a;

	printf ("%d",area);

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include <stdio.h>

int main (){

	int a, area;

	scanf ("%d", &a );

	area= 3*a*a;

	printf ("%d",area);

	

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.202156902075451x):
#include<stdio.h>



int main(){

	int n;

	scanf("%d",&n);

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



	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.263261483387858x):
#include<stdio.h>



int main(){

	int n;

	scanf("%d",&n);

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



	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.201773834506963x):
#include <cstdio>

int main(){

   int r;

   scanf("%d",&r);

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

   return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.262873916304297x):
#include <cstdio>

int main(){

   int r;

   scanf("%d",&r);

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

   return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include <stdio.h>



int main(){

	

	int input;

	

	scanf("%d", &input);

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

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include <stdio.h>



int main(){

	

	int input;

	

	scanf("%d", &input);

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

	

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include <stdio.h>



int main () {

	int r;

	scanf("%d", &r);

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

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include <stdio.h>



int main () {

	int r;

	scanf("%d", &r);

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

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.211145720140043x):
#include<stdio.h>



int main()

{

	int R, A;

	scanf("%d", &R);

	A = 3 * (R * R);

	printf("%d", A);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.2723558841895075x):
#include<stdio.h>



int main()

{

	int R, A;

	scanf("%d", &R);

	A = 3 * (R * R);

	printf("%d", A);

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.202156902075451x):
#include <stdio.h>



int main() 

{

  int L;

  scanf("%d", &L);

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



  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a;



int main () {

    cin >> a;

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

}

// Faster C++ solution for the same problem (measured speedup: 5.263261483387858x):
#include <stdio.h>



int main() 

{

  int L;

  scanf("%d", &L);

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



  return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

int r,s;

cin >> r;

s=3*r*r;

cout << s;

return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.262589874976149x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n;cin>>n;

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

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.250754787476706x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main()

{

     long int area;

    int r;cin>>r;

    area=3*r*r;

    cout<<area;







    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.259757736986667x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

 int r,area;

 cin>>r;

 area=3*r*r;

 cout<< area<< endl;

}


// Faster C++ solution for the same problem (measured speedup: 5.2724081567163275x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:


#include <bits/stdc++.h>



using namespace std;



int a,b;



int main() {

	cin >> a;

	b= 3*a*a;

	cout <<b<< endl;

}


// Faster C++ solution for the same problem (measured speedup: 5.273201566836357x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int a, luas;



int main () {

cin >> a;

luas=3*a*a;

cout << luas << endl;



}

// Faster C++ solution for the same problem (measured speedup: 5.2734575376245845x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main() {



    int radius;

    cin>>radius;

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







    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.2724081567163275x):
#include <stdio.h>



int main(){

	int r;

	int rumus;

	scanf("%d", &r);

	rumus = 3*(r*r);

	printf("%d", rumus);

	

	

	

	

	return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

int r,s;

cin >> r;

s=3*r*r;

cout << s;

return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.262589874976149x):
#include <stdio.h>

#include <string.h>



int main(){

int r, result;



scanf("%d", &r);

result=  r * r * 3;

printf("%d", result);





return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n;cin>>n;

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

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.250754787476706x):
#include <stdio.h>

#include <string.h>



int main(){

int r, result;



scanf("%d", &r);

result=  r * r * 3;

printf("%d", result);





return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main()

{

     long int area;

    int r;cin>>r;

    area=3*r*r;

    cout<<area;







    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.259757736986667x):
#include <stdio.h>

#include <string.h>



int main(){

int r, result;



scanf("%d", &r);

result=  r * r * 3;

printf("%d", result);





return 0;

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

 int r,area;

 cin>>r;

 area=3*r*r;

 cout<< area<< endl;

}


// Faster C++ solution for the same problem (measured speedup: 5.2724081567163275x):
#include <stdio.h>

#include <string.h>



int main(){

int r, result;



scanf("%d", &r);

result=  r * r * 3;

printf("%d", result);





return 0;

}