CodeEff/ECCO huggingface dataset:
# Original solution
import sys


input = sys.stdin.readline
n, p = list(map(int, input().split()))
if n == 1:
    ans = p
else:
    ans = 1
    for i in range(2, 10**6+1):
        check = i**n
        if check > p:
            break
        elif p % check == 0:
            ans = i
print(ans)


# Optimized solution
import sys


input = sys.stdin.readline
n, p = list(map(int, input().split()))
if n == 1:
    ans = p
elif n > 10**6:
    ans = 1
else:
    ans = 1
    for i in range(2, 10**6+1):
        check = i**n
        if check > p:
            break
        elif p % check == 0:
            ans = i
print(ans)
# Original solution
(N,P) = list(map(int,input().split()))

if N == 1:
    print(P)
    exit()

primelist=[]
powerlist=[]

p=2
while 1:
    Q = p**N
    if P < Q:
        break
    elif P == Q:
        primelist.append(p)
        powerlist.append(1)
        break
#    elif p**(N+1) > P:
#        p = P**(1/N)
#        if p == int(p):
#            primelist.append(int(p))
#            powerlist.append(1)
#        break

#    f = 0
#    for q in primelist:
#        if p % q == 0:
#            f = 1
#            break
#    if f == 1:
#        p += 1
#        continue
#    else:
    k = 0
    while P % p == 0:
        P //= p
        k += 1
    primelist.append(p)
    powerlist.append(k//N)
    p += 1

ans = 1
for i in range(len(primelist)):
    ans *= (primelist[i]**powerlist[i])

print(ans)

# Optimized solution
import math

(N,P) = list(map(int,input().split()))

if N == 1:
    print(P)
    exit()

ans = 1
p = 2
logP = math.log(P)
while N * math.log(p) <= logP:
    k = 0
    while P % p == 0:
        P //= p
        k += 1
    ans *= p**(k//N)
    if k > 0:
        logP = math.log(P)

    r = p % 6
    if r == 1:
        p += 4
    elif r == 5:
        p += 2
    else:
        p += 1

print(ans)
# Original solution
n, p = [int(i) for i in input().split()]
num = int(p ** (1 / n)) + 1
for i in range(num):
    pp = p
    dv = num - i
    if pp % (dv**n) == 0:
        ans = dv
        break
print(ans)

# Optimized solution
n, p = [int(i) for i in input().split()]
if n >= 10 ** 4:
    print((1))
    exit()

num = int(p ** (1 / n)) + 1
for i in range(num):
    pp = p
    dv = num - i
    if pp % (dv ** n) == 0:
        ans = dv
        break
print(ans)
# Original solution
from statistics import mean, median,variance,stdev
import sys
import math
import fractions
def j(a):
    if a: print("AC")
    else :print("WA")


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

def ip():
    return int(eval(input()))

#x = ip()                              #入力整数1つ
x,y = (int(i) for i in input().split())      #入力整数横2つ
#x,y,z = (int(i) for i in input().split())    #入力整数横3つ
#n,m,x,y= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列

max = 1
ls = int(math.sqrt(y))+1
s = []
if y==1 or x>=y:print((1))
elif x==1:print(y)
else:
    n = y
    for i in range(2,y//2+1):
        if n==1:break
        l=0
        while n%i == 0:
             n = n//i
             l+=1
        s.append([i,l])
    for i in range(len(s)):
        s[i][1]//=x
    num = 1
    for i in range(len(s)):
        if s[i][1]: num*=(pow(s[i][0],s[i][1]))
    print(num)


# Optimized solution
from statistics import mean, median,variance,stdev
import sys
import math
import fractions
def j(a):
    if a: print("AC")
    else :print("WA")


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

def ip():
    return int(eval(input()))

#x = ip()                              #入力整数1つ
x,y = (int(i) for i in input().split())      #入力整数横2つ
#x,y,z = (int(i) for i in input().split())    #入力整数横3つ
#n,m,x,y= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列

max = 1
ls = int(math.sqrt(y))+1
s = []
if y==1 or x>=y:print((1))
elif x==1:print(y)
else:
    n = y
    for i in range(2,ls):
        if n==1:break
        l=0
        while n%i == 0:
             n = n//i
             l+=1
        s.append([i,l])
    for i in range(len(s)):
        s[i][1]//=x
    num = 1
    for i in range(len(s)):
        if s[i][1]: num*=(pow(s[i][0],s[i][1]))
    print(num)
# Original solution
n,p = list(map(int,input().split()))
if n == 1:
  print(p)
  exit()
a = 1
for i in range(1,1000001):
  if p< i**n:
    break
  if p%(i ** n) == 0:
    a = i
print(a)

# Optimized solution
n,p = list(map(int,input().split()))
if n == 1:
  print(p)
  exit()
a = 1
for k in range(2,1000001):
  c = 0
  while p%k == 0:
    p = p//k
    c += 1
  a *= k**(c//n)
  if p == 1:
    break
print(a)
# Original solution
N,P = list(map(int, input().split()))

count = 1
ans = 0

if N > 1000001:
    print((1))
    exit()

while True:

    if count**N > P:
        break

    if P % count**N == 0:
        ans = count

    count += 1
 
print(ans)

# Optimized solution
N,P = list(map(int, input().split()))

count = 1
ans = 0

if N == 1:
    print(P)
    exit()

if N > 1000001:
    print((1))
    exit()

while True:

    if count**N > P:
        break

    if P % count**N == 0:
        ans = count

    count += 1
 
print(ans)
# Original solution
import math
N,P = list(map(int,input().split()))
if N == 1:
    print(P)
    exit()
ans = 1
for i in range(2,math.floor(pow(P,1/2)) + 1):
    if P % i == 0:
        count = 1
        P = P // i
        while P % i == 0:
            count += 1
            P = P // i
        ans *= pow(i,count // N)
print(ans)

# Optimized solution
import math
def factoring(n,dict_count = {}):
    sup = math.floor(pow(n,1/2))
    n_new = n
    for i in range(2,sup + 1):
        if n % i == 0:
            n_new = n // i
            if i in dict_count:
                dict_count[i] += 1
            else:
                dict_count[i] = 1
            break
    if n == n_new:
        if n_new in dict_count:
            dict_count[n_new] += 1
        else:
            dict_count[n_new] = 1
        return sorted(list(dict_count.items()))
    return factoring(n_new,dict_count)
N,P = list(map(int,input().split()))
result = factoring(P)
ans = 1
for e in result:
  ans *= pow(e[0],e[1] // N)
print(ans)
# Original solution
from collections import defaultdict
from copy import deepcopy

N,K=list(map(int,input().split()))
AB=[0]*N
dic=defaultdict(int)
for i in range(N):
    a,b=list(map(int,input().split()))
    if a in list(dic.keys()):
        AB[dic[a]]=[a,AB[dic[a]][1]+b]
    else:
        dic[a]=i
        AB[i]=[a,b]
AB_=[]
for i in AB:
    if i==0:
        continue
    k=bin(i[0])[2:].zfill(30)
    AB_.append([k,i[1]])
AB=AB_
l=len(AB)

k=bin(K)[2:].zfill(30)
ans=0
for i in range(30):
    if k[i]=="1":
        t=k[:i]+"0"
        sum=0
        for j in range(l):
            if int(t)|int(AB[j][0][:i+1])<=int(t):
                sum+=AB[j][1]
        ans=max(ans,sum)
sum=0
t=k
for j in range(l):
    if int(t)|int(AB[j][0])<=int(t):
        sum+=AB[j][1]
ans=max(ans,sum)
print(ans)



# Optimized solution
N,K=list(map(int,input().split()))
AB=[]
for i in range(N):
    a,b=list(map(int,input().split()))
    AB.append([a,b])
ans=sum([b for a,b in AB if K|a==K])

for i in range(int.bit_length(K)-1,0,-1):
    if not K &(1<<i):
        continue
    m=K & ~(1<<i)|(1<<i)-1
    s=sum([b for a,b in AB if m | a ==m])
    ans=max(s,ans)
print(ans)
# Original solution
import sys
readline=sys.stdin.readline
read=sys.stdin.read

def main():
    n,k=list(map(int,readline().split()))
    ab=[list(map(int,l.split())) for l in read().splitlines()]
    
    ek=0
    while k>>ek:
        ek+=1
    ans=0
    for i in range(ek):
        if k>>i&1:
            m=(k>>(i+1))<<(i+1)|((1<<i)-1)
            ans=max(ans,sum(e[1] for e in ab if e[0]|m==m))
    ans=max(ans,sum(e[1] for e in ab if e[0]|k==k))
    print(ans)

if __name__=='__main__':
    main()


# Optimized solution
import sys
readline=sys.stdin.readline
read=sys.stdin.read

def main():
    n,k=list(map(int,readline().split()))
    ab=[list(map(int,l.split())) for l in read().splitlines()]
    
    ek=0
    while k>>ek:
        ek+=1
    ans=0
    for i in range(ek):
        if k>>i&1:
            m=(k>>(i+1))<<(i+1)|((1<<i)-1)
            ans=max(ans,sum((e[1] for e in ab if e[0]|m==m)))
    ans=max(ans,sum((e[1] for e in ab if e[0]|k==k)))
    print(ans)

if __name__=='__main__':
    main()
# Original solution
from collections import Counter

def func(n):
  dic = Counter()
  rest = list({i ** 2 % n for i in range(1, n)})
  lenr = len(rest)
  rest.sort()
  half = n // 2
  
  for i in range(lenr):
    resti = rest[i]
    for j in range(i + 1, lenr):
      dff = rest[j] - resti
      if dff > half:
        dic[n - dff] += 2
      else:
        dic[dff] += 2

  for i in range(1, half + 1):
    print((dic[i]))

def main():
  while True:
    n = int(eval(input()))
    if n == 0:
      break
    func(n)

main()


# Optimized solution
import itertools
def func(n):
  rest = {i ** 2 % n for i in range(1, n)}

  count = [0] * n
  for x, y in itertools.combinations(rest, 2):
    count[x - y] += 2

  for i in range(n // 2):
    print((count[i + 1] + count[n - i - 1]))


def main():
  while True:
    n = int(eval(input()))
    if n == 0:
      break
    func(n)

main()
# Original solution
# 0142 - Nature of Prime Numbers

while True:
	n = int(eval(input()))
	if n == 0: break

	_min = 0
	_max = int((n - 1) / 2)

	ns = set([ x * x % n for x in range(1, n)])
	count  = [0 for i in range(0, int((n - 1) / 2) + 1)]
	for i in ns:
		for j in ns:
			if i < j:
				m = i - j
				if m < _min: m = n + m
				if m > _max: m = n - m
				count[m] += 1
	for i in count:
			if i > 0: print((i * 2))

# Optimized solution
# 0142 - Nature of Prime Numbers

while True:
	n = int(eval(input()))
	if n == 0: break

	_max = int((n - 1) / 2)

	ns = set([ x * x % n for x in range(1, n)])
	count  = [0 for i in range(0, int((n - 1) / 2) + 1)]
	for i in ns:
		for j in ns:
			if i > j:
				m = i - j
				if m > _max: m = n - m
				count[m] += 1
	for i in count:
			if i > 0: print((i * 2))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
cta=[0]*(n)
ctb=[0]*(n)
for i in range(n):
  cta[a[i]-1]+=1
  ctb[b[i]-1]+=1

for i in range(n):
  if cta[i]+ctb[i]>n:
    print('No')
    exit()

sa=[0]
sb=[0]
for i in range(n):
  sa.append(cta[i]+sa[-1])
  sb.append(ctb[i]+sb[-1])
l=[]
for i in range(n):
  l.append(sa[i+1]-sb[i])
ans=[]
for i in range(n):
  ans.append(str(b[(i-max(l))%n]))
print('Yes')
print((' '.join(ans)))

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
cta=[0]*n
ctb=[0]*n
for i in range(n):
  cta[a[i]-1]+=1
  ctb[b[i]-1]+=1

for i in range(n):
  if cta[i]+ctb[i]>n:
    print('No')
    exit()

sa=[0]
sb=[0]
for i in range(n):
  sa.append(cta[i]+sa[-1])
  sb.append(ctb[i]+sb[-1])
l=[]
for i in range(n):
  l.append(sa[i+1]-sb[i])
ans=[]
maxl=max(l)
for i in range(n):
  ans.append(str(b[(i-maxl)%n]))
print('Yes')
print((' '.join(ans)))
# Original solution
def main():
    n = int(eval(input()))
    a = list(map(int, input().split()))
    b = list(map(int, input().split()))

    ai, bi = 0, 0
    al, bl = [], []
    while ai < n and bi < n:
        ax, bx = a[ai], b[bi]
        la, lb = [], []
        if ax == bx:
            cnt = 2

            la.append(ai)
            ai += 1
            while ai < n and a[ai] == ax:
                la.append(ai)
                cnt += 1
                ai += 1

            lb.append(bi)
            bi += 1
            while bi < n and b[bi] == bx:
                lb.append(bi)
                cnt += 1
                bi += 1

            if cnt > n:
                print('No')
                exit()

        elif ax < bx:
            la.append(ai)
            ai += 1
        else:
            lb.append(bi)
            bi += 1

        al.append(la)
        bl.append(lb)

    print('Yes')

    slit = 0
    for i in range(len(al)):
        if len(al[i]) == 0 or len(bl[i]) == 0:
            continue
        if al[i][-1] - bl[i][0] + 1 > slit:
            slit = al[i][-1] - bl[i][0] + 1

    print((' '.join(map(str, b[n-slit:] + b[:n-slit]))))

main()

# Optimized solution
# bを必要なだけ(strideの分)右にずらせばよい
def main():
    n = int(eval(input()))
    a = list(map(int, input().split()))
    b = list(map(int, input().split()))

    ai, bi = 0, 0
    stride = 0
    while ai < n and bi < n:
        ax, bx = a[ai], b[bi]
        if ax == bx:
            cnt = 2

            ai += 1
            while ai < n and a[ai] == ax:
                cnt += 1
                ai += 1

            bi_copy = bi
            bi += 1
            while bi < n and b[bi] == bx:
                cnt += 1
                bi += 1

            if cnt > n:
                print('No')
                exit()

            if stride < ai - bi_copy:
                stride = ai - bi_copy

        elif ax < bx:
            ai += 1
        else:
            bi += 1

    print('Yes')
    print((' '.join(map(str, b[n-stride:] + b[:n-stride]))))

main()
# Original solution
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())

    N = NI()
    A = LI()
    B = LI()
    mb = B[-1]
    for i in range(N):
        if A[i] == B[i]:
            if B[i] < mb:
                p = bisect.bisect_left(B[i+1:],B[i]+1) + i+1
                if p > N-1:
                    print('No')
                    return
            else:
                p = N-1 - i
            t = B[i]
            B[i] = B[p]
            B[p] = t
            if A[i] == B[i]:
                print('No')
                return
    print('Yes')
    print(*B,sep=' ')

if __name__ == '__main__':
    main()


# Optimized solution
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())

    N = NI()
    A = LI()
    B = LI()

    c = collections.Counter()
    for x in A:
        c[x] += 1
    for x in B:
        c[x] += 1
        if c[x] > N:
            print('No')
            return

    s = 0
    for i in range(N):
        if A[i] == B[i]:

            p = bisect.bisect_left(B,B[i]+1,i+1)
            if p > N-1:
                p = s
                s += 1
                while B[i] == B[s]:
                    s+=1

            B[i],B[p] = B[p],B[i]
    print('Yes')
    print(*B,sep=' ')

if __name__ == '__main__':
    main()
# Original solution
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, Ai, Bi):
    Ci = [0] * (N + 1)
    Di = [0] * (N + 1)
    j = 0
    k = 0
    for i in range(1, N + 1):
        while j < N and Ai[j] <= i:
            j += 1
        Ci[i] = j
        while k < N and Bi[k] <= i:
            k += 1
        Di[i] = k
    # print(Ci)
    # print(Di)
    for i in range(1, N + 1):
        if Ci[i] - Ci[i - 1] + Di[i] - Di[i - 1] > N:
            print('No')
            return
    x = 0
    for i in range(1, N + 1):
        x = max(x, Ci[i] - Di[i - 1])
    print('Yes')
    # print(x)
    # print(' '.join([str(a) for a in Ai]))
    print((' '.join([str(Bi[(N - x + i) % N]) for i in range(N)])))


if __name__ == '__main__':
    # S = input()
    N = int(eval(input()))
    # N, M = map(int, input().split())
    Ai = [int(i) for i in input().split()]
    Bi = [int(i) for i in input().split()]
    # ABi = [[int(i) for i in input().split()] for _ in range(N)]
    solve(N, Ai, Bi)

    # # test
    # from random import randint
    # from func import random_str
    # solve()


# Optimized solution
# 解説を参考に作成
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
# 
# 
# @stop_watch
def solve(N, A, B):
    buf = -1
    key = 0
    for i in range(N):
        if buf != A[i]:
            key = 0  # 前回(A[i - 1])と同じ値じゃなければリセット
        if A[i] == B[i]:
            for j in range(key, N):
                if A[i] != A[j] and B[j] != A[i]:
                    B[i], B[j] = B[j], B[i]
                    key = j
                    break
            else:
                print('No')
                return
        buf = A[i]
    print('Yes')
    print((' '.join([str(i) for i in B])))


if __name__ == '__main__':
    # S = input()
    N = int(eval(input()))
    # N, M = map(int, input().split())
    A = [int(i) for i in input().split()]
    B = [int(i) for i in input().split()]
    # ABi = [[int(i) for i in input().split()] for _ in range(N)]
    solve(N, A, B)

    # # test
    # from random import randint
    # from func import random_str
    # solve()
# Original solution
n=int(eval(input()))
m=[0]*101
for i in range(1,n+1):
  for j in range(2,n+1):
    while i%j==0:
      a=i//j
      while (a+1)*j<=i:
        a+=1
      i=a
      m[j]+=1
counter75=0
counter25=0
counter15=0
counter5=0
counter3=0
for i in range(101):
  if m[i]>=74:
    counter75+=1
  if m[i]>=24:
    counter25+=1
  if m[i]>=14:
    counter15+=1
  if m[i]>=4:
    counter5+=1
  if m[i]>=2:
    counter3+=1
a=(counter5*(counter5-1)*(counter3-2))//2
while (a+1)*2<=(counter5*(counter5-1)*(counter3-2)):
  a+=1
print((counter75+counter25*(counter3-1)+counter15*(counter5-1)+a))


# Optimized solution
import sys
primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
num3=0
num5=0
num15=0
num25=0
num75=0
n=int(eval(input()))
for i in primes:
  tmp=0
  j=1
  while n//pow(i,j)>0:
    tmp+=n//pow(i,j)
    j+=1
  if tmp>=2:
    num3+=1
  if tmp>=4:
    num5+=1
  if tmp>=14:
    num15+=1
  if tmp>=24:
    num25+=1
  if tmp>=74:
    num75+=1
print((num75+max(0,(num3-1)*num25)+max(0,((num3-2)*(num5-1)*num5)//2)+max(0,((num5-1)*num15))))
# Original solution
# -*- coding: utf-8 -*-
"""
Created on Thu Jan  3 10:20:42 2019

@author: Yamazaki Kenichi
"""

N = int(eval(input()))

prime = [2]
for j in range(3,100):
    if all(j % i != 0 for i in prime) :
        prime.append(j)

N1 = 1
for i in range(1,N+1):
    N1 *= i 

prime1 = []
a02,a04,a14,a24,a74 =0,0,0,0,0
for j in prime:
    temp = 0
    while N1 % pow(j,temp) ==0:
        temp += 1
    a02 += 1 if temp > 2 else 0
    a04 += 1 if temp > 4 else 0
    a14 += 1 if temp > 14 else 0
    a24 += 1 if temp > 24 else 0
    a74 += 1 if temp > 74 else 0    
    prime1.append(temp)

ans = a74 +a24*(a02-1) +a14*(a04-1) +a04*(a04-1)//2*(a02-2)



print(ans)


# Optimized solution
# -*- coding: utf-8 -*-
"""
Created on Thu Jan  3 10:20:42 2019

@author: Yamazaki Kenichi
"""

N = int(eval(input()))

prime = [2]
for j in range(3,100):
    if all(j % i != 0 for i in prime) :
        prime.append(j)

N1 = 1
for i in range(1,N+1):
    N1 *= i 

prime1 = []
for j in prime:
    temp = 0
    while N1 % pow(j,temp) ==0:
        temp += 1
    prime1.append(temp-1)

def num(m):
    return len(list([x for x in prime1 if x>=m-1]))

ans = num(75)+ num(25)*(num(3)-1)+ num(15)*(num(5)-1)+ num(5)*(num(5)-1)//2*(num(3)-2)

print(ans)
# Original solution
from math import factorial
from itertools import permutations

n=int(eval(input()))

np=factorial(n)

def eratosthenes(n):
 is_p=[1]*n
 p_list=[]

 is_p[0]=0
 is_p[1]=0

 for i in range(2,n):
  if is_p[i]:
   p_list.append(i)
   for j in range(i*i,n,i):
    is_p[j] = 0

 return is_p, p_list

lim=10**2+1
is_p, p_list=eratosthenes(lim)

cnt=0
ans=[]
l=len(p_list)
for i in range(l):
  for j in range(i+1,l):
    for k in range(j+1,l):
      for s,t,u in permutations([p_list[i],p_list[j],p_list[k]],3):
        num1=(s**4)*(t**4)*(u**2)
        num2=(s**14)*(t**4)
        num3=(s**24)*(t**2)
        num4=s**74
        for z in [num1,num2,num3,num4]:
          if np%z==0:
            ans.append(z)

print((len(set(ans))))

# Optimized solution
from math import factorial
from itertools import permutations

def eratosthenes(n):
 is_p=[1]*n
 p_list=[]

 is_p[0]=0
 is_p[1]=0

 for i in range(2,n):
  if is_p[i]:
   p_list.append(i)
   for j in range(i*i,n,i):
    is_p[j] = 0

 return is_p, p_list

n=int(eval(input()))
np=factorial(n)

lim=10**2+1
is_p, p_list=eratosthenes(lim)

ans=[]
for s,t,u in permutations(p_list,3):
  num1=(s**4)*(t**4)*(u**2)
  num2=(s**14)*(t**4)
  num3=(s**24)*(t**2)
  num4=s**74
  for z in [num1,num2,num3,num4]:
    if np%z==0:
      ans.append(z)

print((len(set(ans))))
# Original solution
from math import factorial
from itertools import permutations

n=int(eval(input()))
np=factorial(n)
p_list=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

ans=[]
for s,t,u in permutations(p_list,3):
  num1=(s**4)*(t**4)*(u**2)
  num2=(s**14)*(t**4)
  num3=(s**24)*(t**2)
  num4=s**74
  for z in [num1,num2,num3,num4]:
    if np%z==0:
      ans.append(z)

print((len(set(ans))))

# Optimized solution
from collections import Counter
from itertools import permutations

n=int(eval(input()))

def factorization(n):
    p=2
    fcr=[]
    while p*p<=n:
        while n%p==0:
            fcr.append(p)
            n//=p
        p+=1
    if n>1:
        fcr.append(n)
    return fcr


fcr_l=[]
for i in range(1,n+1):
  fcr=factorization(i)
  fcr_l+=fcr


c=Counter(fcr_l)
fcr_st=set(fcr_l)

ans=[]
for p,q,r in permutations(fcr_st,3):
  if c[p]>=74:
    ans.append(p**74)
  if c[p]>=24 and c[q]>=2:
    ans.append((p**24)*(q**2))
  if c[p]>=14 and c[q]>=4:
    ans.append((p**14)*(q**4))
  if c[p]>=4 and c[q]>=4 and c[r]>=2:
    ans.append((p**4)*(q**4)*(r**2))

print((len(set(ans))))
# Original solution
import sys
from collections import defaultdict

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode('utf-8')


def factorize_dict(n):
    b = 2
    fct = defaultdict(lambda: 0)
    while b ** 2 <= n:
        while n % b == 0:
            n //= b
            fct[b] += 1
        b += 1
    if n > 1:
        fct[n] += 1
    return fct


def main():

    N = in_n()

    if N == 1:
        print((0))
        exit()

    prime = defaultdict(int)
    for i in range(1, N + 1):
        for k, v in list(factorize_dict(i).items()):
            prime[k] += v

    n2, n4, n14, n24, n74 = 0, 0, 0, 0, 0
    for k, v in list(prime.items()):
        if v >= 2:
            n2 += 1
        if v >= 4:
            n4 += 1
        if v >= 14:
            n14 += 1
        if v >= 24:
            n24 += 1
        if v >= 74:
            n74 += 1

    ans = n74
    if n24 >= 1:
        ans += n24 * (n2 - 1)
    if n14 >= 1:
        ans += n14 * (n4 - 1)
    if n4 >= 2:
        ans += n4 * (n4 - 1) // 2 * (n2 - 2)
    print(ans)


if __name__ == '__main__':
    main()


# Optimized solution
import sys
from collections import defaultdict

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode('utf-8')


def factorize_dict(n):
    b = 2
    fct = defaultdict(lambda: 0)
    while b ** 2 <= n:
        while n % b == 0:
            n //= b
            fct[b] += 1
        b += 1
    if n > 1:
        fct[n] += 1
    return fct


def main():

    N = in_n()

    prime = defaultdict(int)
    for i in range(1, N + 1):
        for k, v in list(factorize_dict(i).items()):
            prime[k] += v

    def num(a):
        return len(list([x for x in list(prime.values()) if x >= a]))

    ans = num(74)
    if num(24) >= 1:
        ans += num(24) * (num(2) - 1)
    if num(14) >= 1:
        ans += num(14) * (num(4) - 1)
    if num(4) >= 2:
        ans += num(4) * (num(4) - 1) // 2 * (num(2) - 2)
    print(ans)


if __name__ == '__main__':
    main()