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:
#  --*-coding:utf-8-*--

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

print(r*r)

Submission status: Accepted

Solution code:
def main():
  #A, B = ( int(x) for x in input().split() )
  r = int( input() )
  
  print(r * r)

if __name__ == '__main__': main()

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

print(int(n**2))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s=list(map(int,input().split()))
print(s[0]*s[0])

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

r = int(input())

print(r**2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10000000)


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
i = int(input())

print(i ** 2)

Submission status: Accepted

Solution code:
# 2019/11/16

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#import sys

#input = sys.stdin.readline
import math
#import bisect

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True


def main():
#    h,w,a,b = map(int, input().split())
    r = int(input())
    print(r*r//1)




if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def two_int():
    N, K = map(int, input().split())
    return N,K

def one_int():
    return int(input())

def one_str():
    return input()

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

import math
r=one_int()
print(r*r)

Submission status: Accepted

Solution code:
from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math

print(int(stdin.readline().rstrip())**2)

Submission status: Accepted

Solution code:
#
import sys
import math
import numpy as np
import itertools

# ひとつ入力
n = int(input())

print(n*n)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

print(n*n)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

def main():
    n = int(input().strip())
    print(n**2)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

x = int(input())

ans = x * x

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import bisect
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


# A
def A():
    r = I()
    print(r * r)
    return


# B
def B():
    return


# C
def C():
    return


# D
def D():
    return


# E
def E():
    return


# F
def F():
    return


# Unittest
def resolve():
    A()
    return


# Solve
if __name__ == "__main__":
    A()

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    r = int(input())

    print(r**2)

Submission status: Accepted

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

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:
a = input()

a = int(a)

print(a*a)

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding utf-8 -*-

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

Submission status: Accepted

Solution code:
r = int(input())

S = r ** 2

print(int(S))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r = int(input())

ans = r*r

print(ans)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)

r = int(input())
#a, b = map(int, input().split())
#array = [int(s) for s in input().split()]

print(r**2)

Submission status: Accepted

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



if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r = int(input())

print (r * r)

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
input=lambda :sys.stdin.readline().rstrip()
inputs= sys.stdin.buffer.readlines
INF=float("inf")
MOD=10**9+7
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(2147483647)
#rstrip().decode('utf-8')
#import math
#import numpy as np
#import operator
#import bisect
#from heapq import heapify,heappop,heappush
#from math import gcd
#from fractions import gcd
#from collections import deque
#from collections import defaultdict
#from collections import Counter
#from itertools import accumulate
#from itertools import groupby
#from itertools import permutations
#from itertools import combinations
#from scipy.sparse import csr_matrix
#from scipy.sparse.csgraph import floyd_warshall
#from scipy.sparse.csgraph import csgraph_from_dense
#from scipy.sparse.csgraph import dijkstra
#map(int,input().split())


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



if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
#!/usr/bin/python3

import os
import sys


def main():
    print(read_int() ** 2)


###############################################################################

DEBUG = 'DEBUG' in os.environ


def inp():
    return sys.stdin.readline().rstrip()


def read_int():
    return int(inp())


def read_ints():
    return [int(e) for e in inp().split()]


def dprint(*value, sep=' ', end='\n'):
    if DEBUG:
        print(*value, sep=sep, end=end)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
# input = sys.stdin.readline
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

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



if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# ABC145a


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

    # map(int,input().split())

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import os, sys, re, math

r = int(input())
#N,D = map(int,input().split(' '))

print(r**2)

Submission status: Accepted

Solution code:
import bisect

mod = 1000000007

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


if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
input = sys.stdin.readline

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- Coding: utf-8 -*-

import sys


input = sys.stdin.readline


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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

r = int(input())

answer = r*r

print(answer)

Submission status: Accepted

Solution code:
R = int(input())

print(R * R)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

import numpy as np

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

    print(n**2)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  r = readInts()[0]
  print(r * r)

if __name__ == "__main__":
  main()

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt

from sys import exit

from copy import deepcopy
import numpy as np

import bisect
import re
import heapq


from copy import deepcopy
import itertools

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))






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





