Problem:
 Score : 200 points    Problem Statement Find the largest square number not exceeding N . Here, a square number is an integer that can be represented as the square of an integer.      Constraints  1 \leq N \leq 10^9  N is an integer.         Input Input is given from Standard Input in the following format:  N       Output Print the largest square number not exceeding N .        Sample Input 1 10      Sample Output 1 9  10 is not square, but 9 = 3 × 3 is. Thus, we print 9 .       Sample Input 2 81      Sample Output 2 81       Sample Input 3 271828182      Sample Output 3 271821169

Solution (Python):
import numpy as np
import pdb

def main():
    N = int(raw_input())
    answer = solve(N)
    print int(answer)

def solve(N):
    answer = np.floor(np.sqrt(N))**2
    return answer

if __name__ == '__main__':
    main()

Solution (Python):
print((lambda x:max([i*i for i in range(100001) if x>=i*i]))(int(input())))

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

Solution (Python):
import math

n = float(input())
n = math.floor(math.sqrt(n))

print(n*n)

Solution (Python):
import math
N = int(input())
sq = int(math.sqrt(N))
for i in range(max(0, sq-1), sq+2):
    x = i**2
    if x <= N:
        ans = x
print(ans)

Solution (Python):
import math

N=int(input())

T=1
for i in range(N,0,-1):
    T=math.sqrt(i)
    if T%int(T)==0:
        break

print(int(T)*int(T))

Solution (Python):
N = int(input())
ans = 0
for i in range(int(N**0.5)+1):
    a = i**2
    if a <= N:
        ans = a

print(ans)

Solution (Python):
import math

N = float(input())
N = math.floor(math.sqrt(N))
print(N*N)

Solution (Python):
import numpy as np
N = input()
print int(np.sqrt(N + 0.1)) ** 2

Solution (Python):
n = int(input())
l = 0
r = n + 1

while l + 1 < r:
    m = l + (r - l) // 2
    if m**2 > n:
        r = m
    else:
        l = m
print(l**2)

Solution (Python):
n = int(input())
for i in range(n+1):
    if (i+1)**2 > n:
        print(i**2)
        exit()

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

a = 1

while a**2 <= N:
    a+=1

print((a-1)**2)

Solution (Python):
import math


print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math
a = int(input())
ans = int(math.sqrt(a))**2
print(ans)

Solution (Python):
n=int(input())
i=1
while i*i<=n:
    i+=1
print((i-1)*(i-1))

Solution (Python):
import math

n=float(input())

x=math.sqrt(n)
x=math.floor(x)
print(x*x)

Solution (Python):
import math
e=int(input())
print(math.floor(e**(1/2))**2)

Solution (Python):
from math import sqrt
print(int(pow(int(sqrt(int(input()))),2)))

Solution (Python):
import math
print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math
N = int(input())
ans = int(math.sqrt(N)) ** 2
print(ans)

Solution (Python):
import math;print(math.floor(math.sqrt(int(input())))**2)

Solution (Python):
import math

a=int(input())

while 1:

    b=math.sqrt(a)

    if a%b==0:
        print(a)
        break
    elif a%b>0:
        a=a-1

Solution (Python):
import math
N = int(input())
print(int(math.sqrt(N))**2)

Solution (Python):
Ns = input()
N = int(Ns)
o = 1

while(N >= (o * o)):
    o = o + 1

print((o - 1) * (o - 1))

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

Solution (Python):
import math

N = float(input())

Nsqrt = int(math.sqrt(N))
ans = Nsqrt**2

print(ans)

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

for i in range(a+1):
    if(i*i < a or i*i == a):
        b = i
    else:
        break
        
print(b*b)

Solution (Python):
import math
n = int(input())
print(int(math.sqrt(n)) ** 2)

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

Solution (Python):
A,B,N = 0,1,int(input())
while (True):
	A += 1
	if A*A>N:
		break
	b = A*A     
print(b)

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

for i in range(n, 0, -1):
  if math.sqrt(i).is_integer():
    print(i)
    break

Solution (Python):


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

Solution (Python):
import math

N = int(input())
print(int(math.sqrt(N))**2)

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

x=int(N**0.5)
print(x**2)

