CodeEff/ECCO huggingface dataset:
# Original solution
from collections import defaultdict


def cand_count(v, d):
    return len(tuple([x for x in list(d.values()) if x >= v]))


n = int(eval(input()))
d = defaultdict(int)

for i in range(2, n + 1):
    b = i
    j = 2
    while j * j <= i:
        while b % j == 0:
            b //= j
            d[j] += 1
        j += 1
    if b > 1:
        d[b] += 1
    # print(i, j, d)
# print(d)

ans = 0
ans += cand_count(74, d)
ans += cand_count(24, d) * (cand_count(2, d) - 1)
ans += cand_count(14, d) * (cand_count(4, d) - 1)
ans += cand_count(4, d) * (cand_count(4, d) - 1) // 2 * (cand_count(2, d) - 2)
print(ans)


# Optimized solution
def num(v):
    return len(tuple([x for x in e if x >= v - 1]))


n = int(eval(input()))
e = [0] * (n + 1)

for i in range(2, n + 1):
    b = i
    j = 2
    while j * j <= i:
        while b % j == 0:
            b //= j
            e[j] += 1
        j += 1
    if b > 1:
        e[b] += 1
e = tuple([x for x in e if x > 0])

ans = 0
ans += num(75)
ans += num(25) * (num(3) - 1)
ans += num(15) * (num(5) - 1)
ans += num(5) * (num(5) - 1) // 2 * (num(3) - 2)
print(ans)
# Original solution

from collections import defaultdict

def get_yakusuu(num):
    yakusuu_dic = defaultdict(int)
    seed_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]
    for now_num in range(1, num + 1):
        for num_ele in seed_primes:
            if now_num < num_ele:
                break
            while now_num % num_ele == 0:
                yakusuu_dic[num_ele] += 1
                now_num = now_num // num_ele
    return list(yakusuu_dic.values())

def calc(yakusuu_dic, lim):
    count = 0
    for num in yakusuu_dic:
        if num >= lim:
            count += 1
        else:
            break
    return count