main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
r = int(input())
print(r * r)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

N = int(input())

print(N**2)

Submission status: Accepted

Solution code:
import math

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

# 
# a, b = list(map(int, input().split()))
# s = input()


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

Submission status: Accepted

Solution code:
from sys import stdin


def input():
    return stdin.readline()[:-1]


def intput():
    return int(input())


def sinput():
    return input().split()


def intsput():
    return map(int, sinput())


print(intput()  ** 2)

Submission status: Accepted

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

print(r**2)

Submission status: Accepted

Solution code:
R = int(input())

print(R**2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():

    r = int(input())
    return r * r

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys; readline = sys.stdin.readline
from collections import deque

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    r=int(input())
    print(r*r)
resolve()

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

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

Submission status: Accepted

Solution code:
import numpy as np

n = int(input())

print(int(n * n))

Submission status: Accepted

Solution code:
r = int(input())

s = r*r
print(s)

Submission status: Accepted

Solution code:
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    r = int(readline())
    print(r ** 2)


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def examA():
    N = I()
    ans = N*N
    print(ans)

def examB():
    N = I()


import sys,copy,bisect,itertools
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

Submission status: Accepted

Solution code:
#import heapq
#import itertools
#import math
#import numpy as np
#import sys

S = int(input())
#A,B = list(map(int, input().split()))
#S = [input() for _ in range(H)]
#T = [list(map(int,input().split())) for _ in range(N)]
#sys.exit()
print(int(S * S))

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

Submission status: Accepted

Solution code:
import sys
import math

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


print(r*r)

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

r = ni()
print(r*r)

Submission status: Accepted

Solution code:
import math
import copy
import sys
import fractions
import numpy as np
from functools import reduce
import statistics


# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputoData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===

n = getInputInt()

ans = n*n

print(ans)

Submission status: Accepted

Solution code:
n = int(input())
import math

print(n**2)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    r = int(inputs[0])
    return r * r


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-


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


if __name__ == '__main__':
  main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
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 I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  r=I()
  return r*r

# main()
print(main())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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
INF = 2**62-1


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 R**2


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import numpy as np

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

Submission status: Accepted

Solution code:
r, = (int(x) for x in input().split())

print(r*r)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

ri = lambda: int(input())
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]

r = ri()
print(r**2)

Submission status: Accepted

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


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


# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
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

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    r = II()
    print(r*r)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
import sys
input = sys.stdin.readline


def main():
    sc = Scan()
    a = sc.intarr()[0]
    print(a**2)


class Scan():

    def intarr(self):
        line = input()
        array = line.split(' ')
        num_array = [int(n) for n in array]
        return num_array

    def strarr(self):
        line = input()
        array = line.split(' ')
        array[-1] = array[-1].strip('\n')
        return array


main()

Submission status: Accepted

Solution code:
n = int(input())

print(int(n*n))

Submission status: Accepted

Solution code:
r = int(input())

print(r ** 2)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
def input():
    return sys.stdin.readline()[:-1]

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

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(10 ** 9)



INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7



print(I() ** 2)

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
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)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

r =I()

print(r * r)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

Solution code:

r = int(input())

print (r ** 2)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys, math
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans=count=0

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
t=int(input())
print(t**2)

Submission status: Accepted

Solution code:
import sys
from heapq import heapify, heappop, heappush
MAX_INT = int(10e15)
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(r**2)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

r=int(input())

print(r**2)

Submission status: Accepted

Solution code:
from fractions import gcd
from datetime import date, timedelta
from heapq import*
import math
from collections import defaultdict, Counter, deque
import sys
from bisect import *
import itertools
import copy
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7




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



            
            
            
            
            
        


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    print(int(input())**2)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

print(n*n)

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

r = ni()
print(r*r)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    n = input()
    print n * n


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    n = I()

    return n**2


print(main())

Submission status: Accepted

Solution code:
# coding: utf-8
# submission # - User: herp_sy
# https://atcoder.jp/contests/
#
# lang: Python3 (3.4.3)

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

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()

print(n**2)

Submission status: Accepted

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

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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