Problem:
 Score : 100 points    Problem Statement 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 .      Constraints  1 \leq r \leq 100  r is an integer.         Input Input is given from Standard Input in the following format:  r       Output Print an integer representing the area of the regular dodecagon.        Sample Input 1 4      Sample Output 1 48  The area of the regular dodecagon is 3 \times 4^2 = 48 .       Sample Input 2 15      Sample Output 2 675       Sample Input 3 80      Sample Output 3 19200

Solution (Python):
def main():

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    
        
        
    
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    if __name__ != '__main__':
        
        sys.stdin = open('sample.txt')

    
    

    ar = int(r())
    print(3*ar*ar)
    
    
    

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """

if __name__ == '__main__':
    main()

Solution (Python):

a = int(input())

print(3*a*a)

Solution (Python):
r = int(input())
ans = 3 * r * r
print(ans)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r=int(input())
print(3*r**2)

Solution (Python):
from sys import stdin

readline = stdin.readline


def ns():
    """
    入力を`[\\s]`を除いて文字列として取得
    """
    return readline().rstrip()


def ni():
    """
    入力を`int`に変換
    """
    return int(ns())


def main():
    print(3 * ni() ** 2)


if __name__ == "__main__":
    main()

Solution (Python):
r = int(input())
print(3*(r**2))

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
input = sys.stdin.readline






















def main():

	r = int(input())
	
	
	

	print(3*(r**2))


if __name__ == "__main__":
	main()

Solution (Python):
r = int(input())

print(r*r*3)

Solution (Python):
r = int(input())

print(3 * r * r)

Solution (Python):
r = int(input())

res = 3*r**2
print(res)

Solution (Python):

r = int(input())

ans = 3 * r * r

print(ans)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
import numpy as np
import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

r = I()
print(3*(r**2))

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
r = int(input())


print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print("%d" % (3*(r**2)))

Solution (Python):
r = int(input())

print(3 * r**2)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())

print(3 * (r ** 2))

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
import bisect
import heapq
import itertools
import math
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


r = int(sys.stdin.readline())
print(r**2 *3)

Solution (Python):
r = int(input())

print(3*(r**2))

Solution (Python):
r = int(input())
print(3 * r**2)

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    r = int(input())

    print(3 * (r ** 2))




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
a = int(input())
print(3*a**2)

Solution (Python):
r = int(input())
print(r*r*3)

Solution (Python):
r = int(input())
res = 3 * r * r
print(res)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
print(3 * pow(int(input()), 2))

Solution (Python):
r = int(input())

ans = 3*(r**2)
print(ans)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3 * (r**2))

Solution (Python):
print(3*int(input())**2)

Solution (Python):
r = int(input())

print(3 * (r ** 2))

Solution (Python):
a=int(input())
print(3*a*a)

Solution (Python):
r = int(input())

print(int(3 * r ** 2))

Solution (Python):
r =int(input())

print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
import sys

fin = sys.stdin.readline
num = int(str(fin()).split()[0])

print(3 * num * num)

Solution (Python):
n=int(input())
ans=3*(n**2)

print(ans)

Solution (Python):
r=int(input())

print(3*r*r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())

print(3 * (r ** 2))

Solution (Python):
N = int(input())
print(3 * N**2)

Solution (Python):




def solve():
    r = int(input())
    return 3 * r * r


def main():
    print(solve())


if __name__ == "__main__":
    main()

Solution (Python):
r = int(input())

print(3*r**2)

Solution (Python):
def main():
    r = int(input())
    print(3 * r * r)


if __name__ == '__main__':
    main()

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
print(3*((int(input())**2)))

Solution (Python):
r = int(input())

print(3*(r**2))

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
a = int(input())

print(3 * a * a)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
from sys import stdin
import math
import fractions
from collections import deque
from collections import Counter
import itertools

INF = 10 ** 10

r = int(stdin.readline().rstrip())

ans = 3 * r * r

print(ans)

Solution (Python):
r = int(input())
print(3 * (r**2))

Solution (Python):
print(3*(int(input())**2))

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
n = int(input())

print(3 * (n ** 2))

Solution (Python):
n=int(input())
print(3*n*n)

Solution (Python):
a=int(input())
print(a**2*3)

Solution (Python):
N = int(input())
print(3 * N * N)

Solution (Python):
r = int(input())
s = 3*pow(r,2)
print(s)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
from fractions import gcd
import math


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


def main():
    a = int(input())
    print(3 * a * a)

main()

Solution (Python):
r = int(input())
S = 3 * r ** 2
print(S)

Solution (Python):
r=int(input())


ans=3*r**2

print(ans)

Solution (Python):
print(3 * int(input()) ** 2)

Solution (Python):
t=int(input())
print(3*t**2)

Solution (Python):
N = int(input())
m = 3*(N**2)
print(m)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
N = int(input())

print(3 * (N**2))

Solution (Python):
r=int(input())
print(3*r**2)

Solution (Python):
n = int(input())
print(3 * n * n)

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
def resolve():
    r = int(input())
    print(3 * r**2)
    
resolve()

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())
print(3*(r**2))

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
a=input()
a=int(a)
print(3*a**2)

Solution (Python):
print(int(input()) ** 2 * 3)

Solution (Python):
print(3*int(input())**2)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
a = int(input())
print(3*a**2)

Solution (Python):
N = int(input())
print(3*(N**2))

Solution (Python):
r = int(input())
print(3 * r**2)

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]






a = int(input())
ans = 3 * a * a
print(ans)

Solution (Python):
print(int(input())**2 * 3 )

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return list(map(float, sys.stdin.readline().split()))
def LS():return sys.stdin.readline().split()
def SR(n): return [list(sys.stdin.readline())[:-1] for i in range(n)]
def IR(n): return [int(sys.stdin.readline()) for i in range(n)]
def LIR(n): return [list(map(int, sys.stdin.readline().split())) for i in range(n)]
def LSR(n): return [list(map(list, sys.stdin.readline().split())) for i in range(n)]
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
    return reduce(_gcd, numbers)
def lcm(*numbers):
    return reduce(_lcm, numbers)
sys.setrecursionlimit(1000000)
INF = float('inf')
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]

N = I()

print(3*(N**2))

Solution (Python):
n = int(input())
print(3*n*n)

Solution (Python):
r=int(input())
print(3*r**2)

Solution (Python):
n = int(input())

print(3*n**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
N =int(input())

print(3*(N**2))

Solution (Python):
r=int(input())

ans = 3*r*r
print(ans)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
N=list(map(int, input().split()))
print(N[0]**2*3)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())

print(3 * r * r)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3 * (r ** 2))

Solution (Python):
r = int(input())

print(3*(r**2))

Solution (Python):
n=int(input())
print(3*n*n)

Solution (Python):


def read_input():
    r = int(input())
    return r


def submit():
    r = read_input()

    print(3 * r * r)
    return


if __name__ == '__main__':
    submit()

Solution (Python):
A = int(input())
print(3 * A**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
r = int(input())

print(3 * r * r)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(R):
    return 3*R*R


def main():
    R = read_int()
    print(slv(R))


if __name__ == '__main__':
    main()

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)

r = _I()

print(3*r**2)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
n=int(input())
print(3*(n**2))

Solution (Python):
r = int(input())

print(3 * r ** 2)

Solution (Python):

n = int(input())
print(3*(n*n))

Solution (Python):
r=int(input())
print(r**2*3)

Solution (Python):
a = int(input())
print(3 * a**2)

Solution (Python):
a = int(input())
print(3*(a**2))

Solution (Python):
r = int(input())

print(3*r**2)

Solution (Python):
r = int(input())
print(3 * (r **2))

Solution (Python):
n=int(input())
print(3*(n**2))

Solution (Python):
print 3 * (input () ** 2)

Solution (Python):
def solve():
  r = int(input())
  return 3 * (r ** 2)

print(solve())

Solution (Python):
N = int(input())
print(3*N*N)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
print(3*int(input())**2)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7



n = INT()
print(3 * n ** 2)

Solution (Python):
r = int(input())

print(3* (r**2))

Solution (Python):
r = int(input())

print(3*r**2)

Solution (Python):
a = int(input())
print(3 * a * a)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
print(3*(int(input()))**2)

Solution (Python):




if __name__ == "__main__":
    r = int(input())
    print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*(r**2))

Solution (Python):
a = int(input())
print(3*a**2)

Solution (Python):
r = int(input())

print(3 * r * r)

Solution (Python):

def Solve():
    
    r=int(input())
    return 3*r*r
print(Solve())

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
a= int(input())
print(3*(a**2))

Solution (Python):
a = int(input())
print(3*a**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
print(3*int(input())**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
print(3 * (int(input()) ** 2))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

N=II()
print(3*N*N)

Solution (Python):
a = int(input())

print(3*a**2)

Solution (Python):
r = int(input())
print(3 * r ** 2)

Solution (Python):
n = int(input())
print(3*n**2)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
a = int(input())
print(3*a*a)

Solution (Python):
import sys

inf = 10 ** 18
P = 10 ** 9 + 7

print( 3 * (int(input()) ** 2) )

Solution (Python):

r = int(input())
print(3*r*r)

Solution (Python):
r = int( input() )

print( 3*r*r )

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
a = int(input())
area = 3 * a**2
print(area)

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 

def LI(): return list(map(int, sys.stdin.readline().split()))

r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())

print(3*(r**2))

Solution (Python):
r = int(input())
print(3*(r*r))

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3 * r* r)

Solution (Python):
r = int(input())
ans = 3 * (r ** 2)
print(ans)

Solution (Python):
r = int(input())

print(3 * r ** 2)

Solution (Python):
r = int(input())
print(3 * r ** 2)

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
r = int(input())
print(3 * r ** 2)

Solution (Python):
r = int(input())

print (3 * r * r)

Solution (Python):
n = int(input())
print(3 * n * n)

Solution (Python):
r = int(input())
print(3 * (r ** 2))

Solution (Python):
def getlist():
	return list(map(int, input().split()))

r = int(input())
print((r ** 2) * 3)

Solution (Python):
print(3 * (int(input()) ** 2))

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]

n=I()
ans=3*n*n

print(ans)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):
n=int(input())
print(3*(n**2))

Solution (Python):
r=int(input())

print(3*r*r)

Solution (Python):
r = int(input())
print(3 * r ** 2)

Solution (Python):
r=int(input())
print(3*r*r)

Solution (Python):

import sys
def input(): return sys.stdin.readline().rstrip()
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
import heapq
INF = float("inf")
MOD = 10**9 + 7
sys.setrecursionlimit(10**7)

dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def mi(): return map(int, input().split())
def ii(): return int(input())


r = ii()

print(3 * r * r)

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):

r = int(input())
print(3*(r**2))

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

r = ni()

print(3*(r**2))

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
a = int(input())
ans = 3 * ( a ** 2 )
print(ans)

Solution (Python):
r = int(input())
print(int(3*r**2))

Solution (Python):
r = int(input())

print(3*r*r)

Solution (Python):
n = int(input())
print(3*n**2)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
r = int(input())
print(3 * (r ** 2))

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
r = int(input())

print(3 * r * r)

Solution (Python):
r = int(input())
print(3*(r**2))

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3 * (r**2))

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    r = int(input())
    print(3 * r * r)

if __name__ == "__main__":
    main()

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
r = int(input())
print(3*r*r)

Solution (Python):




def main():
    r = int(input())

    print(3 * r ** 2)


if __name__ == '__main__':
    main()

Solution (Python):
a = int(input())

print(3 * a * a)

Solution (Python):
r = int(input())
print(3*r*r)

Solution (Python):
a = int(input())

print(3*a*a)

Solution (Python):
n = int(input())
print(3*n*n)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    
    a = int(input())
    print(3 * a * a)
    
    return 0

main()

Solution (Python):
r = int(input())

print(3*r**2)

Solution (Python):
a=int(input())
print(3*a*a)

Solution (Python):
hoge = int(input())

print(3*hoge*hoge)

Solution (Python):
x = int(input())
print(3*x*x)

Solution (Python):
print(int(input())**2*3)

Solution (Python):
r = int(input())
print(3*(r**2))

Solution (Python):
a=int(input())
print(3*(a**2))

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
r = int(input())

print(3*r**2)

Solution (Python):
r=int(input())
print(r*r*3)

Solution (Python):
r = int(input())
print(3 * r * r)

Solution (Python):
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations

from itertools import accumulate
from bisect import bisect_left, bisect_right

import re




def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
 
def i_inpl(): return int(input())
def l_inpl(): return list(map(int, input().split()))
def line_inpl(x): return [i_inpl() for _ in range(x)]

INF = int(1e18)
MOD = int(1e9)+7 



r = i_inpl()

print(3*(r**2))

Solution (Python):
r = int(input())
print(3 * (r ** 2))

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

r = int(input())
print(r**2*3)

Solution (Python):
r=int(input())
print(3*r**2)

Solution (Python):
r=int(input())
print(3*(r**2))

Solution (Python):
r=int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
r = int(input())
print(3*r**2)

Solution (Python):
print(3*int(input())**2)

Solution (Python):


import sys
import math
import collections
import itertools
def input(): return sys.stdin.readline().strip()
def gcd(x, y): return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y): return (x * y) // gcd(x, y)
MOD = 10 **9 + 7

R = int(input())









print(3 * R * R)

Solution (Python):
print(3*int(input())**2)

Solution (Python):
r = int(input())
print(3 * (r ** 2))

Solution (Python):
print(3*(int(input())**2))