def main():
    num = int(eval(input()))
    yakusuu_dic = get_yakusuu(num)
    yakusuu_dic.sort(reverse=True)

    up_4 = calc(yakusuu_dic, 4)
    up_2 = calc(yakusuu_dic, 2)
    ans1 = max(up_4 * (up_4 - 1) * (up_2 - 2) // 2, 0)

    up_24 = calc(yakusuu_dic, 24)
    ans2 = max(up_24 * (up_2 - 1), 0)

    up_14 = calc(yakusuu_dic, 14)
    ans3 = max(up_14 * (up_4 - 1), 0)

    up_74 = calc(yakusuu_dic, 74)
    ans4 = up_74

    ans = ans1 + ans2 + ans3 + ans4

    print(ans)




if __name__ == '__main__':
    main()

# Optimized solution
def main2():
    dic = {1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:1, 11:1, 12:1, 13:1, 14:2, 15:2, 16:3, 17:3, 18:3, 19:3, 20:8, 21:8, 22:11, 23:11, 24:11, 25:11, 26:14, 27:14, 28:32, 29:32, 30:35, 31:35, 32:35, 33:35, 34:42, 35:42, 36:42, 37:42, 38:49, 39:49, 40:49, 41:49, 42:49, 43:49, 44:75, 45:75, 46:86, 47:86, 48:86, 49:86, 50:86, 51:86, 52:123, 53:123, 54:131, 55:131, 56:131, 57:131, 58:148, 59:148, 60:153, 61:153, 62:170, 63:170, 64:170, 65:170, 66:170, 67:170, 68:227, 69:227, 70:227, 71:227, 72:227, 73:227, 74:250, 75:250, 76:323, 77:323, 78:324, 79:324, 80:324, 81:324, 82:354, 83:354, 84:354, 85:354, 86:384, 87:384, 88:384, 89:384, 90:384, 91:391, 92:491, 93:491, 94:529, 95:529, 96:529, 97:529, 98:529, 99:529, 100:543}
    print((dic[int(eval(input()))]))


if __name__ == '__main__':
    main2()
# Original solution
# -*- coding: utf-8 -*-

"""
解説参考
・まず素因数分解で階乗全部バラす
・そこからいい感じの組み合わせを探して数える
"""

N = int(eval(input()))

# 階乗の素因数分解：ひとつずつ分解したものを合算
e = [0] * (N+1)
# 階乗の各値ループ
for i in range(2, N+1):
    num = i
    # 素因数分解するループ
    for j in range(2, N+1):
        while num % j == 0:
            num //= j
            e[j] += 1

# 約数75(各指数+1をかける)を取りうる素因数の組み合わせを探していく
nums = set()
# 指数が4, 4, 2
for p in range(2, N+1):
    for q in range(2, N+1):
        for r in range(2, N+1):
            if (e[p] >= 4 and e[q] >= 4 and e[r] >= 2
                    and p != q and q != r and r != p):
                nums.add(pow(p, 4) * pow(q, 4) * pow(r, 2))
# 指数が14, 4 or 24, 2
for p in range(2, N+1):
    for q in range(2, N+1):
        if e[p] >= 14 and e[q] >= 4 and p != q:
            nums.add(pow(p, 14) * pow(q, 4))
        if e[p] >= 24 and e[q] >= 2 and p != q:
            nums.add(pow(p, 24) * pow(q, 2))
# 指数が74
for p in range(2, N+1):
    if e[p] >= 74:
        nums.add(pow(p, 74))  

print((len(nums)))


# Optimized solution
# -*- coding: utf-8 -*-

import sys
from collections import Counter

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

def factorize(num: int) -> dict:
    """ 素因数分解 """
    from math import sqrt
    from collections import Counter

    d = Counter()
    # 終点はルート切り捨て+1
    for i in range(2, int(sqrt(num))+1):
        # 素因数分解：小さい方から割れるだけ割って素数をカウント
        while num % i == 0:
            num //= i
            d[i] += 1
        # 1まで分解したら終了
        if num == 1:
            break
    # 最後に残ったnumは素数(ただし1^1は1^0なので数に入れない)
    if num != 1:
        d[num] += 1
    return d

N = INT()

# N!までを全部素数冪でまとめる
primes = Counter()
for i in range(2, N+1):
    primes.update(factorize(i))

# 約数が75になる素数冪の組み合わせを数える
primes = sorted(primes.values())
M = len(primes)
cnt = 0
# 3種類使う
for i, v1 in enumerate(primes):
    for j, v2 in enumerate(primes[i+1:], i+1):
        for k, v3 in enumerate(primes[j+1:], j+1):
            if v1 >= 2 and v2 >= 4 and v3 >= 4:
                cnt += 1
            if v1 >= 4 and v2 >= 2 and v3 >= 4:
                cnt += 1
            if v1 >= 4 and v2 >= 4 and v3 >= 2:
                cnt += 1
# 2種類使う
for i, v1 in enumerate(primes):
    for j, v2 in enumerate(primes[i+1:], i+1):
        if v1 >= 2 and v2 >= 24:
            cnt += 1
        if v1 >= 4 and v2 >= 14:
            cnt += 1
        if v1 >= 24 and v2 >= 2:
            cnt += 1
        if v1 >= 14 and v2 >= 4:
            cnt += 1
# 1種類使う
for i, v1 in enumerate(primes):
    if v1 >= 74:
        cnt += 1
print(cnt)
# Original solution
N = int(eval(input()))
lim = 1
for i in range(N): lim *= (i+1)
Prime = [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 = 0
for i in range(23):
    for j in range(i+1, 24):
        for k in range(j+1, 25):
            a, b, c = Prime[i], Prime[j], Prime[k]
            d, e, f = (a**4)*(b**4)*(c**2), (a**4)*(b**2)*(c**4), (a**2)*(b**4)*(c**4)
            if d <= lim and lim%d == 0: Ans += 1
            if e <= lim and lim%e == 0: Ans += 1
            if f <= lim and lim%f == 0: Ans += 1
for i in range(24):
    for j in range(i+1, 25):
        a, b = Prime[i], Prime[j]
        d, e, f, g = (a**24)*(b**2), (a**2)*(b**24), (a**4)*(b**14), (a**14)*(b**4)
        if d <= lim and lim%d == 0: Ans += 1
        if e <= lim and lim%e == 0: Ans += 1
        if f <= lim and lim%f == 0: Ans += 1
        if g <= lim and lim%g == 0: Ans += 1
for i in range(5):
    if Prime[i] ** 74 <= lim and lim % (Prime[i]**74) == 0: Ans += 1
print(Ans)

# Optimized solution
import sys
from collections import defaultdict

def solve():
    input = sys.stdin.readline
    N = int(eval(input()))
    primes = defaultdict(int)
    ans = 0
    for i in range(1, N + 1):
        k = i
        for j in range(2, i+1):
            if j ** 2 > i: break
            if k % j == 0:
                while k % j == 0:
                    primes[j] += 1
                    k //= j
        if k > 1: primes[k] += 1
    P = []
    for key in primes: P.append(primes[key])
    pn = len(P)

    for i in range(pn):
        if P[i] >= 74: ans += 1
        if P[i] >= 24:
            for j in range(pn):
                if P[j] >= 2 and j != i: ans += 1
        if P[i] >= 14:
            for j in range(pn):
                if P[j] >= 4 and j != i: ans += 1
        if P[i] >= 4:
            for j in range(i+1, pn):
                if P[j] >= 4:
                    for k in range(pn):
                        if P[k] >= 2 and k != i and k != j: ans += 1
    print(ans)
    #print(primes)
    #print(P)

    return 0

if __name__ == "__main__":
    solve()
# Original solution
P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,10):
    for j in range(i*i,100,i):
        P[j] = 0
Q = []
for i in range(100):
    if P[i]==1:
        Q.append(i)
C = {i:0 for i in Q}
N = int(eval(input()))
for i in range(2,N+1):
    x = i
    for p in C:
        while x%p==0:
            x = x//p
            C[p] += 1
#2 4 4
c2 = 0
c4 = 0
for p in C:
    if 2<=C[p]<4:
        c2 += 1
    elif C[p]>=4:
        c4 += 1
cnt = c2*((c4*(c4-1))//2)+c4*(((c4-1)*(c4-2))//2)
#2 24
c2 = 0
c24 = 0
for p in C:
    if 2<=C[p]<24:
        c2 += 1
    elif C[p]>=24:
        c24 += 1
cnt += c2*c24+c24*(c24-1)
#4 14
c4 = 0
c14 = 0
for p in C:
    if 4<=C[p]<14:
        c4 += 1
    elif C[p]>=14:
        c14 += 1
cnt += c4*c14+c14*(c14-1)
#75
c74 = 0
for p in C:
    if C[p]>=74:
        c74 += 1
cnt += c74
print(cnt)

# Optimized solution
P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,11):
    for j in range(i*i,100,i):
        P[j] = 0
Q = []
for i in range(100):
    if P[i]==1:
        Q.append(i)
N = int(eval(input()))
C = {p:0 for p in Q}
for p in Q:
    cnt = 0
    k = 1
    while p**k<=N:
        for i in range(2,N+1):
            if i%(p**k)==0:
                cnt += 1
        k += 1
    C[p]=cnt
c2=0
c4=0
c14=0
c24=0
c74=0
for p in C:
    if C[p]>=2:
        c2 += 1
    if C[p]>=4:
        c4 += 1
    if C[p]>=14:
        c14 += 1
    if C[p]>=24:
        c24 += 1
    if C[p]>=74:
        c74 += 1
ans = ((c4*(c4-1))//2)*(c2-2)
ans += c24*(c2-1)
ans += c14*(c4-1)
ans += c74
print(ans)
# Original solution
P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,11):
    for j in range(i*i,100,i):
        P[j] = 0
Q = []
for i in range(2,100):
    if P[i]==1:
        Q.append(i)
C = {q:0 for q in Q}
N = int(eval(input()))
for i in range(2,N+1):
    x = i
    for q in Q:
        while x%q==0:
            x = x//q
            C[q] += 1
D = {2:0,4:0,14:0,24:0,74:0}
for q in Q:
    if C[q]>=2:
        D[2] += 1
    if C[q]>=4:
        D[4] += 1
    if C[q]>=14:
        D[14] += 1
    if C[q]>=24:
        D[24] += 1
    if C[q]>=74:
        D[74] += 1
cnt = D[74]
cnt += (D[2]-D[24])*D[24]+(D[24]*(D[24]-1))
cnt += (D[4]-D[14])*D[14]+(D[14]*(D[14]-1))
cnt += (D[2]-D[4])*(D[4]*(D[4]-1))//2+(D[4]*(D[4]-1)*(D[4]-2))//2
print(cnt)

# Optimized solution
P = [1 for _ in range(100)]
P[0]=0
P[1]=0
for i in range(2,11):
    for j in range(i**2,100,i):
        P[j] = 0
Q = []
for i in range(100):
    if P[i]==1:
        Q.append(i)
N = int(eval(input()))
C = {p:0 for p in Q}
for i in range(2,N+1):
    for p in Q:
        if i%p==0:
            x = i
            while x%p==0:
                x = x//p
                C[p] += 1
cnt = 0
for p in Q:
    if C[p]>=74:
        cnt += 1
cnt1 = 0
cnt2 = 0
for p in Q:
    if C[p]>=24:
        cnt2 += 1
    elif C[p]>=2:
        cnt1 += 1
cnt += cnt2*(cnt2-1)+cnt2*cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
    if C[p]>=14:
        cnt2 += 1
    elif C[p]>=4:
        cnt1 += 1
cnt += cnt2*(cnt2-1)+cnt2*cnt1
cnt1 = 0
cnt2 = 0
for p in Q:
    if C[p]>=4:
        cnt2 += 1
    elif C[p]>=2:
        cnt1 += 1
cnt += (cnt2*(cnt2-1)*(cnt2-2))//2+((cnt2*(cnt2-1))//2)*cnt1
print(cnt)
# Original solution
from collections import Counter as c
from itertools import permutations as p

def fact(n):
    d=[]
    for i in range(2,int(n**0.5)+2):
        while n%i==0:
            n//=i
            d.append(i)
    if n!=1:d.append(n)
    return c(d)

n=int(eval(input()))
d=c()
for i in range(1,n+1):
    d+=fact(i)

f=lambda n,x:sum(1 for i in p(list(d.values()),n) if all(map(lambda x,y:x>=y,i,x)))
print((f(3,(2,4,4))//2+f(2,(2,24))+f(2,(4,14))+f(1,(74,))))

# Optimized solution
from collections import defaultdict as dd
from itertools import permutations as p

def factorize(n):
    d = dd(int)
    for i in range(2, int(n**0.5)+1):
        while n%i==0:
            d[i] += 1
            n //= i
        if not n:
            break
    if n>1:
        d[n] += 1
    return d

N = int(eval(input()))
d = dd(int)
for i in range(1, N+1):
    e = factorize(i)
    for i,j in list(e.items()):
        d[i] += j

ans = 0
for i, j, k in p(list(d.values()), 3):    
    if i>=2 and j>=4 and k>=4:
        ans += 1
ans //= 2

for i, j in p(list(d.values()), 2):
    if i>=2 and j>=24:
        ans += 1
    if i>=4 and j>=14:
        ans += 1

for i in list(d.values()):
    if i>=74:
        ans += 1

print(ans)
# Original solution
from collections import defaultdict as dd
from itertools import permutations as p

def factorize(n):
    d = dd(int)
    for i in range(2, int(n**0.5)+1):
        while n%i==0:
            d[i] += 1
            n //= i
        if not n:
            break
    if n>1:
        d[n] += 1
    return d

N = int(eval(input()))
d = dd(int)
for i in range(1, N+1):
    e = factorize(i)
    for i,j in list(e.items()):
        d[i] += j

ans = 0
for i, j, k in p(list(d.values()), 3):    
    if i>=2 and j>=4 and k>=4:
        ans += 1
ans //= 2

for i, j in p(list(d.values()), 2):
    if i>=2 and j>=24:
        ans += 1
    if i>=4 and j>=14:
        ans += 1

for i in list(d.values()):
    if i>=74:
        ans += 1

print(ans)

# Optimized solution
from collections import defaultdict as dd
from itertools import permutations as p

def factorize(n):
    d = dd(int)
    for i in range(2, int(n**0.5)+1):
        while n%i==0:
            d[i] += 1
            n //= i
        if not n:
            break
    if n>1:
        d[n] += 1
    return d

N = int(eval(input()))
d = dd(int)
for i in range(1, N+1):
    e = factorize(i)
    for i,j in list(e.items()):
        d[i] += j
vl = list(d.values())

ans = sum(1 for i, j, k in p(vl, 3) if i>=2 and j>=4 and k>=4)//2
ans += sum(1 for i, j in p(vl, 2) if i>=2 and j>=24)
ans += sum(1 for i, j in p(vl, 2) if i>=4 and j>=14)
ans += sum(1 for i in vl if i>=74)
print(ans)
# Original solution
N = int(eval(input()))
prime_number = [2, 3, 5, 7]
prim = [2, 3, 5, 7]

#素数作成
for i in range(2, 101):
	prime_flag = True
	for j in prim:
		if i % j == 0:
			prime_flag = False
			break
			
	if prime_flag:
		prime_number.append(i)
	
prime_factor = [0] * len(prime_number)

for i in range(2, N + 1):
	tmp = i
	for j in range(len(prime_number)):
		while tmp % prime_number[j] == 0:
			prime_factor[j] += 1
			tmp //= prime_number[j]
			
count2 = 0
count4 = 0
count14 = 0
count24 = 0
count74 = 0

for i in prime_factor:
	if i >= 2:
		count2 += 1
	if i >= 4:
		count4 += 1
	if i >= 14:
		count14 += 1
	if i >= 24:
		count24 += 1
	if i >= 74:
		count74 += 1

if count4 >= 2:		
	combination4 = count4 * (count4 - 1) // 2
else:
	combination4 = 0
	
ans = combination4 * (count2 - 2) + count14 * (count4 - 1) + count24 * (count2 - 1) + count74
print(ans)


# Optimized solution
ans = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 8, 8, 11, 11, 11, 11, 14, 14, 32, 32, 35, 35, 35, 35, 42, 42, 42, 42, 49, 49, 49, 49, 49, 49, 75, 75, 86, 86, 86, 86, 86, 86, 123, 123, 131, 131, 131, 131, 148, 148, 153, 153, 170, 170, 170, 170, 170, 170, 227, 227, 227, 227, 227, 227, 250, 250, 323, 323, 324, 324, 324, 324, 354, 354, 354, 354, 384, 384, 384, 384, 384, 391, 491, 491, 529, 529, 529, 529, 529, 529, 543]
print((ans[int(eval(input()))]))
# Original solution
# M = a ** x * b ** y * c ** z
# の約数の個数は(x + 1)*(y + 1)*(z + 1)
# なので約数が75個になるには、以下パターンが考えられる
# 75
# 25 * 3
# 15 * 5
# 5 * 5 * 3
# よって1～Nまで素因数分解して、各素因数の指数部分の値を求めて
# 計算する

import itertools

def main():
    N = int(eval(input()))
    d = [0] * (N+1)

    for i in range(2,N+1):
        cur = i
        for j in range(2, i+1):
            while cur % j == 0:
                d[j] += 1
                cur = cur // j

    ans = 0
    for i in d:
        if i >= 74:
            ans += 1
    for (x, y, z) in itertools.combinations(d,3):
        for a, b, c in [[4, 4, 2],[4, 2, 4],[2, 4, 4]]:
            if x >= a and y >= b and z >= c:
                ans += 1

    for (x, y) in itertools.combinations(d,2):
        for a, b in [[24,2],[14,4],[4,14],[2,24]]:
            if x >= a and y >= b:
                ans += 1

    print(ans)


    

main()

# Optimized solution
from collections import defaultdict

def main():
    # 75 * 1
    # 25 * 3
    # 15 * 5
    # 5 * 5 * 3
    N = int(eval(input()))
    d = defaultdict(int)
    for n in range(1, N+1):
        for i in range(2, int(n ** 0.5) + 1):
            while n % i == 0:
                d[i] += 1
                n = n // i
        if n != 1:
            d[n] += 1

    d2 = 0
    d4 = 0
    d14 = 0
    d24 = 0
    d74 = 0
    for i in list(d.values()):
        if i >= 2:
            d2 += 1
        if i >= 4:
            d4 += 1
        if i >= 14:
            d14 += 1
        if i >= 24:
            d24 += 1
        if i >= 74:
            d74 += 1

    ans = d74
    ans += d24 * (d2 - 1)
    ans += d14 * (d4 - 1)
    ans += (d4 * (d4 - 1) * (d2 - 2)) // 2

    print(ans)


if __name__ == "__main__":
    main()
# Original solution
from collections import defaultdict

def main():
    # 75 * 1
    # 25 * 3
    # 15 * 5
    # 5 * 5 * 3
    N = int(eval(input()))
    d = defaultdict(int)
    for n in range(1, N+1):
        for i in range(2, int(n ** 0.5) + 1):
            while n % i == 0:
                d[i] += 1
                n = n // i
        if n != 1:
            d[n] += 1

    d2 = 0
    d4 = 0
    d14 = 0
    d24 = 0
    d74 = 0
    for i in list(d.values()):
        if i >= 2:
            d2 += 1
        if i >= 4:
            d4 += 1
        if i >= 14:
            d14 += 1
        if i >= 24:
            d24 += 1
        if i >= 74:
            d74 += 1

    ans = d74
    ans += d24 * (d2 - 1)
    ans += d14 * (d4 - 1)
    ans += (d4 * (d4 - 1) * (d2 - 2)) // 2

    print(ans)


if __name__ == "__main__":
    main()

# Optimized solution
from collections import defaultdict

def prime_factor(n):
    ass = []
    for i in range(2,int(n**0.5)+1):
        while n % i==0:
            ass.append(i)
            n = n//i
    if n != 1:
        ass.append(n)
    return ass

def main():
    N = int(eval(input()))
    d = defaultdict(int)
    for i in range(1,N+1):
        for j in prime_factor(i):
            d[j] += 1
    # 1 * 75
    # 3 * 25
    # 5 * 15
    # 3 * 5 * 5
    e = defaultdict(int)
    for i, j in list(d.items()):
        if j >= 2:
            e[2] += 1
        if j >= 4:
            e[4] += 1
        if j >= 14:
            e[14] += 1
        if j >= 24:
            e[24] += 1
        if j >= 74:
            e[74] += 1
    ans = 0
    ans += (e[2] - 1) * e[24]
    ans += (e[4] - 1) * e[14]
    ans += e[74]
    ans += (e[2] - 2) * e[4] * (e[4] - 1) // 2
    print(ans)

if __name__ == "__main__":
    main()
# Original solution
N = 101
prime = [True]*(N+1)
count = [0]*(N+1)
prime[0] = prime[1] = False

for i in range(N+1):
    if prime[i]:
        for j in range(2*i, N+1, i):
            prime[j] = False
a = int(eval(input()))
for i in range(1,a+1):
    cur = i
    for j in range(2,i+1):
        if prime[j]: 
            while cur%j==0:
                count[j]+=1
                cur//=j
            
s=r=0
for i in range(1,a+1):
    if count[i]>=4:
        s+=1
        r+=1
    elif count[i]>=2:r+=1
def num(m): # e の要素のうち m-1 以上のものの個数
    return len(list([x for x in count if x >= m-1]))

#if s>=2and r-2>=1:print(combinations_count(s,2)*(r-2))
#else:print(0)
print((num(75)+num(25)*(num(3)-1)+num(15)*(num(5)-1)+num(5)*(num(5)-1)*(num(3)-2)//2))

# Optimized solution
N = int(eval(input()))
e = [0] * (N+1)
for i in range(2, N+1):
    cur = i
    for j in range(2, i+1):
        while cur % j == 0:
            e[j] += 1
            cur //= j
def num(m): # e の要素のうち m-1 以上のものの個数
    return len(list([x for x in e if x >= m-1]))

print((num(75) + num(25) * (num(3) - 1) + num(15) * (num(5) - 1)+ num(5) * (num(5) - 1) * (num(3) - 2) // 2))
# Original solution
n = int(eval(input()))

def primes(m) :
    ps = [2]
    for i in range(3, m) :
        for p in ps :
            if i%p == 0 :
                break
        else :
            ps.append(i)
    return ps

def fdivisor(m) :
    ps = primes(m)
    df = {p:0 for p in ps}
    for i in range(1, m+1) :
        ii = i
        while ii != 1 :
            for p in ps :
                if ii%p == 0 :
                    df[p] += 1
                    ii //= p
    return df

ans = 0
df = fdivisor(n)
over2 = len([v for v in list(df.values()) if v >= 2])
over4 = len([v for v in list(df.values()) if v >= 4])
over14 = len([v for v in list(df.values()) if v >= 14])
over24 = len([v for v in list(df.values()) if v >= 24])
over74 = len([v for v in list(df.values()) if v >= 74])
ans += over4*(over4-1)//2*(over2-2)
ans += over14*(over4-1)
ans += over24*(over2-1)
ans += over74

print(ans)

# Optimized solution
n = int(eval(input()))

def primes(m) :
    ps = [2]
    for i in range(3, m+1) :
        for p in ps :
            if i%p == 0 :
                break
        else :
            ps.append(i)
    return ps

def fdivisor(m) :
    ps = primes(m)
    df = {p:0 for p in ps}
    for i in range(1, m+1) :
        ii = i
        while ii != 1 :
            for p in ps :
                if ii%p == 0 :
                    df[p] += 1
                    ii //= p
    return df

ans = 0
df = fdivisor(n)
over2 = len([v for v in list(df.values()) if v >= 2])
over4 = len([v for v in list(df.values()) if v >= 4])
over14 = len([v for v in list(df.values()) if v >= 14])
over24 = len([v for v in list(df.values()) if v >= 24])
over74 = len([v for v in list(df.values()) if v >= 74])
ans += over4*(over4-1)//2*(over2-2)
ans += over14*(over4-1)
ans += over24*(over2-1)
ans += over74

print(ans)
# Original solution
from operator import mul
from functools import reduce

nCr = {}
def cmb(n, r):
    if r == 0 or r == n: return 1
    if r == 1: return n
    if (n,r) in nCr: return nCr[(n,r)]
    nCr[(n,r)] = cmb(n-1,r) + cmb(n-1,r-1)
    return nCr[(n,r)]


a = int(eval(input()))

b = [0 for i in range(15)]
j = 0
c = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47]
d = [0 for i in range(101)]
p = 0
pp = 0
g = 0
gg = 0
ggg = 0
co = 0
for i in range(1,101):
  k = i
  while True:
    if k % c[j] == 0 and k >= c[j]:
      b[j] += 1
      k //= c[j]
    else:
      j += 1
      if j == 15:
        j = 0
        break
  for k in range(15):
    if b[k] >= 74:
      g += 1
    if b[k] >= 24:
      gg += 1
    if b[k] >= 14:
      ggg += 1
    if b[k] >= 4:
      p += 1
    if b[k] >= 2:
      pp += 1
  if i >= 10:
    d[i] = cmb(p, 2)*cmb((pp-2), 1) + cmb(g, 1) + cmb(gg, 1)*cmb((pp-1), 1) + cmb(ggg, 1)*cmb((p-1), 1)
  p = 0
  pp = 0
  g = 0
  gg = 0
  ggg = 0
print((d[a]))

# Optimized solution
def cmb(n, r):
    if n - r < r: r = n - r
    if n <= 0: return 0
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p;
            for k in range(p-1,r,p):
                numerator[k - offset] //= pivot
                denominator[k] //= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

a = int(eval(input()))

b = [0 for i in range(15)]
j = 0
c = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47]
d = [0 for i in range(101)]
p = 0
pp = 0
g = 0
gg = 0
ggg = 0
co = 0
for i in range(1,101):
  k = i
  while True:
    if k % c[j] == 0 and k >= c[j]:
      b[j] += 1
      k //= c[j]
    else:
      j += 1
      if j == 15:
        j = 0
        break
  for k in range(15):
    if b[k] >= 74:
      g += 1
    if b[k] >= 24:
      gg += 1
    if b[k] >= 14:
      ggg += 1
    if b[k] >= 4:
      p += 1
    if b[k] >= 2:
      pp += 1
  if i >= 10:
    d[i] = cmb(p, 2)*cmb((pp-2), 1) + cmb(g, 1) + cmb(gg, 1)*cmb((pp-1), 1) + cmb(ggg, 1)*cmb((p-1), 1)
  p = 0
  pp = 0
  g = 0
  gg = 0
  ggg = 0
print((d[a]))