peterverebics/CodeNet_Python_118 huggingface dataset:
D,N=map(int,input().split())

if N!=100:
  if D==0: 
    print(N)
  elif D==1: 
    print(100*N)
  else: 
    print(10000*N)
else:
  if D==0: 
    print(101)
  elif D==1: 
    print(10100)
  else: 
    print(1000100)
d,n = map(int,input().split())

#print(n*100**d)
a = 0

while n > 0:
    a += 100**d
    n -= 1
print(a)
d,n=map(int,input().split())
if n==100:
    n=101
print(10**d*n)
# AtCoder Beginner Contest 100
# B - Ringo's Favorite Numbers

D,N=map(int,input().split())

print(N*100**D)
d, n = map(int, input().split())

if (d == 0):
  print(n)
else:
  print(100**d*n)
D, N = map(int, input().split())

ans = 100**D
ans += (N//100) * 100

print(ans*N)
D,N=map(int,input().split())
print((100**D)*N)
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

D, N = MAP()

print((100**D)*N)
a=input().split(" ")
print((100**(int(a[0])))*(int(a[1])))
d, n = map(int, input().split())

if d == 0:
    print(n)
elif d == 1:
    print(n*100)
elif d == 2:
    print(n*10000)
#100b
D,N = map(int, input().split())

if D==0:
    if N!=100:
        print(N)
    else:
        print(101)
elif D==1:
    print(100*N)
elif D==2:
    print(10000*N)
D,N = map(int,input().split())
print(N*pow(100,D))
d,n=map(int,input().split())

if n != 100:
    a=100**d*n
else:
    a=101**d*n

print(a)
d, n = map(int, input().split())
if d == 0:
    print(1*n)
elif d == 1:
    print(100*n)
else:
    print(10000*n)
d, n = map(int, input().split())
l = []
l.append(str(n))
for i in range(d):
    l.append("00")
print("".join(l))
#!/usr/bin/env python3
d, n = map(int, input().split())
if d == 0:
    print(n)
elif d == 1:
    print(100 * n)
else:
    print(100 * 100 * n)
d,n = map(int,input().split())
if n==100:
    ans = 100**d*n+1
else:
    ans = 100**d*n
print(ans)
d,n=map(int,input().split())
num=10**d
if n==100:
    print(num*101)
else:
    print(num*n)
#!/usr/bin/env python3
d, n = map(int, input().split())
print(n * 100**d + (n == 100))
D, N = [int(_) for _ in input().split()]

ans = 1 * 100 ** D * N

if ans >= 1 * 100 ** (D+1):
    ans = 1 * 100 ** D * 99

print(ans)
d,n = map(int,input().split())

num = 100 ** d * n
print(num)
D,N=map(int,input().split())
if N!=100:
    print(100**D*N)
else:
    print(100**D*N+1)
a, b = map(int, input().split())
print((100**a)*b)
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

d,n = nm()

ans = n*100**d
print(ans)
D, N = map(int, input().split())

if D == 0:
  if N != 100:
    print(N)
  else:
    print(101)
elif D == 1:
  if N != 100:
    print(N * 100)
  else:
    print(10001)
else:
  if N != 100:
    print(N*10000)
  else:
    print(1000001)
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from math import floor, ceil, sqrt, factorial, log
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
from itertools import product
import sys
stdin = sys.stdin
mod = 10**9 + 7


def ns(): return stdin.readline().rstrip()


def ni(): return int(ns())


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


D, N = na()
if D == 0:
    print(N)
else:
    print(N * 100**D if N != 100 else 101 * 100**D)
# import math
# from itertools import permutations as permus
# from fractions import gcd
# from collections import deque

# import numpy as np
# import scipy as scp

# 入力の受け取り
d,n = map(int,input().split())
if d ==0:
    if n <=99:
        ans = n
    elif n==100:
        ans = 101
elif d == 1:
    if n <=99:
        ans = n*100
    elif n==100:
        ans = 101*100
else:
    if n <=99:
        ans = n
    elif n==100:
        ans = 101*100**2

print(ans)
d,n=map(int,input().split())
a=[100**d*i for i in range(n+1)]
if d==0 and n==100:
    print(101)
elif d==1 and n==100:
    print(100001)
elif d==2 and n==100:
    print(10000001)
else:
    print(a[-1])
D, N = map(int, input().split())
print((100**D)*N)
D, N = map(int, input().split())

print(100**D*N)
# coding:utf-8
d, n = map(int, input().split())

if d == 0:
    print(n)
else:
    print((100 ** d) * n)
import itertools
import sys
input = sys.stdin.readline

D, N = map(int, input().split())

M = N // 99
ans = 100**D * (100*M + (N-M*99))
print(ans)
D, N = map(int, input().split())

if N == 100:
    print(100**D*N+100)
else:
    print(100**D*N)
D, N = map(int, input().split())
li = [i * 100 ** D for i in range(N + 1)]
print(li[N])
D,N = map(int,input().split())
print(N*100**D if N != 100 else N*100**(D-1))
D, N = map(int, input().split())

A = 100**D
print(A*N)
a, b = list(map(int, input().split()))
print(b * 100 ** a)
D, N = map(int, input().split())
tmp = str(100**D)
print(str(N)+tmp[1:])
D,N=map(int,input().split())

if N!=100:
  if D==0: 
    print(N)
  elif D==1: 
    print(100*N)
  else: 
    print(10000*N)
else:
  if D==0: 
    print(101)
  elif D==1: 
    print(10001)
  else: 
    print(1000001)
d,n = map(int,input().split())
if d == 0:
  print(n)
else:
  print(100**d*n)
d, n = map(int, input().split())
print(100**d*n if d>0 or n<100 else 101)
D,N = map(int,input().split())

if N < 100:
  print((100**D)*N)
else:
  print((100**D)*N+1)
D,N=map(int,input().split())
print(pow(100,D)*N)
d, x = (int(i) for i in input().split())
ans = str(x)
for i in range(d):
    ans += '00'
print(ans)
d,n = map(int,input().split())
if d !=0:
  print((100**d)*n)
else:
  print(n)
def read_ints():
    return[int(i) for i in input().split()]

def main():
    d, n = read_ints()
    print(100 * (100**n) + 1 if n == 100 else (100**d)*n)

if __name__ == '__main__':
    main()
#!/usr/bin/env python3
d, n = map(int, input().split())
print(n * 100**d + (n == 100 and d ==0))
d, n = map(int, input().split())

print(n * 100**d)
D,N = map(int,input().split())
ans = 0

if D == 0:
  print(N)
  
elif D == 1 and N !=100:
  print(N*100)
  
elif D == 1 and N == 100:
  print(10100)
  
elif D == 2 and N != 100:
  print(N*10000)
  
else:
  print(1010000)
a, b = map(int, input().split())
dst = str(b) + str(100 ** a)[1:] if a != 0 else str(b)
if b == 100: dst = str(int(dst) + 100 ** 1) if a != 0 else str(int(dst) + 1)
print(dst)
D,N = map(int,input().split())

ans = (100 ** D) * N

print(ans)
d, n = map(int, input().split())
s = 0
if d == 0:
  print(n)
  exit()
for i in range(100 ** d, 100 ** (d * 2), 100 ** d):
  s += 1
  if s == n:
    print(i)
    exit()
D,N = map(int,input().split())
print(str((100 ** D) * N))
d,n=map(int,input().split())
if d==0:
    print(n)
    exit()
if d==1:
    base=100
elif d==2:
    base=10000
tmp=base

for i in range(n-1):
   tmp+=base
print(tmp)
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    d, n = nm()
    print(pow(100, d) * n)


if __name__ == '__main__':
    main()
d,n,=map(int, input().split())
ans=0
for i in range(d+1):
    ans=100**i*n
print(ans)
d,n=map(int,input().split())
ans=0
m=0
while True:
  ans+=1
  if ans//100==d:
    m+=1
    if n==m:
      break
print(ans)
d, n = map(int, input().split())

if d == 0:
    print(n)
elif d == 1:
    print(n*100)
else:
    print(n*10000)
D, N = map(int, input().split())
if D == 0:
    if N == 100:
        print(101)
    else:
        print(N)
elif D == 1:
    if N == 100:
        print(10100)
    else:
        print(100*N)
else:
    if N == 100:
        print(10010000)
    else:
        print(10000*N)
d, n = map(int,input().split())

if n == 100:
    print('1010000')
else:
    print(100 ** d * n)
d, n = map(int, input().split())
if  n == 100:
    print(100**d * n + 100 ** n)
    exit()
print(100**d * n)
d, n = map(int, input().split())
print((100+(n==100))**d*n)
d, n = map(int, input().split())

ans = 0

if d == 0:
    print(n)
elif d == 1:
    print(100 * n)
elif d == 2:
    print(10000 * n)
X=int(input())
x=0
ans=[]

if X == 1:
  print(X)
  exit()
else:
  # p
  for i in range(2, int(X**0.5)+1):
    n=1
    a=i
    # b
    while n < X : #超えたら中断
      n *= a
      ans.append(n)
    if n // a > x:
      x = (n//a)
      #print(ans)
print(max(i for i in ans if i <= X))
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, groupby
from math import floor, ceil, sqrt, factorial, log
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
from itertools import product
import sys
stdin = sys.stdin
mod = 10**9 + 7


def ns(): return stdin.readline().rstrip()


def ni(): return int(ns())


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


x = ni()
ans = 1
for b in range(2, 100):
    for p in range(2, 10):
        if b**p <= x:
            ans = max(ans, b**p)
print(ans)
# -*- coding: utf-8 -*-
import sys
from bisect import bisect_left,bisect_right
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    X=int(input())
    l=[]
    for i in range(1,33):
        for j in range(2,11):
            l.append(i**j)
    l.sort()
    print(l[bisect_right(l,X)-1])

if __name__ == '__main__':
    main()
def main():
    X = int(input())

    ans = 1
    for i in range(2, 11):
        for j in range(32):
            if j ** i <= X:
                if j ** i > ans:
                    ans = j ** i

    print(ans)


if __name__ == "__main__":
    main()
x=int(input())
print(max([i**j for i in range(33) for j in range(2,10) if i**j<=x]))
import math
x=int(input())
ans=1
for i in range(2,math.ceil(x**(0.5))):
  j=2
  tmp = i**j
  while tmp<=x and x!=1:
    ans = max(ans, tmp)
    j+=1
    tmp = i**j
print(ans)
x=int(input())
ans=0
for i in range(2,10):
    for j in range(1,1001):
        tmp=j**i
        if tmp<=x:
            ans=max(tmp,ans)
print(ans)
import math

x=int(input())
a=int(math.sqrt(x)//1)
ans=1
for i in range(1,a+1):
    for j in range(2,a+1):
        if i**j<=x:
            ans=max(ans,i**j)
print(ans)
x=int(input())
a=1
for b in range(1,x+1):
    for p in range(2,x+1):
        t=b**p
        if t>x:
            break
        a=max(a,t)
print(a)
x = int(input())
bekis = [1]
for i in range(2,35):
    for j in range(2,15):
        v = i**j
        if v > x: break
        bekis.append(v)

bekis.sort()
print(bekis[-1])
X=int(input())
ans=0

for i in range(1,100):
  for j in range(2,20):
    if i**j<=X:
      ans=max(ans,i**j)
      
print(ans)
# ABC097 B  Exponential
x = int(input())
ans = 0
 
for i in range(1,33):
    for j in range(2,10):
        t = i**j
        if t <= x:
            ans = max(t,ans)
print(ans)
x = int(input())
y = 0
if x==1 or x==2 or x==3:
    print(1)
    exit()
else:
    for a in range(2,(x+1)):
        for b in range (2,10):
            if b==2 and a**b>x:
                print(y)
                exit()
            elif a**b<=x:
                y=max(a**b,y)
X = int(input())
if X==1:
    print(1)
else:
    cmax = 1
    for i in range(2,int(X**0.5)+1):
        k = 2
        while i**k<=X:
            cmax = max(cmax,i**k)
            k += 1
    print(cmax)
X = int(input())
if X == 1:
  print(1)
  exit()

def it():
  for i in range(2, X):
    x = i*i
    if x > X: return 0
    
    while x*i <= X:
      x *= i
    yield x
  
print(max(it()))
x = int(input())
max_val = 1
for i in range(1, x):
    for j in range(2, x):   
        val = i ** j
        if val > x:
            break
        elif val > max_val:
            max_val = val
print(max_val)
X = int(input())
list = []

if X == 1:
  list.append(1)

elif X == 2 or X == 3:
  list.append(2)
  
else:
  for b in range(2, X):
    p = 2
    while b ** p <= X:
      list.append(b ** p)
      p += 1
      
print(max(list))
x = int(input())
# n, k = list(map(int, input().split()))
# a = list(map(int, input().split()))
_max = 1
for i in range(1, x+1):
    for j in range(2, x+1):
        if pow(i, j) > _max and pow(i, j) <= x:
            _max = pow(i, j)
        if pow(i, j) > x:
            break

print(_max)
x = int(input())
ans = [1]
for i in range(2, 40):
    for j in range(2, 10):
        if i**j <= x:
            ans.append(i**j)
        else:
            break

ans.sort()
print(ans[-1])
x = int(input())
pr = [1]
for i in range(2,32):
    for j in range(2,10):
        if (i**j <= 1000)&(i**j not in pr):
            pr.append(i**j)
print(max([k for k in pr if k <= x]))
import numpy as np
X = int(input())
ans = 1
for b in range(2, 1+int(np.ceil(np.sqrt(X)))):
    p = 0
    while np.power(b, p) <= X:
        p += 1
    p -= 1
    ans = max(ans, np.power(b, p))
print(ans)
x=int(input())
l=[]
for i in range(1,x+1):
    for k in range(2,11):
        z = i**k
        if z <= x:
            l.append(z)
print(max(l))
from math import sqrt
X=int(input())
ans=0
for i in range(1,int(sqrt(X))+1):
    now=i
    b=2
    while i!=1 and X>=i**b:
        now=i**b
        b+=1
    ans=max(ans, now)
print(ans)
X=int(input())
ans=1
X_max=int(X**0.5)

for i in range(1,X_max+1):
    for j in range(1,X):
        if i**j <= X:
            ans=max(ans,i**j)
print(ans)
X = int(input())
S = set([1])
for i in range(2,X):
  b = 2
  while(i**b<=X):
    S.add(i**b)
    b += 1

ans = max(S)
print(ans)
n = int(input())
import math as m
if n < 4:
  print(1)
  exit(0)
  
perfect = 1
for b in range(2,int(n**0.5)+1):
  p = int(m.log(n,b))
  x = b**(p+1)
  if x > n:
    x = b**p
  perfect = max(perfect,x)
  #print(b,x)
  if perfect == n:
    break

print(perfect)
x = int(input())

tmp = 2
ans = 1

while tmp*tmp <= x:
    cur = tmp*tmp
    while cur*tmp <= x:
        cur *= tmp
    ans = max(ans, cur)
    tmp += 1

print(ans)
x = int(input())

c=1
for b in range(1,x):
    for p in range(2,x):
        if b**p<=x:c=max(c,b**p)
        else:break
print(c)
X=int(input())
ans=1
for i in range(1,X+1):
  for j in range(2,X+1):
    if i**j<=X:
      ans=max(ans,i**j)
    else:
      break
print(ans)
#ABC097
import math
x = int(input())
l = [1]
for i in range(int(math.sqrt(x))+1):
    for j in range(2,100):
        if i ** j > x:
            l.append(i ** (j-1))
            break
            
print(max(l))
import math
x = int(input())
for i in range(x,0,-1):
    if math.sqrt(i)%1 == 0  or (math.ceil(i ** (1/3)))**3 == i or (math.ceil(i ** (1/5)))**5 == i:
        print(i)
        break
x = int(input())
ans = 1

for i in range(1,32):
    for j in range(2,11):
        if i ** j > x:
            pass
        else:
            if ans < i ** j:
                ans = i ** j
#                print(i,j)

print(ans)
x = int(input())
li = [1]
for i in range(100):
    n = 2
    while x >= (i+2)**n:
        li.append((i+2)**n)
        n += 1
print(max(li))
x = int(input())

ans = 0
for i in range(1, 100):
    for j in range(2, 100):
        if i ** j <= x:
            ans = max(ans, i ** j)
print(ans)
import math
X = int(input())

sq = int(math.sqrt(X))
m = 1
for b in range(2, sq+1):  # ここで2が1になると1のp乗となり永遠にループが回り続ける
    p = 2
    tmp = b ** p
    while tmp <= X:
        m = max(tmp, m)
        p += 1
        tmp = b ** p
print(m)
x = int(input())

ans = 0
for i in range(1,32):
    for p in range(2,10):
        y = i**p
        if y > 1000:
            break
        if ans < y <= x:
            ans = y
print(ans)
import math
X = int(input())
res = 1
for i in range(2, int(math.sqrt(X)) + 1):
    j = 2
    while i ** j <= X:
        j += 1
    res = max(res, i ** (j - 1))
print(res)
X=int(input())
a_max=1
for b in range(2,X//2):
  a=1
  p=2
  while a<X:
    a=b**p
    p+=1
    if X >= a > a_max:
      a_max=a
print(a_max)
x=int(input())
l=[]
for i in range(1,1000+1):
    for k in range(2,11):
        z = i**k
        if z <= x:
            l.append(z)
print(max(l))
n=int(input())
ans=1
for b in range(2,100):
    tmp=b
    for p in range(2,10):
        tmp*=b
        if tmp<=n :
            ans=max(ans,tmp)
print(ans)
import math
x=int(input())
y=math.ceil(math.sqrt(x))
ans=1
for i in range(y):
    for j in range(y):
        if ans<=i**j<=x:
            ans=i**j
        else:
            continue
print(ans)
n = int(input())
array = []
array.append(1)
for i in range(2,32):
  cnt = 2
  num = i**cnt
  while num<=1000:
    array.append(num)
    cnt += 1
    num = i**cnt 

array.sort()
ans = 0
l = len(array)
for i in range(l):
  if array[i]<=n:
    ans = array[i]
print(ans)
X = int(input())
ans = 1
for i in range(2,1000):
    for j in range(2,10):
        if i**j <= X:
            ans = max(ans,i**j)
print(ans)
x=int(input())
if x==1:
    print(1)
    exit()

i=2
ans=0
while i*i<x:
    j=2
    while i**j<=x:
        ans=max(ans,i**j)
        j +=1
    i += 1
print(ans)
import sys
import math

input = sys.stdin.readline
MOD = 1000000007

X = int(input())

sa = 100000
res = 0

if X == 1:
    print(1)
else:
    for i in range(2,X):
        a = int(math.log(X,i)+0.00000004)
        if (sa > (X - (i**a))) & ( a != 1):
            sa = X - (i**a)
            res = i**a

    print(res)
X = int(input())

dammy=[]
for b in range(1,101):
    for p in range(2,10):
        dammy.append(b**p)
        dammy.sort()

for i in range(101):
    if dammy[i]>X:
        print(dammy[i-1])
        break
X = int(input())

X_half = X // 2
max_ans = 1
tmp_max = 0

for i in range(1,X_half+10):
    for j in range(2,X_half+10):
        tmp = i ** j
        if tmp<=X:
            tmp_max = tmp
    max_ans = max(max_ans, tmp_max)

print(max_ans)
X = int(input())
ans = 1

for b in range(1,X):
  for p in range(2,10):
    if b**p<=X:
      ans = max(ans,b**p)
      
print(ans)
#!/usr/bin/env python3

X = int(input())

ret = 0
for i in range(1, 1001):
    for j in range(2, 20):
        if i**j <= X:
            ret = max(i**j, ret)

print(ret)
n = int(input())
ans = 0
for i in range(1,1000):
  for j in range(2, 10):
    if i**j <= n:
      ans = max(ans, i**j)
print(ans)
x=int(input())
a=1
for i in range(1,x):
    for y in range(2,x):
        if i**y<=x: a=max(a,i**y)
        else:break
print(a)
x = int(input())
c = 1
for b in range(1, x):
    for p in range(2, x):
        if b**p <= x:
            c = max(c, b**p)
        else:
            break
print(c)
import math
X=int(input())
x=int((X**(1/2))//1)
A=[]
y=int(math.log2(X)//1)
for i in range(x+1):
    for j in range(y+1):
        if i**j<=X:
            A.append(i**j)
print(max(A))
x = int(input())
ans = 1
for i in range(2,x):
    a = 2
    while i**a<=x:
        ans = max(i**a,ans)
        a+=1
print(ans)
a = int(input())

if a==1:
    print(1)
    exit()

res = 1
for i in range(2,32):
    for j in range(2,10):
        x = i**j
        if x > a:
            pass
        else:
            res = max(res,x)
print(res)
X = int(input())
tab = set([1])
for i in range(1,X+1):
    for j in range(2,X+1):
        if i**j <= X:
            tab.add(i**j)
        else:
            break
print(max([i for i in tab]))
x=int(input())
c=1
for b in range(1,x):
    for p in range(2,x):
        if b**p<=x:c=max(c,b**p)
        else:break
print(c)
from bisect import bisect_right

x = int(input())
l = []

for i in range(2, 10):
    j = 1
    while j ** i <= 1000:
        y = j ** i
        if y not in l:
            l.append(y)
        j += 1

l.sort()
print(l[bisect_right(l, x)-1])
x = int(input())
ans  = 1
for b in range(1,32):
    for p in range(2,10):
        c = b**p
        if x >= c > ans:
            ans = c
print(ans)
X = int(input())

num_list = []
for i in range(1, int(1000**0.5)+1):
    for j in range(2, 11):
        if i**j <= 1000:
            num_list.append(i**j)

for num in sorted(num_list, reverse=True):
    if num <= X:
        print(num)
        break
import bisect

x = int(input())

s = {1}
for a in range(2, 1000):
    for b in range(2, 11):
        c = a ** b
        if c > 1000:
            break
        s.add(c)
s = sorted(s, reverse=True)
for a in s:
    if a <= x:
        print(a)
        exit(0)
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

X = int(input())

ans = 1
for i in range(2, X):
    b = i
    p = 2
    a = b ** p
    while a <= X: 
        ans = max(ans, a)
        p += 1
        a = b ** p
print(ans)
#
# Written by NoKnowledgeGG @YlePhan
# ('ω')
#
#import math
#mod = 10**9+7
#import itertools
#import fractions
#import numpy as np
#mod = 10**4 + 7
"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
 
def main():
  x = int(input())
  ans = 1
  for i in range(1,x):
    for j in range(2,x):
      if i**j <= x:
        ans = max(ans, i**j)
      else:
        break
  print(ans)
  
if __name__ == '__main__':
  main()
x=int(input())
ans=0
for i in range(1,34):
    for j in range(2,11):
        t=i**j
        if t<=x:
            ans=max(ans,t)
print(ans)
X = int(input())
M = 1
for i in range(1, X):
    for p in range(2, 10):
        if M < i ** p <= X:
            M = i ** p

print(M)
X = int(input())
cnt = 1
for b in range(1,X):
    for p in range(2,X):
        if b**p <= X:
          cnt = max(cnt, b**p)
        else: break
print(cnt)
x = int(input())

ans = 1
for b in range(1, 32):
    for p in range(2, 10):
        if b**p <= x:
            ans = max(ans, b**p)

print(ans)
x = int(input())
ans = [1]

for i in range(2, 100):
    n = 2
    while i**n <= x:
        ans.append(i**n)
        n += 1

print(max(ans))
X = int(input())
val = 1
for b in range(1, int(X**0.5)+1):
    for p in range(2,X):
        if b**p > X:
            break
        else:
            val = max(val, b**p)
print(val)
x=int(input())
a=[]
for i in range(1,33):
    for j in range(2,11):
        a.append(i**j)
for i in range(x):
    if x-i in a:
        print(x-i)
        exit()
import math
def main():
  x = int(input())
  sum=0
  if x==0 or x==1:
    sum=x
  else:
    for i in range(2,int(math.sqrt(x))+1):
      j=2
      while True:
        if pow(i,j) <= x:
          if pow(i,j) > sum:
            sum=pow(i,j)
        else:
          break
        j+=1
  print(sum)
main()
x = int(input())

lis = []
for n in range(32):
    for e in range(2,11):
        if n**e <= x:
            lis.append(n**e)
se = set(lis)
print(max(se))
x=int(input())
ans=1
for i in range(1,1000+1):
    for j in range(2,11):
        if i**j<=x:
            ans=max(ans,i**j)

print(ans)
import math
X = int(input())

sq = int(math.sqrt(X))

candidates = [1]
for b in range(2, sq+1):
    p = 2
    tmp = b ** p
    while tmp <= X:
        candidates.append(tmp)
        p += 1
        tmp = b ** p

print(sorted(candidates)[-1])
# solution

data=int(input())

array=[]

for i in range(1,34):
  for j in range(2,11):
    if (i**j)<=data:
      array.append(i**j)

print(max(array))
X=int(input())
H=[1]

i=2
while i<=X**0.5:
    j=2
    while i**j<=X:
        H.append(i**j)
        j+=1
    i+=1

print(sorted(H)[-1])
import math
x = int(input())
if x==1:
  print(1)
  exit()

used = {}
for b in range(2,int(math.sqrt(x))+1):
  p=2
  while(b**p<=x):
    used[b**p]=True
    p+=1

ans=0
for key in used.keys():
  ans = max(ans,key)

print(ans)
n = int(input())
l = []
l.append(1)
for i in range(2,40):
  b = i**2
  while b <= 1000:
    l.append(b)
    b*= i
l.sort()

for i in range(len(l)):
  if n < l[i]:
    print(l[i-1])
    exit()
print(1000)
import math

X = int(input())
maxBeki = 1
for b in range(1, X, 1):
    for p in range(2, X, 1):
        if b**p <= X:
            maxBeki = max(maxBeki, b ** p)
        else:
            break
print(maxBeki)