Solution (Python):
import math
print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math
N = int(input())
a = int(math.sqrt(N)//1)
ans = a*a
print(ans)

Solution (Python):
import math
print int(math.pow(int(math.sqrt(input())), 2))

Solution (Python):
import math
n=int(input())
a=math.trunc(math.sqrt(n))
print(a**2)

Solution (Python):
def solve():
    N = int(input())
    ans1 = 0
    n = 0
    while ans1 <= N:
        ans1 = n ** 2
        n += 1
 
    print((n - 2) **  2)
    
    
solve()

Solution (Python):
import math as m
N = int(input())
X = m.pow(m.floor(m.sqrt(N)),2)
print(int(X))

Solution (Python):
import math

n = int(raw_input())
while True:
    if int(math.sqrt(n)) == math.sqrt(n):
        print n
        break
    else:
        n -= 1

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

import numpy as np
b = int(np.sqrt(a))

print(b**2)

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

print(int(N**0.5)**2)

Solution (Python):
import math

def main():
    N = int(input())
    max_sqrt = int(math.sqrt(N))
    print(max_sqrt * max_sqrt)

if __name__ == '__main__':
    main()

Solution (Python):
from math import*
print(int(sqrt(int(input())))**2)

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

while True:
	if int(N**(1/2)) == N**(1/2):
		break
	else:
		N -= 1
print(N)

Solution (Python):
import math

n = int(input())
print(math.floor(math.sqrt(n)) ** 2)

Solution (Python):
a = int(input())
b = a **(1/2)
if b == int(b):
  print(a)
else:
  print(int(b) ** 2)

Solution (Python):

import math

n=int(raw_input())
r=math.sqrt(n)
print int(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**15
mod = 10**9+7

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 S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n = I()
    sq = math.sqrt(n)
    r = 1
    for i in range(int(sq)-2, int(sq)+2):
        if i**2 <= n and r < i**2:
            r = i**2

    return r



print(main())

Solution (Python):
n=int(input())
for i in range(1,n+2):
 if i*i>n:print(~-i*~-i);break

Solution (Python):

 
import math
 
num=int(input())
 
for i in reversed(range(1, num+1)):
    rev=math.sqrt(i)
    
    if( rev-int(rev) == 0 ):
        print(i)
        break

Solution (Python):
def solve():
    N = int(input())
    ans = 0
    while ans*ans <= N:
        ans += 1
    print((ans-1)**2)
 
solve()

Solution (Python):
import math

N = int(input())
route = math.floor(math.sqrt(N))

print(route**2)

Solution (Python):

import math

N = int(input())
x = math.sqrt(N)

print(int(x)**2)

Solution (Python):
N = int(input())
maxsq = 0
for i in range(N+1):
    if(i*i <= N):
        maxsq = i*i
    elif(i*i > N):
        break;
print(maxsq)

Solution (Python):
a=int(input())
for i in range(a):
    if(i*i>a):
        print((i-1)*(i-1))
        break

if a<=2: print("1")

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

i = 1
sq = i * i
while sq <= N:
    i += 1
    temp = i * i
    if temp > N:
        break
    sq = temp

print(sq)

Solution (Python):
import math
print(str(int(math.pow(int(math.sqrt(int(input()))),2))))

Solution (Python):
import math
N = int(input())
n = int(math.sqrt(N))
ans = n **2
print(ans)

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

x=1
while 1:
    if (x+1)**2>n:
        break
    x+=1
print(x**2)

Solution (Python):
import numpy

n = int(input())

for i in range(n):
    a = int(numpy.sqrt(n - i))
    b = n - i
    if a**2 == b:
        print(b)
        break
    else:
        pass

Solution (Python):
import sys
import random
import math

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

def rdi():
        return [ int(x) for x in rd().split() ]

N, = rdi()

s = int(math.sqrt(N))
print s * s

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

Solution (Python):
N=int(input())
n=1
while n*n <= N:
  n += 1
print((n-1)**2)

Solution (Python):
import math


def main():
    n = int(input())
    maxv = -1
    for x in range(1, int(math.pow(n, 1/2))+1):
        t = x**2
        if t > maxv and t <= n:
            maxv = t
    print(maxv)


if __name__ == "__main__":
    main()

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

print(int(N ** 0.5) ** 2)

Solution (Python):
n=int(raw_input())
for k in range(40000):
  if k**2>n:
    print (k-1)**2
    break

Solution (Python):
import math;print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math
N=int(input())
n=math.sqrt(N)
m=math.floor(n)
print(m*m)

Solution (Python):
import math
print((int(math.sqrt(int(input()))))**2)

Solution (Python):
import math
N=int(input())
O=math.sqrt(N)
print(int(O)*int(O))

Solution (Python):

import math

def around_square(N):
	i = int(math.sqrt(N))
	print(pow(i, 2))


N = int(input())
around_square(N)

Solution (Python):
import sys,collections,math 
sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
t = N
while 1:
    sqr = math.sqrt(t)
    if (sqr==int(sqr)):
        print(int(sqr**2))
        break
    else:
        t= t - 1

Solution (Python):
n = int(raw_input())
n = int(n**0.5);
print n*n

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
INF = float("inf")
 
 
def main():
    N = int(input())
    ans = 0
    for i in range(10**9):
        if i * i <= N:
            ans = max(ans, i * i)
        else:
            break
    print(ans)
 
 
if __name__ == '__main__':
    main()

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

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

Solution (Python):

import math
N = int(input())
a = math.floor(math.sqrt(N))
print(a**2)

Solution (Python):
n = int(raw_input())
m = 1
while m**2 <= n:
    m += 1
print (m-1)**2

Solution (Python):
import numpy as np
import math
N = int(input())
print(math.floor(np.sqrt(N))**2)

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

Solution (Python):



def main():
    N = int(input())
    i = 0
    while True:
        if i ** 2 > N:
            return (i - 1)  ** 2
        i += 1
if __name__ == "__main__":
    print(main())

Solution (Python):
import math
N = int(input())
print(int(math.sqrt(N))**2)

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

for i in range(n+1):
    if i**2>n:
        break
print(max((i-1)**2,1))

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

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

Solution (Python):
import math
N=input()
print int(math.sqrt(N))*int(math.sqrt(N))

Solution (Python):
def around_square(N):
    return int(N**(0.5))**2

N = int(input())
print(around_square(N))

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
INF = float("inf")


def main():
    N = int(input())
    ans = 0
    for i in range(10**9):
        if i * i <= N:
            ans = max(ans, i * i)
        else:
            break
    print(ans)


if __name__ == '__main__':
    main()

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

Solution (Python):
def main():
    n = int(input())
    i = 1
    while i*i <= n:
        i += 1
    print( (i-1) * (i-1) )
main()

Solution (Python):
N=int(input())
a=int(N**0.5)

print(a**2)

Solution (Python):
from math import sqrt

def main():
	n = int(input())
	
	for i in reversed(range(n+1)):
	    if sqrt(i) - int(sqrt(i)) == 0:
	        print(i)
	        break
        
if __name__ == "__main__": main()

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

n=math.floor(math.sqrt(N))
print(n*n)

Solution (Python):
import math

n = int(input())

number = []
for i in range(1,n+1):
    if int(math.pow(i, 2)) > n:
        break
    else:
        number.append(int(math.pow(i, 2)))

print(max(number))

Solution (Python):
import math
n = int(input())
n_sqrt = math.sqrt(n)
max_n = 0

for i in range(int(n_sqrt) + 1):
    if i ** 2 <= n and i ** 2 > max_n:
        max_n = i

print(max_n ** 2)

Solution (Python):
from math import *
print(int(sqrt(int(input()))) ** 2)

Solution (Python):
import math
n = int(input())
tmp = int(math.sqrt(n))
print(tmp*tmp)

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

k = 1
while k**2 <= n:
    ans = k**2
    k += 1
print(ans)

Solution (Python):
import sys

DBG_FLAG = 0

def p_dbg(str):
    if(DBG_FLAG == 1):
        sys.stdout.flush()
        print str



Num = int(raw_input())

p_dbg('Num : ' + str(Num))

square_max = 1










i = 1
tmp = 1
while tmp <= Num:
    p_dbg(str(i) + ':' + str(square_max))
    square_max = tmp
    tmp = i*i
    i = i+1

print square_max

Solution (Python):
a = int(input())
import math
b = math.sqrt(a)
c = math.floor(b)
d = c**2
print(d)

Solution (Python):

import math

n = int(raw_input())
print int(math.floor(math.sqrt(n)) ** 2)

Solution (Python):
N=int(input())
i=0
while (i+1)**2<=N:
    i+=1
print(i**2)

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

    Sn = [] 
    i = 1
    while 1:
        if i ** 2 <= N:
            Sn.append(i ** 2)
            i += 1
        else:
            break

    print(Sn[-1])


if __name__ == "__main__":
    main()

Solution (Python):


def main():
    n = input()
    l = []
    for i in xrange(1, n+1):
        s = i ** 2
        l.append(s)

        if s > n:
            print l[-2]
            return

    print 1

main()

Solution (Python):
import sys
import math

n = int(input())

root = math.floor(math.sqrt(n))
print(int(root * root))

Solution (Python):
import math

a = int(input())

ans = int(math.sqrt(a))
print(ans**2)

Solution (Python):
import math

n = int(input())
ans =1
for i in range(n,0,-1):
    if isinstance(math.sqrt(i),float) and math.sqrt(i) == int(math.sqrt(i)):
        ans = i
        break
print(ans)

Solution (Python):
N = int(input().strip())
 
count = 0
while True:
    if (count + 1) ** 2 > N:
        print(count ** 2)
        break
    count += 1

Solution (Python):
from math import *
n = input()

print(int(floor(sqrt(int(n))))**2)

Solution (Python):
N = int(input())
i = 1
while True:
    if i ** 2 > N:
        sq = (i - 1) ** 2
        break
    elif i ** 2 == N:
        sq = i ** 2
        break
    else:
        i += 1

print(sq)

Solution (Python):
import numpy as np

N = int(input())
print(int(np.sqrt(N)) ** 2)

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

a = []

for i in range(n) :
    if (i+1)**2 <= n:
      a.append((i+1)**2 )
    else:
      break

print(a[-1])

Solution (Python):
import math

a = int(input())
b = math.floor(math.sqrt(a))
print(b*b)

Solution (Python):

a = int(input())
import math
def Bround(a):
    while True:
        s = math.floor(math.sqrt(a))
        if s * s == a:
            return a
        else:
            a -= 1
print(Bround(a))

Solution (Python):
import math

N = int(input())
rN = math.sqrt(N)
A = int(rN)**2
print(A)

Solution (Python):
import math
a = math.sqrt(int(input()))
a = int(a)
print(a**2)

Solution (Python):

import numpy
N = int(input())
X = numpy.sqrt(N)

print(int(X)*int(X))

Solution (Python):



N = int(raw_input())
n = 1

while n * n <= N :
    n = n + 1

print (n - 1) * (n - 1)

Solution (Python):
import math

a = int(input())
for n in range(a):
    
    if math.sqrt(a-n) == int(math.sqrt(a-n)):
            break

print(a-n)

Solution (Python):
import math
row1=int(raw_input())

while True:
    arg=math.sqrt(row1)
    if arg == int(arg):
        output=row1
        break
    row1-=1
print output

Solution (Python):
def B_Around_Square(N):
    ans=[]
    tmp=0
    while tmp**2<=N:
        ans.append(tmp**2)
        tmp+=1
    return ans[-1]

N = int(input())
print(B_Around_Square(N))

Solution (Python):


n = int(input())

for num in range(100000):
    if pow(num,2) > n:
        print (pow(num-1,2))
        break

Solution (Python):
import math

N = int(input())
for i in range(N):
    y = math.sqrt(N-i)
    if int(y) == y:
        print(N-i)
        break

Solution (Python):
import math
N = int(input())
print(math.floor(math.sqrt(N))**2)

Solution (Python):
import numpy as np
n=int(input())
for i in range(n,0,-1):
    if np.sqrt(i)==int(np.sqrt(i)):
        print(i)
        break

Solution (Python):

import math
N = int(input())
N = math.floor(math.sqrt(N))
print(N*N)

Solution (Python):
from math import sqrt

innum = int(input())
outnum = int(sqrt(innum))
print(outnum*outnum)

Solution (Python):


import math

num=int(input())

for i in reversed(range(1, num+1)):
    rev=math.sqrt(i)
    
    if( rev-int(rev) == 0 ):
        print(i)
        break

Solution (Python):
import math


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

    ans = int(math.sqrt(N)) ** 2
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
import math
N = int(input())
print(int(math.sqrt(N))**2)

Solution (Python):
n = int(input())
m = 1
while m**2<=n:
    m+=1
print((m-1)**2)

Solution (Python):

import math


def test(N):
    while True:
        num = (int(math.sqrt(N)))**2
        if num < N:
            N -= 1
        else:
            return N

if __name__ == "__main__":
    N = int(input())
    answer = test(N)
    print(answer)

Solution (Python):
n = int(input())
m = 1
while m**2<=n:
    m+=1
print((m-1)**2)

Solution (Python):
import math

N = int(input())
print(math.floor(math.sqrt(N))**2)

Solution (Python):
import math

N = int(input())

print(math.floor(math.sqrt(N)) ** 2)

Solution (Python):
def main():
    N = int(input())
    ans = 1
    
    for num in range(N, 0, -1):
        int_rt_num = int(num**0.5)
        if(num == int_rt_num**2):
            ans = num
            print(ans)
            break
    
if __name__=="__main__":
    main()

Solution (Python):
n = int(input())
i = 0
while i**2 <= n:
    i+=1
print((i-1)**2)

Solution (Python):
import math
N = int(input())
n = int(math.sqrt(N))
print(n * n)

Solution (Python):

import numpy as np
import math

N = input()

sq = np.sqrt(N)
s = int(math.floor(sq))
print s*s

Solution (Python):
a = int(input())
count = 1
while True:
    b = count**2
    c = (count+1)**2
    if c > a:
        print(b)
        break
    else:
        count += 1
        b = c

Solution (Python):

N=int(input())
maxi=0
for i in range(1,N+1):
    if pow(i,2)<=N:
        maxi=pow(i,2)
    else:
        break
print(maxi)

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

i = N **(1/2)
i =int(i)

print(i**2)

Solution (Python):
N = int(input())
tmp = 1
for i in range(N, 1, -1):
    tmp = int(pow(i, 0.5))
    if tmp * tmp == i:
        break
print(tmp * tmp)

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

j = 0
i = 0
while N > i:
    i = j ** 2
    j += 1

if (j - 1) ** 2 == N:
    print( ( j - 1 ) ** 2)

else:
    print( (j - 2) ** 2)

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

judge ="True"
count = 1
while  judge == "True": 
    ans = pow(count,2)
    if input_lines >= ans:
        count +=1
    else:
        judge="False"
        print(pow(count-1,2))

Solution (Python):
import sys
import math

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

for i in range(N, 0, -1):
    if math.sqrt(i).is_integer() == True:
        print (i)
        break

Solution (Python):
N=int(input())
i=0
while i*i<=N:
    i+=1
i-=1
print(i*i)

Solution (Python):
import math
x = int(raw_input())
a = math.floor(math.sqrt(x))
print(int(a*a))

Solution (Python):
import math
n = int(input())
print(int(math.pow(math.floor(math.sqrt(n)), 2)))

Solution (Python):
import math
N = int(input())
for i in range(N+1)[::-1]:
  a = math.sqrt(i)
  if a % 1 == 0:
    print(i)
    break
  else:
    continue

Solution (Python):
import math
n = int(input())
ans = int(math.sqrt(n))
print (ans**2)

Solution (Python):
import sys
import math

N = int(input())
for i in range(N):
    num = N-i
    sq = math.sqrt(num)
    if sq == int(sq):
        break
print(num)

Solution (Python):
n = input()
a = 1
ans = 1
while(1):
    if a**2 > n: break
    ans = a**2
    a += 1
print ans

Solution (Python):
def solve():
    N = int(input())
    ans1 = 0
    n = 0
    while ans1 <= N:
        ans1 = n ** 2
        n += 1

    print((n - 2) **  2)
    
    
solve()

Solution (Python):
import sys
N=input()

for i in range(100000):
	if i*i==N:
		print i*i
		sys.exit()		
	elif i*i>N:
		print (i-1)*(i-1)
		sys.exit()
	else:
		continue

Solution (Python):
import math
N = int(input())
print(int(math.sqrt(N)) ** 2)

Solution (Python):
import math

num = int(input())
for i in reversed(range(0, num+1)):
    val = math.sqrt(i)
    if val - int(val) == 0:
        print(i)
        break

Solution (Python):
def solve():
    N = int(input())
    ans = 0
    while ans*ans <= N:
        ans += 1
    print((ans-1)**2)

solve()

Solution (Python):
import math

n = int(input())
print(math.floor(math.sqrt(n))**2)

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

Solution (Python):
import math
print(int(math.sqrt(int(input()))) ** 2)

Solution (Python):

import math


n = int(input())

print(math.floor(math.sqrt(n)) ** 2)

Solution (Python):

import math

N = int(input())
print(int(math.sqrt(N)) ** 2)

Solution (Python):
import math
N = int(raw_input())

print int(math.floor(math.sqrt(N)) ** 2)

Solution (Python):
n = int(input())
for i in range(n+2):
	if i**2 > n:
		print((i-1)**2)
		break

Solution (Python):

from sys import stdin, stdout
from math import sqrt

def rint():
   return map(int, stdin.readline().split())

a = int(input())
aa = int(sqrt(a))
print(aa*aa)

Solution (Python):
from math import sqrt

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

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

Solution (Python):
import math

n = int(input())

nq = int(math.sqrt(n))
print(nq * nq)

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

Solution (Python):





from sys import stdin
from math import sqrt

def solve(N):
    return int(sqrt(N)) ** 2

N = int(stdin.readline())
print(solve(N))

Solution (Python):



"""077-b"""

import sys
import pprint
import re
import math

import itertools
pp = pprint.PrettyPrinter(indent=2)

def main():
    """Main function."""
    N = int(input())
    print(int(math.sqrt(N)) * int(math.sqrt(N)))


if __name__ == '__main__':
    sys.exit(main())

Solution (Python):
import sys
import numpy as np

n = int(sys.stdin.readline().strip())
a = int(np.sqrt(n))
print(str(a*a))

Solution (Python):
from math import sqrt

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

Solution (Python):
import math

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

    x = int(math.sqrt(N))
    print(x ** 2)

main()

Solution (Python):
N = int(input())
i = 1
while True:
    if i ** 2 > N:
        break
    i += 1

print((i-1) ** 2)

Solution (Python):
import numpy as np
import copy as cp

N = int(input())
MIN = np.sqrt(N) - 1
MAX = np.sqrt(N)

m = int(MAX)
print(m**2)

Solution (Python):
N = int(input())
n = 1
while True:
	if (n + 1) ** 2 > N:
		break
	else:
		n += 1
print(n ** 2)

Solution (Python):
N=int(input())
s=0
while s*s<=N:
    s += 1
print((s-1)*(s-1))

Solution (Python):
import math
print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math
i = int(input())

print(pow(int(math.sqrt(i)), 2))

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

n = 1
while True:
    if n*n <= N and N < (n+1)*(n+1):
        print(n*n)
        break
    else:
        n += 1

Solution (Python):


import math
n = int(input())

while(True):
    result = math.sqrt(n)
    if math.floor(result) == result: break
    n -= 1
    
print(n)

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

Solution (Python):
import math
n = int(input())
print(math.floor(math.sqrt(n)) ** 2)

Solution (Python):
import math
N=int(raw_input())
print int(math.pow(math.floor(math.sqrt(N)),2))

Solution (Python):
from math import sqrt
N=int(sqrt(int(input())))
print(N*N)

Solution (Python):
N = int(input())
from math import sqrt
print(int(sqrt(N))**2)

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

sqrtn = math.sqrt(n)

print(math.floor(sqrtn)**2)

Solution (Python):
import math

if __name__ == '__main__':
    N = int(input())
    print(int(math.sqrt(N)) ** 2)

Solution (Python):
import math
t=int(input())
a=int(math.sqrt(t))
print(a*a)

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

Solution (Python):

"""
https://beta.atcoder.jp/contests/abc077/tasks/abc077_b

"""
import sys
from sys import stdin
input = stdin.readline


def main(args):
    N = int(input())
    ans = 1

    for i in range(int(N**0.5)+1):
        ans = i
    print(i**2)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
import math

a = int(input())
b = math.sqrt(a)
print(int(b)**2)

Solution (Python):
import  math
print(int(math.sqrt(int(input())))**2)

Solution (Python):
import math

x = int(raw_input())
sqrt = int(math.sqrt(x))
print(sqrt*sqrt)

Solution (Python):
n=int(input())
sqn=(n**0.5)//1
print(int(sqn**2))

Solution (Python):
import math
for i in range(int(input()), -1, -1):
	temp = math.sqrt(i)
	
	if math.floor(temp) == temp:
		print(i)
		break

Solution (Python):
import math

N = int(input())
n = int(math.sqrt(N))
print(n**2)

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

Solution (Python):
n = int(input())
x = 1
while x * x <= n:
    x += 1

x -= 1
print(x * x)