stablegradients/pie-gem5-pairs huggingface dataset:
// 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>

#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 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>

#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 radius;

    cin>>radius;

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







    return 0;

}


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

}
// 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.262412014079507x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.2505773265730955x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.259579971808409x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.272229963989078x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.273023347294053x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.273279309431181x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.272229963989078x):
#include <stdio.h>



int main() {



	int r;

	

	scanf("%d", &r);

	r = 3 * r * r;

	printf("%d", r);



    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.253533378983167x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.241718658722111x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.2507061148765x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.26333476424626x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.264126808970971x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.264382339253959x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.26333476424626x):
#include <stdio.h>



int main() {



    int x = 3, y;

    scanf("%d", &y);

    y = x * y * y;

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



    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.253512319775207x):
#include <stdio.h>



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 main()

{

    int n;cin>>n;

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

    return 0;

}


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



int main () {

	

	int r;

	scanf("%d", &r);

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

	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.250685067001854x):
#include <stdio.h>



int main () {

	

	int r;

	scanf("%d", &r);

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

	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.263313665748664x):
#include <stdio.h>



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,b;



int main() {

	cin >> a;

	b= 3*a*a;

	cout <<b<< endl;

}


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



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, luas;



int main () {

cin >> a;

luas=3*a*a;

cout << luas << endl;



}

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



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 main() {



    int radius;

    cin>>radius;

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







    return 0;

}


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



int main () {

	

	int r;

	scanf("%d", &r);

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

	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.253512319775207x):
#include <stdio.h>

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 main()

{

    int n;cin>>n;

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

    return 0;

}


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

int main(){

   int r;

   scanf("%d",&r);

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

   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.250685067001854x):
#include <stdio.h>

int main(){

   int r;

   scanf("%d",&r);

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

   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.263313665748664x):
#include <stdio.h>

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,b;



int main() {

	cin >> a;

	b= 3*a*a;

	cout <<b<< endl;

}


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

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, luas;



int main () {

cin >> a;

luas=3*a*a;

cout << luas << endl;



}

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

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 main() {



    int radius;

    cin>>radius;

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







    return 0;

}


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

int main(){

   int r;

   scanf("%d",&r);

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

   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.253512319775207x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.2416976468744005x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.250685067001854x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.263313665748664x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.264105707298402x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.264361236557075x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.263313665748664x):
#include <stdio.h>

int main(){

	//r = a, L = 3a *pangkat 2

	//cari luasnya

	int r;

	scanf("%d", &r);

	int luas = 3 * (r*r);

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

	

	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.253512319775207x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.2416976468744005x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.250685067001854x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.263313665748664x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.264105707298402x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.264361236557075x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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.263313665748664x):
#include <stdio.h>

int main ()

{

	int r;

	scanf ("%d", &r);

	int hasil = 3*r*r;

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

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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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):
//It is known that the area of a regular dodecagon inscribed in a circle of radius a is 3a^2

//Given an integer r, find the area of a regular dodecagon inscribed in a circle of radius r



#include <stdio.h>



int main ()

{

	int r;

	scanf("%d", &r);

	

	int rumus;

	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>



int main(){

	int r;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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;

	scanf("%d", &r);

	

	int area;

	area = 3*(r*r);

	printf("%d", area);

	

	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.253512319775207x):
#include <stdio.h>



int main() {

	int ree;

	scanf("%d", &ree);

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

	

	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.2416976468744005x):
#include <stdio.h>



int main() {

	int ree;

	scanf("%d", &ree);

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

	

	return 0;

}