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

	scanf("%d", &ree);

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

	

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

	scanf("%d", &ree);

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

	

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

	scanf("%d", &ree);

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

	

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

	scanf("%d", &ree);

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

	

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

	scanf("%d",&r);

	a= 3*r*r;

	printf("%d",a);

	

	

	

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

	scanf("%d",&r);

	a= 3*r*r;

	printf("%d",a);

	

	

	

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

	scanf("%d",&r);

	a= 3*r*r;

	printf("%d",a);

	

	

	

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

	scanf("%d",&r);

	a= 3*r*r;

	printf("%d",a);

	

	

	

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

	scanf("%d",&r);

	a= 3*r*r;

	printf("%d",a);

	

	

	

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

int main()

{

	int x;

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

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

	scanf("%d",&x);

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

	return 0;

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

}






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

int main()

{

	int x;

	scanf("%d",&x);

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

	return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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



int main (){

	int n;

	

	scanf ("%d",&n);

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

	

	

	return 0;

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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



int main (){

	int n;

	

	scanf ("%d",&n);

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

	

	

	return 0;

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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



int main (){

	int n;

	

	scanf ("%d",&n);

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

	

	

	return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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



int main (){

	int n;

	

	scanf ("%d",&n);

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

	

	

	return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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



int main () {

	cin >> r;

	cout << 3*r*r << 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 <iostream>

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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

int main() {

 int r;

 scanf("%d", &r);

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

return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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

int main() {

 int r;

 scanf("%d", &r);

 printf("%d", 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;

    return 0;

}

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



int main () {

	cin >> r;

	cout << 3*r*r << 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 <iostream>

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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



int main(){

	int r;

	scanf("%d", &r);

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



	return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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



int main(){

	int r;

	scanf("%d", &r);

	printf("%d", 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;

    return 0;

}

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



int main(){

    int R;

    scanf("%d", &R);



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

    return 0;

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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



int main(){

    int R;

    scanf("%d", &R);



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

    return 0;

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  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", R*3*R);

    return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

	cout << 3 * r * r << 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", R*3*R);

    return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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

int main ()

{

	int r;

	scanf("%d",&r);

	r=3*r*r;

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

	return 0;	

	

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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

int main ()

{

	int r;

	scanf("%d",&r);

	r=3*r*r;

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

	return 0;	

	

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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

int main ()

{

	int r;

	scanf("%d",&r);

	r=3*r*r;

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

	return 0;	

	

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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

int main ()

{

	int r;

	scanf("%d",&r);

	r=3*r*r;

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

	return 0;	

	

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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



int main () {

	cin >> r;

	cout << 3*r*r << 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 <iostream>

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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

int main() {

	int r;

	scanf("%d",&r);

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

	

	return 0; 

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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

int main() {

	int r;

	scanf("%d",&r);

	printf("%d",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;

    return 0;

}

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



int main () {

    int jrri;

    scanf("%d", &jrri);

    int lass = 3 * jrri * jrri;

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





    return 0;

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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



int main () {

    int jrri;

    scanf("%d", &jrri);

    int lass = 3 * jrri * jrri;

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





    return 0;

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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



int main () {

    int jrri;

    scanf("%d", &jrri);

    int lass = 3 * jrri * jrri;

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





    return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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



int main () {

    int jrri;

    scanf("%d", &jrri);

    int lass = 3 * jrri * jrri;

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





    return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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

 

int main (){

int x;

scanf("%d", &x);

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

	

	return 0;

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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

 

int main (){

int x;

scanf("%d", &x);

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

	

	return 0;

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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

 

int main (){

int x;

scanf("%d", &x);

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

	

	return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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

 

int main (){

int x;

scanf("%d", &x);

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

	

	return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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

int main (){

	int a;

	scanf ("%d", &a);

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

	return 0;

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

using namespace std;



int r;



int main () {

	cin >> r;

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

}

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

int main (){

	int a;

	scanf ("%d", &a);

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

	return 0;

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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  return 0;



 }


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

int main (){

	int a;

	scanf ("%d", &a);

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

	return 0;

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

#include<string>

using namespace std;

int main()

{

	int r;

	cin >> r;

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

	return 0;

}

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

int main (){

	int a;

	scanf ("%d", &a);

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

	return 0;

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

using namespace std;



int main()

{

    int r,area;

    cin >> r;

    area = 3*r*r;

    cout << area;

    return 0;

}

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



int main () {

	cin >> r;

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

}

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



int main() {

  int r;

  scanf("%d", &r);

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



  return 0;



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

#include <cstring>

using namespace std;

int main(){

    int r; cin>>r;

    int area;

    area=3*r*r ;

    cout<<area;



  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;



}