Duff is in love with lovely numbers! A positive integer *x* is called lovely if and only if there is no such positive integer *a* &gt; 1 such that *a*<sup class="upper-index">2</sup> is a divisor of *x*.

Malek has a number store! In his store, he has only divisors of positive integer *n* (and he has all of them). As a birthday present, Malek wants to give her a lovely number from his store. He wants this number to be as big as possible.

Malek always had issues in math, so he asked for your help. Please tell him what is the biggest lovely number in his store.
The first and only line of input contains one integer, *n* (1 ≤ *n* ≤ 10<sup class="upper-index">12</sup>).
import math

# Typedefs
lli = int
uInt = int
ulli = int
vi = list
vii = list
vc = list
udouble = float
vd = list
vs = list
vv = list  # Use nested lists for a 2D vector
pq = list  # Priority Queue
pq_ = list  # Priority Queue with greater comparison
vp = list  # Vector of Pairs

# Macros
ln = "\n"
_flush = None  # In Python, you can just use '\n' for a line break
stop_sync = None
untie_ios = None
pb = list.append
ppb = list.pop
mp = tuple  # Make a pair
sz = len
all = list
bin_sc = lambda a, x: x in a  # Binary search
lbd = lambda a, x: [i for i, v in enumerate(a) if v >= x][0]
ubd = lambda a, x: [i for i, v in enumerate(a) if v > x][0]
eq_seg = None
minE = min
maxE = max
FIXED = lambda x: f"{x:.2f}"
mem = None
filla = lambda a, n, v: a.extend([v] * n)
fillv = lambda a, v: a.extend([v] * len(a))
_fillv = None
glue = None
msg = print
bug = print
printv = lambda v: print(*v)
printvv = None
printm = None
prints = print
uceil = lambda a, b: -(-a // b)
gcd = math.gcd
unq_v = None
mk_upper = str.upper
mk_lower = str.lower
valid = None
dbug = None

# Constants
dx = [+1, -1, +0, +0]
dy = [+0, +0, +1, -1]
ddx = [+0, +0, +1, -1, -1, +1, -1, +1]
ddy = [-1, +1, +0, +0, +1, +1, -1, -1]
yms = ["YES", "Yes", "yes"]
nms = ["NO", "No", "no"]
PI = math.acos(-1.0)
MOD = {"i": 10**9 + 7, "l": 10**9 + 7}
inf = {"i": float('inf'), "l": float('inf')}

# Functions
def isUp(ch):
    return ch.isupper()

def debug(s):
    print("#------------------#")

# C++ bit manipulation functions
ffs = lambda x: (x & -x).bit_length()  # 1-based index of the rightmost set bit
clz = lambda x: (x | (1 << 32)).bit_length() - 32  # Number of leading zeros
ctz = lambda x: (x & -x).bit_length() - 1  # Number of trailing zeros
cto = lambda x: bin(x).count('1')  # Number of set bits
parity = lambda x: bin(x).count('1') % 2  # Parity of set bits

# C++ power of 2 functions
pow2 = lambda x: 1 << x if x <= 31 else 1 << 31  # Returning unsigned
binpow = lambda a, b, m=None: pow(a, b, m)

# C++ Nsum function
def Nsum(n):
    return (n * (n + 1)) // 2

# C++ Round function
def Round(a, b):
    if a < b:
        return 1
    if a % b:
        return 1 + a // b
    return a // b

# Main function
def main():
    t, tcase = 1, 0

    while tcase < t:
        tcase += 1
        n = lli(input())

        for i in range(2, int(math.sqrt(n)) + 1):
            while n % (i * i) == 0:
                n //= i * i
            if i > n:
                break

        print(n)

if __name__ == "__main__":
    main()