Problem:


Score : 100 points

Problem Statement

Given is an integer r.

How many times is the area of a circle of radius r larger than the area of a circle of radius 1?

It can be proved that the answer is always an integer under the constraints given.

Constraints

1 \leq r \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

r

Output

Print the area of a circle of radius r, divided by the area of a circle of radius 1, as an integer.

Sample Input 1

2

Sample Output 1

4

The area of a circle of radius 2 is 4 times larger than the area of a circle of radius 1.

Note that output must be an integer - for example, 4.0 will not be accepted.

Sample Input 2

100

Sample Output 2

10000



Sample input:
2


Sample output:
4

Submission status: Accepted

Solution code:
r = int(raw_input())

n = r * r

print n

Submission status: Accepted

Solution code:
r = int(input()) 
print(r*r)

Submission status: Accepted

Solution code:
#!/usr/bin/pypy
r = int(raw_input())

print str(r*r)

Submission status: Accepted

Solution code:
a = int(input())
print(a**2)

Submission status: Accepted

Solution code:
def f(n):
    print(n * n)


if __name__ == '__main__':
    n = int(input())
    f(n)

Submission status: Accepted

Solution code:
r = int(input().strip())

print(r**2)

Submission status: Accepted

Solution code:
r = int(raw_input())
print r*r

Submission status: Accepted

Solution code:
def resolve():
    r = int(input())
    print(r*r)
resolve()

Submission status: Accepted

Solution code:
print(int(input().strip())**2)

Submission status: Accepted

Solution code:
x = int(input())
print(x * x)

Submission status: Accepted

Solution code:
N = int(input())
print(N * N)

Submission status: Accepted

Solution code:
r = int(input())
res = r**2
print(res)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
INF = float("inf")


def solve(r: int):
    print(r**2)
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    r = int(next(tokens))  # type: int
    solve(r)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
r = int(input())


print(r ** 2)

Submission status: Accepted

Solution code:
# your code goes here
t=input()
t=int(t)
print(t*t)

Submission status: Accepted

Solution code:
num = int(input())

print(num*num)

Submission status: Accepted

Solution code:
r = int(input())
a=r*r

print(a)

Submission status: Accepted

Solution code:
A = int(input())
print(A**2)

Submission status: Accepted

Solution code:

r = int(input())

r2 = int(r**2)

print(r2)

Submission status: Accepted

Solution code:
circle_r_text = input()
circle_r = int(circle_r_text)

circle_area = circle_r ** 2;
print(circle_area)

Submission status: Accepted

Solution code:
x = input()
print x*x

Submission status: Accepted

Solution code:
import math
x = int(input())
print ('{0}'.format(x**2))

Submission status: Accepted

Solution code:
n = int(input())

print (n*n)

Submission status: Accepted

Solution code:
input_x = input()
x = int(input_x)

compared = x*x

print(str(compared))

Submission status: Accepted

Solution code:
r=int(input())

print((r**2))

Submission status: Accepted

Solution code:
s=int(input())

print(s*s)

Submission status: Accepted

Solution code:
x = int(input())
print(x * x)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
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())


a=II()
print(a*a)

Submission status: Accepted

Solution code:
# coding: utf-8
print(pow(int(input()),2))

Submission status: Accepted

Solution code:
def main():
    print(int(input()) ** 2)
    return


main()

Submission status: Accepted

Solution code:
s = input ()

def radius(r):
  to_number = int(r)
  return to_number ** 2

print (radius(s))

Submission status: Accepted

Solution code:
r= int(input())
if (1<=r and r<=100):
 print(r*r)

Submission status: Accepted

Solution code:
import sys

r      = input()
intr   = int(r)
floatr = float(r)

if intr < 1 or intr > 100:
    print( "ERROR:input value is wrong!")
    exit() 

print( int( floatr**2e0 ) )

Submission status: Accepted

Solution code:
b = int(input())
c = b*b
print(c)

Submission status: Accepted

Solution code:
b = int(input())
c = b*b
print(c)

Submission status: Accepted

Solution code:
N = int(input())

print(N*N)

Submission status: Accepted

Solution code:
N = int(input())

print(N*N)

Submission status: Accepted

Solution code:
# Contest: AtCoder Beginner Contest 145 (https://atcoder.jp/contests/abc145)
# Problem: A: Circle (https://atcoder.jp/contests/abc145/tasks/abc145_a)

def rint():
    return int(input())


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


print(rint()**2)

