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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main(){

	

	int n;

	scanf("%d", &n);

	

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

	

	

	return 0;

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



}


// 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<bits/stdc++.h>

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main(){

	

	int n;

	scanf("%d", &n);

	

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

	

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main (){

	int a, b;

	scanf ("%d", &a);

	b=3*(a*a);

	printf("%d", b);

	

	

	return 0;

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



}


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



int main (){

	int a, b;

	scanf ("%d", &a);

	b=3*(a*a);

	printf("%d", b);

	

	

	return 0;

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main (){

	int a, b;

	scanf ("%d", &a);

	b=3*(a*a);

	printf("%d", b);

	

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main() {

    int r;

    scanf("%d", &r);

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

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



}


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

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main() {

    int r;

    scanf("%d", &r);

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

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main() {

	

	int a;

	int b;

	scanf("%d", &a);

	b = 3*a*a;

	printf("%d", b);

	

	return 0;

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



}


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



int main() {

	

	int a;

	int b;

	scanf("%d", &a);

	b = 3*a*a;

	printf("%d", b);

	

	return 0;

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main() {

	

	int a;

	int b;

	scanf("%d", &a);

	b = 3*a*a;

	printf("%d", b);

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main(){

	int b;

	scanf("%d", &b);

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

	

	return 0;

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



}


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



int main(){

	int b;

	scanf("%d", &b);

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

	

	return 0;

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main(){

	int b;

	scanf("%d", &b);

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

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main(){

	int a;

	scanf("%d", &a);

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

	

	return 0;

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



}


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



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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



int main(){

	int a;

	scanf("%d", &a);

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

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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

 

int main() {

	int r;

	scanf("%d", &r);

	int wilayah = 3*(r*r);

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

	

	return 0;

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



}


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

 

int main() {

	int r;

	scanf("%d", &r);

	int wilayah = 3*(r*r);

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

	

	return 0;

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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

 

int main() {

	int r;

	scanf("%d", &r);

	int wilayah = 3*(r*r);

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

	

	return 0;

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

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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



int main(){



	int r;

	scanf("%d", &r);

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



  return 0;

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



}


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



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << 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<iostream>

#include<cmath>

using namespace std;

int main (){

int a;

cin>>a;

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

cout<<area;

}

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

#include <string.h>



int main(){

	int Rad;

	

	scanf ("%d", &Rad);

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



	return 0;

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



}


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

#include <string.h>



int main(){

	int Rad;

	

	scanf ("%d", &Rad);

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



	return 0;

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

using namespace std;



int a, total;



int main () {

	cin>> a;

	total= 3*a*a;

	cout<< total << endl;



}

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

#include <string.h>



int main(){

	int Rad;

	

	scanf ("%d", &Rad);

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



	return 0;

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

}

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

using namespace std;



int main() {

  int n;

  	cin>>n;

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

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

	}

	

	 

}

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

int main(){

	

	int r;

	scanf("%d", &r);

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

	return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

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

    cout << a;

    return 0;

}


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

 cout<<3*(n*n);

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

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

    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;

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





int main()

{

    int n;

    std::cin >> n;

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

    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,m,l,a,b;

	long long int s;

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

	{

		 s=n*n*3;

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

	}

	

	 

}

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

int main(){

    int a;

    scanf("%d", &a);

    int area =  3 * a * a;

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

    return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

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

    cout << a;

    return 0;

}


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

int main(){

    int a;

    scanf("%d", &a);

    int area =  3 * a * a;

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

    return 0;

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



using namespace std;



int main()

{

 int n;cin>>n;

 cout<<3*(n*n);

    return 0;

}


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

int main(){

    int a;

    scanf("%d", &a);

    int area =  3 * a * a;

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

    return 0;

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

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

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

    int area =  3 * a * a;

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

    return 0;

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





int main()

{

    int n;

    std::cin >> n;

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

    return 0;

}

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

int main(){

    int a;

    scanf("%d", &a);

    int area =  3 * a * a;

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

    return 0;

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

	}

	

	 

}

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



int main() {

	int sisi;

	

	scanf("%d", &sisi);

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

	

	return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

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

    cout << a;

    return 0;

}


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



int main() {

	int sisi;

	

	scanf("%d", &sisi);

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

	

	return 0;

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



using namespace std;



int main()

{

 int n;cin>>n;

 cout<<3*(n*n);

    return 0;

}


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



int main() {

	int sisi;

	

	scanf("%d", &sisi);

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

	

	return 0;

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

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

    cout<<area;

    return 0;

}


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



int main() {

	int sisi;

	

	scanf("%d", &sisi);

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

	

	return 0;

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





int main()

{

    int n;

    std::cin >> n;

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

    return 0;

}

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



int main() {

	int sisi;

	

	scanf("%d", &sisi);

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

	

	return 0;

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

	}

	

	 

}

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



int main ()



{

	int a, area;

	

	scanf("%d", &a);

	area=3*(a*a);

	

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

	

	return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

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

    cout << a;

    return 0;

}


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



int main ()



{

	int a, area;

	

	scanf("%d", &a);

	area=3*(a*a);

	

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

	

	return 0;

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



using namespace std;



int main()

{

 int n;cin>>n;

 cout<<3*(n*n);

    return 0;

}


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



int main ()



{

	int a, area;

	

	scanf("%d", &a);

	area=3*(a*a);

	

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

	

	return 0;

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

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

    cout<<area;

    return 0;

}


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



int main ()



{

	int a, area;

	

	scanf("%d", &a);

	area=3*(a*a);

	

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

	

	return 0;

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





int main()

{

    int n;

    std::cin >> n;

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

    return 0;

}

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



int main ()



{

	int a, area;

	

	scanf("%d", &a);

	area=3*(a*a);

	

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

	

	return 0;

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

	}

	

	 

}

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

#include <cmath>



using namespace std;



int main()

{

    int r; cin >> r;

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

    cout << a;

    return 0;

}


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

 cout<<3*(n*n);

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

using namespace std;



int main()

{

    int a,area;

    cin>>a;

    area=3*a*a;

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

	int area = 3*r*r;

	printf("%d", area);	

	return 0;

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





int main()

{

    int n;

    std::cin >> n;

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

    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,m,l,a,b;

	long long int s;

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

	{

		 s=n*n*3;

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

	}

	

	 

}

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



int main(){

int a,rumus;

scanf("%d", &a);

rumus = 3*(a*a);



printf("%d",rumus);









return 0;

}