Submission status: Accepted

Solution code:
r = int(input())
print(int(r ** 2))

Submission status: Accepted

Solution code:
ret = int(input())**2
print(ret)

Submission status: Accepted

Solution code:
r = int(input())

print(r * r)

Submission status: Accepted

Solution code:
r = int(input())

b = r * r

print(b)

Submission status: Accepted

Solution code:
r = int(input())
print(r * r // 1)

Submission status: Accepted

Solution code:
import math

def circle(r):
    return r*r

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-
#入力
r = int(input())

print(int(r**2))

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()

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

main()

Submission status: Accepted

Solution code:
print(int((pow(int(input()), 2))))

Submission status: Accepted

Solution code:
n = int(input())

print(str(n*n))

Submission status: Accepted

Solution code:
import io

def main():
    s = input()

    basic = 1 * 1

    enter = int(s) * int(s)

    print (enter)


if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
n=int(input())
if n<=100:
    print(int(n**2//1))

Submission status: Accepted

Solution code:
r=int(input());print(r*r)

Submission status: Accepted

Solution code:
from sys import stdin
r = int(stdin.readline().rstrip())
print(r**2)

Submission status: Accepted

Solution code:
r = int(input())

print(r ** 2)

Submission status: Accepted

Solution code:
def main():
    n = iread()
    print(n ** 2)

def iread():
    return int(input())


def sread():
    return input()


def aread(t="int"):
    if t == "int":
        ret = [int(i) for i in input().split()]
    elif t == "str":
        ret = list(input().split())
    return ret


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import copy
import heapq

def j(n):
    if n:print("Yes")
    else:print("No")
    exit(0)
rem = 10 ** 9 + 7

"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def ipmultiplerow(n):
    a = []
    for i in range(n):
        a.append(ip())
    return a
def printrow(a):
    for i in a:
        print(i)

print(ip()**2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r = int(input().strip())
print(r**2)

Submission status: Accepted

Solution code:
aaa = int(input())
print(aaa*aaa)

Submission status: Accepted

Solution code:
import sys
import math
import collections
import itertools
import array
import inspect

# Set max recursion limit
sys.setrecursionlimit(1000000)


# Debug output
def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))


# Binary converter
def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in sys.stdin.readline().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v

def comb(n, r):
    if n - r < r: r = n - r
    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 bisearch(L, target):
    low = 0
    high = len(L) - 1
    
    while low <= high:
        mid = (low + high) // 2
        guess = L[mid]
        if guess == target:
            return True
        elif guess < target:
            low = mid + 1
        elif guess > target:
            high = mid - 1
    if guess != target:
        return False

# --------------------------------------------

dp = None


def main():
    print(int(input())**2)


main()

Submission status: Accepted

Solution code:
r = int(input())


print(r*r)

Submission status: Accepted

Solution code:
a=int(input(""))
print(a**2)

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-

def solve():
    r = int(input())
    print(r*r)


if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
r=input()
r=int(r)
print(r**2)

Submission status: Accepted

Solution code:
a=int(input())
s=a**2
print(s)

Submission status: Accepted

Solution code:
r = int(raw_input())
print r * r

Submission status: Accepted

Solution code:
import sys
from collections import Counter, deque, defaultdict, OrderedDict
from math import factorial
from fractions import Fraction
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

r = INT()
print(r**2)

Submission status: Accepted

Solution code:
# https://atcoder.jp/contests/abc145/tasks/abc145_a
import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop


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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())
print(round(n * n))

Submission status: Accepted

Solution code:
m = int(input())
print(m*m)

Submission status: Accepted

Solution code:
# coding=utf-8

if __name__ == '__main__':
    r = int(input())

    print(r*r)

Submission status: Accepted

Solution code:
r = int(input())
S = r**2
ans = S // 1
print(ans)

Submission status: Accepted

Solution code:
n = int(input().strip())
print (n*n)

Submission status: Accepted

Solution code:
r=int(input())
print(r**2//1**2)

Submission status: Accepted

Solution code:
n = int(raw_input())
print n*n

Submission status: Accepted

Solution code:
r=int(input()) 
print(r*r)

Submission status: Accepted

Solution code:
def resolve():
    r = int(input())
    print(r * r)


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
num=int(input())
num=num**2
print(num)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(r: int):
    print(r**2)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    r = int(next(tokens))  # type: int
    solve(r)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def solve(r):
    return r*r

r = int(input())
print(solve(r))

Submission status: Accepted

Solution code:

x = int(input())
print(x * x)

Submission status: Accepted

Solution code:
# A
r = int(input())
print(r ** 2)

Submission status: Accepted

Solution code:
def main():
    global visited, adj, sets
    print = out.append
    ''' Cook your dish here! '''
    q = get_int()
    print(q**2)



''' Coded with love at India by Satyam Kumar '''
import sys, threading
from collections import defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
out = []
get_int = lambda: int(input())
get_list = lambda: list(map(int, input().split()))
main()
# [main() for _ in range(int(input()))]
print(*out, sep='\n')

Submission status: Accepted

Solution code:
print((int(input())**2))

Submission status: Accepted

Solution code:
#abc145a

r=int(raw_input())
print r**2

Submission status: Accepted

Solution code:
circle = int(input())
print(circle**2)

Submission status: Accepted

Solution code:
print(int(input())**2)

Submission status: Accepted

Solution code:
import numpy as np
r = int(input())
c = int(np.pi)*(1**2)
c2 = int(np.pi)*(r**2)
print(int(c2/c))

Submission status: Accepted

Solution code:
r = input()
r = int(r) ** 2
print(r)

Submission status: Accepted

Solution code:
def main():
    print(int(input()) ** 2)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
r = int(input())
A = r**2
print(A)

Submission status: Accepted

Solution code:
r = int(input())

print(int(r*r))

Submission status: Accepted

Solution code:
r = int(input())

S = r*r
print(S)

Submission status: Accepted

Solution code:
#　A - Circle
r = int(input())
print(r ** 2)

Submission status: Accepted

Solution code:
import numpy as np
 
def calucurate_circle(r):
    S = np.pi * r ** 2
    return S
 
def mulitipulicity(r):
    n = r**2
    n = int(n)
    return n

r = float(input())
print(mulitipulicity(r))

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
sys.setrecursionlimit(300000)


def solve(r: int):
    ret = r * r
    print(ret)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    r = int(next(tokens))  # type: int
    solve(r)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
def print_ans(r):
    """Test Case
    >>> print_ans(2)
    4
    >>> print_ans(100)
    10000
    """
    print(r ** 2)

if __name__ == '__main__':
    r = int(input().rstrip())
    print_ans(r)

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
r = float(input())
a= r*r/1*1
print(int(a))

Submission status: Accepted

Solution code:
r=int(input())
a=r*r
print(a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = int(input())
a = a*a
print(a)

Submission status: Accepted

Solution code:
input_line = int(input())

print(input_line ** 2)

Submission status: Accepted

Solution code:
r = int(input())
 
print(r*r)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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
import itertools
input = sys.stdin.readline

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	r = inputInt()
 
	a = r*r
	print(a)


if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
i = int(input())

print(i*i)

Submission status: Accepted

Solution code:
r = int(input())
s = 1
for i in range(2):
  s = s * r
print(s)

Submission status: Accepted

Solution code:
def main():
  r = int(input())
  return r * r

if __name__ == '__main__':
  print(main())

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline
r = int(readline())
print(r*r)

Submission status: Accepted

Solution code:
radius = int(input())

print(pow(radius, 2))

Submission status: Accepted

Solution code:
r = int(input())

print('{}'.format(r ** 2))

Submission status: Accepted

Solution code:
i = int(input())

print(i**2)

Submission status: Accepted

Solution code:
r = int(input())
print(int(r * r))

Submission status: Accepted

Solution code:
# A - Circle
r = (int)(input())

print(r * r)

Submission status: Accepted

Solution code:
import math
def main():
    r=int(input())
    print(r**2)

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
R = int(input())
print(R**2)

Submission status: Accepted

Solution code:
print int(raw_input())**2

Submission status: Accepted

Solution code:
r=int(input())
s=r*r
print(s)

Submission status: Accepted

Solution code:
n = int(input())
import math
test = 1 * 1 * math.pi
test_ = n * n * math.pi
print(int(round(test_ / test,0)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
def main():
    inStr = input()
    try:
        r = int(inStr)
    except Exception as e:
        return

    print(r*r)

main()

Submission status: Accepted

Solution code:
a=int(input())

print(a*a)

Submission status: Accepted

Solution code:
c = int(input())
print(c*c)

Submission status: Accepted

Solution code:
r = int(input())
print("{}".format(r*r))

Submission status: Accepted

Solution code:
import numpy as np


def main():
	#N, D = [int(x) for x in input().split()]
	r = int(input())
	print(r*r)

if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
r = input().rstrip()
r = int(r)
print(r ** 2)

Submission status: Accepted

Solution code:
comparison = 1 ** 2 * 3.141592653589793
r = int(input())

x = r ** 2 * 3.141592653589793

ans = (x/comparison)

print(round(ans))

Submission status: Accepted

Solution code:
r = int(input())
print(int(r * r * 3 // 3))

Submission status: Accepted

Solution code:
r = input()
s = int(r)**2
a = s/1
print(int(a))

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

r = int(readline())
print(r*r)

Submission status: Accepted

Solution code:
r = int(input())
ans = r*r
print(int(ans))

Submission status: Accepted

Solution code:
import numpy
print(int(input())**2)

Submission status: Accepted

Solution code:
import sys
INPUT = sys.stdin.readline
#入力関数
def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()
 
r=SORO_INT()
print(r**2)

Submission status: Accepted

Solution code:
r = int(input())
ans = r**2
print(ans//1)

Submission status: Accepted

Solution code:
import math

r = int(input())
p = 1*1*math.pi
rp = r*r*math.pi

ret = rp / p
print(math.ceil(ret))

Submission status: Accepted

Solution code:
a = int(input())
print(a ** 2)

Submission status: Accepted

Solution code:

def circle():
    r = int(input())
    ans = r * r / 1
    print(int(ans))

circle()

Submission status: Accepted

Solution code:
x = int(input())
print(x ** 2)

Submission status: Accepted

Solution code:
input_int = input()

if input_int <= 100 and input_int >= 1:
	print(int(input_int) * int(input_int))

Submission status: Accepted

Solution code:
a =int(input())
print(a **2)

Submission status: Accepted

Solution code:

a = int(input())
print(a**2)

Submission status: Accepted

Solution code:
r = int(input()) 
print(r**2)

Submission status: Accepted

Solution code:
r=int(input())
print(str(r*r))

Submission status: Accepted

Solution code:
val = int(input())
print(val*val)

Submission status: Accepted

Solution code:
r = float(input())
print(int(r**2))

Submission status: Accepted

Solution code:
# 入力が10**5とかになったときに100ms程度早い
import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


r = read_a_int()
print(r**2)

Submission status: Accepted

Solution code:
r = int(input())
ans = int(r*r)
print(ans)

Submission status: Accepted

Solution code:
r = int(input())

s = r*r

print(int(s))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 半径(整数)の入力
r = int(input())

area = r*r

times = area/1

print('{:.0f}'.format(times))

Submission status: Accepted

Solution code:
data = int(input())
print(data * data)

Submission status: Accepted

Solution code:
import numpy

input_line= (input())

default=numpy.square(1)
input_num=numpy.square(int(input_line))

print (int(input_num/default))

Submission status: Accepted

Solution code:
if __name__ == '__main__':
  r = int(input())
  print(r*r)

Submission status: Accepted

Solution code:
data = int(input())
data = data * data
print(data)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline
r = int(readline())
print(int(r ** 2))

Submission status: Accepted

Solution code:
import math

r=int(input())
c=(r**2/3.14)
n=(1**1/3.14)
print(math.floor(c/n))

Submission status: Accepted

Solution code:
r = int(input())
print(r **2)

Submission status: Accepted

Solution code:
r = int(input()) #int

print(int((r**2)/(1**2)))

Submission status: Accepted

Solution code:
N = int(input())

output = N ** 2

print(output)

Submission status: Accepted

Solution code:
r = int(input())
print(int(r/1)**2)

Submission status: Accepted

Solution code:
import sys

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

Submission status: Accepted

Solution code:
import math
r = int(input())
print(math.ceil((math.pow(r,2) * math.pi) / (1 * math.pi)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 整数の入力
a = int(input())
out = a**2
# 出力
print(int(out))

Submission status: Accepted

Solution code:
str = int(input())
answer = str * str
print(answer)

Submission status: Accepted

Solution code:
import sys


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
m=int(input())
print(m * m)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#solve
def solve():
    n = II()
    print(n**2)
    return


#main
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
if __name__=='__main__':
    r = int(input())
    print("{}".format(r*r))

Submission status: Accepted

Solution code:
r = int(input())
out = r**2
print(out)

Submission status: Accepted

Solution code:
r = int(input())

ans= r**2

print(ans)

Submission status: Accepted

Solution code:
r = int(input())

def main(r):
    return r*r

print(main(r))

Submission status: Accepted

Solution code:
r=int(input())
a=r**2
print(a)

Submission status: Accepted

Solution code:
r = int(input())
S=r*r
print(int(S))

Submission status: Accepted

Solution code:
from sys import stdin
#from collections import deque
#from math import sqrt, floor, ceil, log, log2, log10, pi, gcd
def ii(): return int(stdin.readline())
def fi(): return float(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def fmi(): return map(float, stdin.readline().split())
def li(): return [x for x in mi()]
def si(): return stdin.readline()
n=ii()
print(n*n)

Submission status: Accepted

Solution code:
r = int(input())

d = int(r * r)

print(d)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def fi(): return float(input())
def mfi(): return map(float, input().rstrip().split())
def lmfi(): return list(map(float, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg): print(*arg); sys.exit()
# template


def main():
    r = ii()
    print(r * r)
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
r=int(input())
print(r**2)

Submission status: Accepted

Solution code:
r_x = int(input())

print(int(r_x**2))

Submission status: Accepted

Solution code:
# 2019 11/16
# ABC 145 A


r = int(input())

S = r * r

print(S)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

R = int(input())

print(int(R ** 2))

Submission status: Accepted

Solution code:
N = int(input().strip())
print(N * N)

Submission status: Accepted

Solution code:
r = int(input())


def solve():
    return r * r


print(solve())

Submission status: Accepted

Solution code:
from sys import stdin
#from collections import deque
#from math import sqrt, floor, ceil, log, log2, log10, pi, gcd
def ii(): return int(stdin.readline())
def fi(): return float(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def fmi(): return map(float, stdin.readline().split())
def li(): return [x for x in mi()]
def si(): return stdin.readline()
n=int(input())
print(n*n)

Submission status: Accepted

Solution code:
def a():
    r = int(input())
    print(r**2)


if __name__ == '__main__':
    a()

Submission status: Accepted

Solution code:
import math

pi = math.pi
circle1 = 1 ** 2

r = int(input())
circle2 = r ** 2

answer = int(circle2 / circle1)
print(answer)

Submission status: Accepted

Solution code:
import sys
r = int(input())
print(r*r)

Submission status: Accepted

Solution code:
# coding UTF-8
# 
# problem A
# 

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

Submission status: Accepted

Solution code:
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
#import random
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
ts=time.time()
sys.setrecursionlimit(10**6)
#input=sys.stdin.readline().rstrip
show_flg=False
show_flg=True

ans=0
n=I()
print(n**2)

Submission status: Accepted

Solution code:
r = int(input())
circle = r ** 2

print(circle)

Submission status: Accepted

Solution code:
r = int(input())

print (r ** 2)

Submission status: Accepted

Solution code:
from sys import stdin
#from collections import deque
#from math import sqrt, floor, ceil, log, log2, log10, pi, gcd
def ii(): return int(stdin.readline())
#def fi(): return float(stdin.readline())
def mi(): return map(int, stdin.readline().split())
#def fmi(): return map(float, stdin.readline().split())
def li(): return [x for x in mi()]
#def si(): return stdin.readline()
n=int(input())
print(n*n)

Submission status: Accepted

Solution code:
a = int(input())

ans = a * a

print(ans)

Submission status: Accepted

Solution code:
radius = int(input())
result = radius**2
print(int(result))

Submission status: Accepted

Solution code:
def circle(r):
    return r**2
str = int(input())
print(circle(str))

Submission status: Accepted

Solution code:
r = int(input())

ans = r * r

print(ans)

Submission status: Accepted

Solution code:
a = int(input())


print(a*a)

Submission status: Accepted

Solution code:
r = int(input()) #入力

t = r * r #直径
y = int(t / 1) #何倍

print(y) #出力

Submission status: Accepted

Solution code:
a = input()
a = int(a)
print(int(a**2))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        # for line in sys.stdin:
        #     lines.append(line)
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    r = int(lines[0])

    return (r, )


def solve(r):

    return r*r

def main():
    # 出力
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Submission status: Accepted

Solution code:
r = int(input())**2
print(int(r))

Submission status: Accepted

Solution code:
r = int(input())
print("{}".format(int(r**2)))

Submission status: Accepted

Solution code:
r = int(input())

cir = r * r

print(cir)

Submission status: Accepted

Solution code:
from math import pi
r = int(input())

print(r**2)