AtCoder Beginner Contest 052 - Factors of Factorial

You are given an integer N.
Find the number of the positive divisors of N!, modulo 10^9+7.

-----Constraints-----
 - 1≤N≤10^3

-----Input-----
The input is given from Standard Input in the following format:
N

-----Output-----
Print the number of the positive divisors of N!, modulo 10^9+7.

-----Sample Input-----
3

-----Sample Output-----
4

There are four divisors of 3! =6: 1, 2, 3 and 6. Thus, the output should be 4.

Source: atcoder | Difficulty: EASY


Solutions:
import collections
na = int(input())
n = 1
mod = 10 ** 9 + 7
for i in range(2, na + 1):
	n *= i
n_break = []
i = 2
while i <= n:
	if n % i == 0:
		n_break.append(i)
		n = n // i
	else:
		i += 1
ans = 1
count = collections.Counter(n_break)
for v in count.values():
	ans *= v + 1
print(ans % mod)


n = int(input())
mod = 10 ** 9 + 7
prime = [1 for _ in range(1000)]
for i in range(1, n + 1):
	now = i
	div = 2
	while now > 1:
		if now % div == 0:
			now //= div
			prime[div - 1] += 1
		else:
			div += 1
ans = 1
for i in range(n):
	ans *= prime[i]
	ans %= mod
print(ans)


n = int(input())
is_prime = [True] * 1005
MOD = 10 ** 9 + 7
is_prime[0] = is_prime[1] = False
factors = []
for i in range(2, n + 1):
	if is_prime[i]:
		cnt = 0
		for j in range(i * i, n + 1, i):
			is_prime[j] = False
		i_init = i
		while i <= n:
			cnt += n // i
			i *= i_init
		factors.append(cnt)
ans = 1
for x in factors:
	ans = ans * (x + 1) % MOD
print(ans)


N = int(input())
A = [a for a in range(2, N + 1)]
T = 1
while len(A) > 0:
	X = A[0]
	T *= sum((N // X ** i for i in range(1, 11))) + 1
	A = [a for a in A if a % A[0]]
print(T % (10 ** 9 + 7))


n = int(input())
MOD = 10 ** 9 + 7

def isp(i):
	if i <= 1:
		return 0
	return all((i % j for j in range(2, int(i ** 0.5) + 1)))
ans = 1

def po(x, n):
	c = 0
	while n // x:
		c += n // x
		n //= x
	return c
for i in range(2, n + 1):
	if isp(i):
		p = po(i, n)
		ans *= p + 1
		ans %= MOD
print(ans)


n = int(input())
a = [0] * (n + 1)
ans = 1
for i in range(2, n + 1):
	x = i
	p = 2
	while x > 1:
		while x % p == 0:
			a[p] += 1
			x //= p
		p += 1
for i in a:
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


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

def cont(y):
	n = 0
	while True:
		if n - int(y ** (1 / 2)) + 1 == 0:
			a.append(y)
			break
		for j in range(2, int(y ** (1 / 2)) + 1):
			if y % j == 0:
				y = y // j
				a.append(j)
				n = 0
				break
			else:
				n = n + 1
ans = 1
for k in range(2, x + 1):
	cont(k)
for h in range(2, x + 1):
	ans = ans * (a.count(h) + 1)
print(ans % 1000000007)


import math
N = int(input())
m = math.factorial(N)
arr = 1000 * [1]
for n in range(2, 1001):
	while m % n == 0:
		m //= n
		arr[n] += 1
ans = 1
for n in arr:
	ans *= n
print(ans % (10 ** 9 + 7))


n = int(input())
l = []
ans = 1
for i in range(2, n + 1):
	for j in range(2, i):
		if i % j == 0:
			break
	else:
		l.append(i)
for h in l:
	a = 1
	for i in range(1, n + 1):
		while i % h == 0:
			i /= h
			a += 1
	else:
		ans *= a
print(ans % (10 ** 9 + 7))


d = {}
for i in range(int(input()) + 1):
	for j in d:
		while i > j - 1 and i % j < 1:
			d[j] += 1
			i //= j
	if i > 1:
		d[i] = 2
a = 1
for v in d.values():
	a = a * v % (10 ** 9 + 7)
print(a)


data = int(input())
modu = 10 ** 9 + 7
n = 1
for i in range(2, data + 1):
	n *= i
count = 1
ans = 1
for i in range(2, data + 1):
	if n % i != 0:
		continue
	count = 1
	while n % i == 0:
		n //= i
		count += 1
	ans *= count
print(ans % modu)


N = int(input())
Index = [0] * (N + 1)
ans = 1
Divider = pow(10, 9) + 7
for i in range(N + 1):
	for j in range(i + 1):
		if j > 1:
			while i % j == 0:
				i = int(i / j)
				Index[j] += 1
for i in range(N + 1):
	ans = ans * (Index[i] + 1) % Divider
print(ans)


n = int(input())
mod = 10 ** 9 + 7
d = {}
for i in range(2, n + 1):
	x = i
	for j in range(2, x + 1):
		while x % j == 0:
			x = x // j
			d[j] = d.get(j, 0) + 1
ret = 1
for v in d.values():
	ret *= v + 1
print(ret % mod)


MOD = 10 ** 9 + 7

def prime_factorize(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
n = int(input())
cnt = [0] * 10000
sum = []
for i in range(2, n + 1):
	sum += prime_factorize(i)
for x in sum:
	cnt[x] += 1
ans = 1
for i in range(len(cnt)):
	if cnt[i] > 0:
		ans *= cnt[i] + 1
print(ans % MOD)


n = int(input())
m = 10 ** 9 + 7
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
D = [0] * 1001
for i in range(2, n + 1):
	for p in primes:
		while i % p == 0:
			D[p] += 1
			i //= p
	if i > 1:
		D[i] += 1
score = 1
for d in D:
	score = score * (d + 1) % m
print(score)


n = int(input())
(s, ans, num) = (1, 1, 2)
for i in range(2, n + 1):
	s *= i
l = []
while s != 1:
	if not s % num:
		l.append(num)
		s //= num
	else:
		num += 1
for i in set(l):
	ans *= l.count(i) + 1
	ans %= 10 ** 9 + 7
print(ans % (10 ** 9 + 7))


n = int(input())
MOD = 10 ** 9 + 7
p = [True for i in range(n + 1)]
ret = 1
for i in range(2, n + 1):
	if not p[i]:
		continue
	for j in range(n // i + 1):
		p[i * j] = False
	j = 1
	cnt = 1
	while i ** j <= n:
		cnt += n // i ** j
		j += 1
	ret = ret * cnt % MOD
print(ret)


import math
url = 'https://atcoder.jp//contests/abc052/tasks/arc067_a'

def get_list_eratosthenes(n):
	if n < 2:
		return [0] * (n + 1)
	prime = [1] * (n + 1)
	prime[0] = prime[1] = 0
	for i in range(2, int(n ** 0.5) + 1):
		if not prime[i]:
			continue
		for j in range(i * 2, n + 1, i):
			prime[j] = 0
	return prime

def main():
	N = int(input())
	tmp = N
	primes = get_list_eratosthenes(N)
	ans = 1
	for p in range(2, N + 1):
		if primes[p] == 0:
			continue
		cur = p
		num = 0
		while cur <= N:
			num += N // cur
			cur *= p
		ans *= num + 1
		ans %= 10 ** 9 + 7
	print(ans)

def __starting_point():
	main()
__starting_point()


N = int(input())
M = 1
ans = 1
for i in range(N):
	M *= i + 1
for k in range(2, N + 1):
	u = 1
	while M % k == 0:
		M = M // k
		u += 1
	ans *= u
print(ans % (10 ** 9 + 7))


pf = {}
ans = 1
m = int(input())
for i in range(2, m + 1):
	for j in range(2, int(i ** 0.5) + 1):
		while i % j == 0:
			pf[j] = pf.get(j, 0) + 1
			i //= j
	if i > 1:
		pf[i] = pf.get(i, 0) + 1
for v in pf.values():
	ans *= v + 1
print(ans % (10 ** 9 + 7))


n = int(input())
l = {}
ans = 1
for i in range(2, n + 1):
	for j in range(2, i + 1):
		if i % j == 0:
			cnt = 0
			while i % j == 0:
				i //= j
				cnt += 1
			if j in l:
				v = l[j]
				l[j] = cnt + v
			else:
				l[j] = cnt
for i in l.values():
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


MOD = 10 ** 9 + 7
n = int(input())
S = [0] * (n + 1)
for i in range(1, n + 1):
	n_i = i
	p = 2
	while n_i > 1:
		while n_i % p == 0:
			n_i //= p
			S[p] += 1
		p += 1
ans = 1
for s in S:
	ans *= s + 1
print(ans % MOD)


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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

def nCr(n, r):
	N = 1
	R = 1
	for m in range(n - r, n + 1):
		N *= m
	for m in range(2, r + 1):
		R *= m
	return N // R
n = int(input())
primes = [p for p in primes if p <= n]
numpow = []
for p in primes:
	i = 1
	tmp = 0
	divisor = p
	while divisor <= n:
		tmp += n // divisor
		i += 1
		divisor = p ** i
	numpow.append(tmp)
import math
numpow = [i + 1 for i in numpow]
y = math.prod(numpow)
print(y % (10 ** 9 + 7))


from operator import mul
from functools import reduce

def PrimeDecomp(N, ConcFlag):
	if ConcFlag:
		if N <= 1:
			return ([1], 1)
		else:
			I = 2
			PrimeDec = []
			DivCount = 1
			while I * I <= N:
				Cnt = 0
				while N % I == 0:
					N //= I
					PrimeDec.append(I)
				DivCount *= Cnt + 1
				I += 1
			if N >= 2:
				PrimeDec.append(N)
				DivCount *= 2
			return (PrimeDec, DivCount)
	elif N <= 1:
		return ([1], [1], 1)
	else:
		I = 2
		PrimeDec = []
		PrimeCnt = []
		DivCount = 1
		while I * I <= N:
			Cnt = 0
			while N % I == 0:
				N //= I
				Cnt += 1
			if Cnt >= 1:
				PrimeDec.append(I)
				PrimeCnt.append(Cnt)
				DivCount *= Cnt + 1
			I += 1
		if N >= 2:
			PrimeDec.append(N)
			PrimeCnt.append(1)
			DivCount *= 2
		return (PrimeDec, PrimeCnt, DivCount)

def DivisorFactorial(N, FactDec, FactCnt, MemoFlag):
	if MemoFlag:
		if N <= 1:
			FDivCnt = 1
			return (FactDec, FactCnt, FDivCnt)
		else:
			(PrimeDec, PrimeCnt, _) = PrimeDecomp(N, False)
			for TP in range(0, len(PrimeDec)):
				if PrimeDec[TP] in set(FactDec):
					FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
				else:
					FactDec.append(PrimeDec[TP])
					FactCnt.append(PrimeCnt[TP])
			FDivCnt = reduce(mul, [T + 1 for T in FactCnt])
			return (FactDec, FactCnt, FDivCnt)
	elif N <= 1:
		FDivCnt = 1
		return (FactDec, FactCnt, FDivCnt)
	else:
		for TN in range(2, N + 1):
			(PrimeDec, PrimeCnt, _) = PrimeDecomp(TN, False)
			for TP in range(0, len(PrimeDec)):
				if PrimeDec[TP] in set(FactDec):
					FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
				else:
					FactDec.append(PrimeDec[TP])
					FactCnt.append(PrimeCnt[TP])
		FDivCnt = reduce(mul, [T + 1 for T in FactCnt])
		return (FactDec, FactCnt, FDivCnt)
N = int(input())
(FactDec, FactCnt, FDivCnt) = DivisorFactorial(N, [], [], False)
print(FDivCnt % (10 ** 9 + 7))


from collections import defaultdict
import math
n = math.factorial(int(input()))
i = 2
factors = defaultdict(int)
ans = 1
while i ** 2 <= n:
	while n % i == 0:
		n //= i
		factors[i] += 1
	i += 1
if n > 1:
	factors[n] += 1
for (k, v) in factors.items():
	ans = ans * (v + 1) % (10 ** 9 + 7)
print(ans)


from math import factorial
N = int(input())

def pdwn(n):
	i = 2
	z = {}
	while i * i <= n:
		while n % i == 0:
			n //= i
			z[i] = z.get(i, 0) + 1
		i += 1
	if n > 1:
		z[n] = z.get(n, 0) + 1
	g = 1
	for y in z.keys():
		g *= z[y] + 1
	return g
print(pdwn(factorial(N)) % (10 ** 9 + 7))


n = int(input())

def f(n):
	pf = {}
	for i in range(2, n + 1):
		for j in range(2, i + 1):
			while i % j == 0:
				pf[j] = pf.get(j, 0) + 1
				i //= j
	return pf
ans = 1
for v in f(n).values():
	ans *= v + 1
print(ans % (10 ** 9 + 7))


from math import factorial
N = int(input())
N = factorial(N)
i = 2
num = 1
ans = 1
while N != 1:
	if N % i == 0:
		N //= i
		num += 1
	else:
		i += 1
		ans *= num
		num = 1
print(ans * num % (10 ** 9 + 7))


import sys
import math
n = int(input())
if n == 1:
	print(1)
	return
prime_list = []
search_list = list(range(2, n + 1))
while True:
	if search_list[0] > math.sqrt(n):
		prime_list.extend(search_list)
		break
	else:
		head_num = search_list[0]
		prime_list.append(head_num)
		search_list.pop(0)
		search_list = [num for num in search_list if num % head_num != 0]
ans = 1
for x in prime_list:
	tmp = 0
	nl = 1
	while x ** nl <= n:
		tmp += n // x ** nl
		nl += 1
	ans *= tmp + 1
if ans >= 10 ** 9 + 7:
	ans %= 10 ** 9 + 7
print(ans)


N = int(input())
mod = 10 ** 9 + 7
f = 1
res = 1
for i in range(2, N + 1):
	f *= i
for i in range(2, N + 1):
	c = 0
	while f % i == 0:
		c += 1
		f //= i
	res *= (c + 1) % mod
	res %= mod
print(res % mod)


import sys
from functools import reduce
MOD = 1000000007

def solve(N: int):
	from itertools import chain
	from collections import Counter
	from functools import reduce
	pu = PrimeUtil(N + 1)
	c = Counter(chain.from_iterable((pu.factor_iter(i) for i in range(2, N + 1))))
	return reduce(lambda a, b: a * (b + 1) % MOD, list(c.values()), 1)

class PrimeUtil:

	def __init__(self, size):
		self.size = size
		self._init_table()

	def _init_table(self):
		from itertools import takewhile
		self._is_prime = [True] * self.size
		self._is_prime[0] = False
		self._is_prime[1] = False
		for i in takewhile(lambda x: x * x <= self.size, list(range(self.size))):
			if not self._is_prime[i]:
				continue
			for j in range(i + i, self.size, i):
				self._is_prime[j] = False

	def prime_iter(self):
		return [x for x in range(self.size) if self._is_prime[x]]

	def primes(self):
		return tuple(self.prime_iter())

	def factor_iter(self, n):
		from itertools import takewhile
		m = n
		for p in self.prime_iter():
			while m % p == 0:
				yield p
				m //= p
			if m == 1:
				return

	def factors(self, n):
		return tuple(self.factor_iter(n))

def main():

	def iterate_tokens():
		for line in sys.stdin:
			for word in line.split():
				yield word
	tokens = iterate_tokens()
	N = int(next(tokens))
	print(solve(N))

def test():
	import doctest
	doctest.testmod()

def __starting_point():
	main()
__starting_point()


N = int(input())
mod = 10 ** 9 + 7
ans = 1
num = [0] * N
for i in range(1, N + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			i //= j
			num[j - 1] += 1
for i in range(N):
	if num[i] == 0:
		continue
	else:
		ans = ans * (num[i] + 1) % mod
print(ans)


import collections
n = int(input())
li = []
for k in range(2, n + 1):
	for i in range(2, int(k ** 0.5) + 1):
		while k % i == 0:
			k //= i
			li.append(i)
	if k != 1:
		li.append(k)
c = collections.Counter(li)
ans = 1
for (k, v) in c.items():
	ans *= v + 1
print(ans % (10 ** 9 + 7))


N = int(input())
prime = [0] * (N + 1)
ans = 1
for i in range(2, N + 1):
	d = 1
	while i > 1:
		d += 1
		while i % d == 0:
			i = i // d
			prime[d] += 1
for j in range(N + 1):
	ans = ans * (prime[j] + 1) % (10 ** 9 + 7)
print(ans)


import math
n = int(input())
mod = 10 ** 9 + 7
m = math.factorial(n)
ans = 1
for i in range(2, n + 1):
	tmp = 1
	while m % i == 0:
		m = m // i
		tmp += 1
	ans *= tmp
print(ans % mod)


n = int(input())
t = [0] * n
f = 1
mod = 10 ** 9 + 7
for i in range(2, n + 1):
	fa = 1
	while i > 1:
		fa += 1
		while i % fa == 0:
			i = i // fa
			t[fa - 2] += 1
for j in range(n):
	f = f * (t[j] + 1) % mod
print(f)


N = int(input())
p = 10 ** 9 + 7

def primeryNum(n):
	n_ = int(n ** 0.5)
	ary = list(range(n + 1))
	ary[1] = 0
	for a in ary:
		if a > n_:
			break
		elif a == 0:
			continue
		for i in range(a * 2, n + 1, a):
			ary[i] = 0
	return ary
primeryN = primeryNum(N)
divN = [0] * (N + 1)
for pn in primeryN:
	if pn == 0:
		continue
	i = 1
	cnt = 0
	while pn ** i <= N:
		cnt += N // pn ** i
		i += 1
	divN[pn] = cnt
ans = 1
for d in divN:
	if d == 0:
		continue
	ans = ans * (d + 1) % p
print(ans)


N = int(input())
MOD = 10 ** 9 + 7
M = 10 ** 5 + 1
rec = [0] * M
for i in range(1, N + 1):
	k = i
	for j in range(2, N + 1):
		while k >= 2 and k % j == 0:
			k //= j
			rec[j] += 1
num = 1
for k in list(filter(lambda x: x > 0, rec)):
	num *= k + 1
	num %= MOD
print(num)


MOD = 10 ** 9 + 7

def sieve(n):
	srn = int(n ** 0.5) + 1
	f = [False] * (srn + 1)
	res = []
	for i in range(2, srn + 1):
		if f[i]:
			continue
		res.append(i)
		for j in range(2 * i, srn + 1, i):
			f[j] = True
	return res

def trial_division(n):
	res = dict()
	for i in range(2, n + 1):
		m = i
		for p in pn:
			while m % p == 0:
				res[p] = res.get(p, 0) + 1
				m //= p
			if m == 1:
				break
		if m > 1:
			res[m] = res.get(m, 0) + 1
	return res
N = int(input())
pn = sieve(N)
fn = trial_division(N)
res = 1
for f in fn.values():
	res *= f + 1
	res %= MOD
print(res)


import collections
import itertools
import functools
import math
s = set([])
n = int(input())
m = math.factorial(n)
res = 1
for j in range(2, n + 1):
	tmp = 1
	while m % j == 0:
		m = m // j
		tmp += 1
	res *= tmp
print(res % (10 ** 9 + 7))


n = int(input())
x = [0] * (n + 1)
a = 2
q = 10 ** 9 + 7
if n == 1:
	print(1)
	exit()
for i in range(2, n + 1):
	a = i
	p = 2
	while p * p <= i:
		if a % p == 0:
			x[p] += 1
			a = a // p
		else:
			p += 1
	if a != 1:
		x[a] += 1
ans = 1
for i in range(n + 1):
	ans = ans * (x[i] + 1) % q
print(ans % q)


n = int(input())
num = [0] * (n + 1)
ans = 1
for i in range(2, n + 1):
	j = 2
	while j < n + 1 and i > 1:
		if i % j == 0:
			i = i // j
			num[j] += 1
		else:
			j += 1
for i in num:
	ans = ans * (i + 1) % 1000000007
print(ans)


n = int(input())
prime_lst = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
lst = [0 for _ in range(n)]
for i in range(1, n + 1):
	a = i
	for num in prime_lst:
		while a % num == 0:
			lst[num - 1] += 1
			a //= num
	if a != 1:
		lst[a - 1] += 1
ans = 1
MOD = 10 ** 9 + 7
for num in lst:
	ans *= num + 1
	ans %= MOD
print(ans)


MOD = 10 ** 9 + 7
N = int(input())
data = [i for i in range(2, N + 1)]
table = list()
while data:
	tmp = data[0]
	table.append(tmp)
	data = [i for i in data if i % tmp != 0]
res = dict()
for i in range(2, N + 1):
	for t in table:
		if i % t == 0:
			if t not in res:
				res[t] = 1
			tmp = i
			while tmp % t == 0:
				res[t] += 1
				tmp //= t
ans = 1
for r in res.values():
	ans *= r
	ans %= MOD
print(ans)


N = int(input())
mod = 10 ** 9 + 7

def factorization(n):
	(arr, temp) = ([], n)
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
A = {}
for i in range(1, N + 1):
	arr = factorization(i)
	for (k, v) in arr:
		if k != 1:
			if k not in A:
				A[k] = v
			else:
				A[k] += v
ans = 1
for v in A.values():
	ans *= v + 1
	ans %= mod
print(ans)


N = int(input())
mod = 10 ** 9 + 7

def primes(n):
	is_prime = [True] * (n + 1)
	is_prime[0] = False
	is_prime[1] = False
	for i in range(2, int(n ** 0.5) + 1):
		if not is_prime[i]:
			continue
		for j in range(i * 2, n + 1, i):
			is_prime[j] = False
	return [i for i in range(n + 1) if is_prime[i]]
L = primes(N)
ans = [0] * (N + 1)
for i in range(2, N + 1):
	for j in L:
		if i < j:
			break
		while True:
			if i % j == 0:
				i //= j
				ans[j] += 1
			else:
				break
ans_num = 1
for i in range(2, N + 1):
	if ans[i] >= 1:
		ans_num *= ans[i] + 1 % mod
print(ans_num % mod)


n = int(input())
mod = 10 ** 9 + 7
div = [0 for _ in range(n)]
for i in range(1, n + 1):
	x = i
	for j in range(2, x + 1):
		while x % j == 0:
			x //= j
			div[j - 1] += 1
ans = 1
for i in range(n):
	ans = ans * (div[i] + 1) % mod
print(ans)


def p_factorize(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
MOD = 10 ** 9 + 7
N = int(input())
if N == 1:
	print(1)
else:
	prime = {}
	for i in range(2, N + 1):
		for (p, n) in p_factorize(i):
			try:
				prime[p] += n
			except KeyError:
				prime[p] = n
	ans = 1
	for n in prime.values():
		ans *= n + 1
		ans %= MOD
	print(ans)


N = int(input())
mod = 10 ** 9 + 7
pf = {}
for i in range(2, N + 1):
	for j in range(2, int(i ** 0.5) + 1):
		while i % j == 0:
			pf[j] = pf.get(j, 0) + 1
			i //= j
	if i > 1:
		pf[i] = pf.get(i, 0) + 1
ans = 1
for p in pf.values():
	ans = ans * (p + 1) % mod
print(ans)


N = int(input())
y = [0] * (N + 1)
for i in range(1, N + 1):
	M = i
	while M > 1:
		for j in range(2, M + 1):
			if M % j == 0:
				M = M // j
				y[j] += 1
				break
ans = 1
for i in y:
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


num = int(input())
cnt_list = [0] * (num + 1)
ans = 1
for i in range(2, num + 1):
	x = i
	prime = 2
	while x > 1:
		while x % prime == 0:
			cnt_list[prime] += 1
			x = x // prime
		prime += 1
for i in cnt_list:
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


def make_prime_table(n):
	sieve = list(range(n + 1))
	sieve[0] = -1
	sieve[1] = -1
	for i in range(4, n + 1, 2):
		sieve[i] = 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i] != i:
			continue
		for j in range(i * i, n + 1, i * 2):
			if sieve[j] == j:
				sieve[j] = i
	return sieve

def prime_factorize(n):
	result = []
	while n != 1:
		p = prime_table[n]
		e = 0
		while n % p == 0:
			n //= p
			e += 1
		result.append((p, e))
	return result
N = int(input())
m = 1000000007
prime_table = make_prime_table(N)
t = [0] * (N + 1)
for i in range(2, N + 1):
	for (p, e) in prime_factorize(i):
		t[p] += e
result = 1
for i in range(2, N + 1):
	if t[i] == 0:
		continue
	result = result * (t[i] + 1) % m
print(result)


import math
n = int(input())
d = {}
for i in range(2, n + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			i /= j
			if j in d:
				d[j] += 1
			else:
				d[j] = 2
ans = 1
for i in list(d.values()):
	ans *= i
print(ans % (10 ** 9 + 7))


N = int(input())
mod = 10 ** 9 + 7
import math
FACT = dict()
for x in range(1, N + 1):
	L = int(math.sqrt(x))
	for i in range(2, L + 2):
		while x % i == 0:
			FACT[i] = FACT.get(i, 0) + 1
			x = x // i
	if x != 1:
		FACT[x] = FACT.get(x, 0) + 1
ANS = 1
for j in FACT.values():
	ANS = ANS * (j + 1) % mod
print(ANS)


import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 7)
INF = float('inf')
MOD = 10 ** 9 + 7

def I():
	return int(input())

def F():
	return float(input())

def SS():
	return input()

def LI():
	return [int(x) for x in input().split()]

def LI_():
	return [int(x) - 1 for x in input().split()]

def LF():
	return [float(x) for x in input().split()]

def LSS():
	return input().split()

def sieve(n):
	is_prime = [True for _ in range(n + 1)]
	is_prime[0] = False
	is_prime[1] = False
	for i in range(2, int(n ** 0.5) + 1):
		if is_prime[i]:
			for j in range(i * 2, n + 1, i):
				is_prime[j] = False
	return [i for i in range(n + 1) if is_prime[i]]

def primeFactorization(n, primes):
	ans = []
	temp = n
	for p in primes:
		while temp % p == 0:
			ans.append(p)
			temp //= p
	if temp > 1:
		ans.append(temp)
	return collections.Counter(ans)

def resolve():
	N = I()
	primes = sieve(N)
	cnt = collections.Counter()
	for i in range(2, N + 1):
		pf = primeFactorization(i, primes)
		for (k, v) in list(pf.items()):
			cnt[k] += v
	ans = 1
	for i in list(cnt.values()):
		ans *= i + 1
		ans %= MOD
	print(ans)

def __starting_point():
	resolve()
__starting_point()


def prime_factorize(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
N = int(input())
total = 1
ans = 1
inf = 10 ** 9 + 7
total = [0] * 1000
for i in range(1, N + 1):
	temp = prime_factorize(i)
	for j in range(len(temp)):
		total[temp[j] - 1] += 1
for i in range(1000):
	ans *= total[i] + 1
	ans %= inf
print(ans)


import collections
N = int(input())
num = []
mod = 10 ** 9 + 7
for i in range(2, N + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			i //= j
			num.append(j)
A = collections.Counter(num)
ans = 1
for v in A.values():
	ans *= (v + 1) % mod
print(ans % mod)


import math
n = int(input())
ans = 1
dic = {}
for i in range(2, n + 1):
	tmp = i
	for j in range(2, i + 1):
		while tmp % j == 0:
			tmp //= j
			if j in dic:
				dic[j] += 1
			else:
				dic[j] = 1
for v in dic.values():
	ans = ans * (v + 1) % (10 ** 9 + 7)
print(ans)


a = int(input())
b = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
c = [0 for _ in range(a)]
for i in range(1, a + 1):
	d = i
	for e in b:
		while d % e == 0:
			c[e - 1] += 1
			d //= e
	if d != 1:
		c[d - 1] += 1
f = 1
g = 10 ** 9 + 7
for h in c:
	f *= h + 1
	f %= g
print(f)


n = int(input())
sosuu = [2]
A = 1000
for L in range(3, A, 2):
	for L2 in sosuu:
		if L % L2 == 0:
			break
	else:
		sosuu.append(L)
ans = []
for i in sosuu:
	ch = 1
	x = i
	while x <= n:
		ch += n // x
		x = x * i
	ans.append(ch)
ans1 = 1
mod = 10 ** 9 + 7
for j in ans:
	ans1 = ans1 * j % mod
print(ans1)


import sys
from collections import Counter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	N = int(readline())
	N_MAX = N
	min_factor = list(range(N_MAX + 1))
	min_factor[2::2] = [2] * (N_MAX // 2)
	for i in range(3, int(N_MAX ** 0.5) + 2, 2):
		if min_factor[i] != i:
			continue
		for j in range(i * i, N_MAX + 1, 2 * i):
			if min_factor[j] > i:
				min_factor[j] = i

	def prime_factorize_fast(n):
		a = Counter()
		while n != 1:
			a[min_factor[n]] += 1
			n //= min_factor[n]
		return a
	factors = Counter()
	for n in range(2, N + 1):
		factors += prime_factorize_fast(n)
	ans = 1
	for v in list(factors.values()):
		ans = ans * (v + 1) % MOD
	print(ans)
	return

def __starting_point():
	main()
__starting_point()


N = int(input())
F = [0] * (N + 1)
Q = 10 ** 9 + 7
for i in range(1, N + 1):
	n = i
	for j in range(2, int(N ** (1 / 2)) + 1):
		while n % j == 0:
			F[j] += 1
			n //= j
	if n != 1:
		F[n] += 1
ans = 1
for i in range(N + 1):
	ans *= F[i] + 1
	ans %= Q
print(ans)


n = int(input())
mod = 10 ** 9 + 7
is_prime = [True for _ in range(1100)]
is_prime[0] = is_prime[1] = False
for i in range(2, 1100):
	if not is_prime[i]:
		continue
	for j in range(i * i, 1100, i):
		is_prime[j] = False
ind = []
for p in range(2, 1100):
	if is_prime[p]:
		cnt = 0
		for m in range(2, n + 1):
			while m % p == 0:
				m //= p
				cnt += 1
		if cnt != 0:
			ind.append(cnt)
ans = 1
for i in range(len(ind)):
	ans *= ind[i] + 1
print(ans % mod)


from collections import Counter

def factor(n):
	Ret = []
	for i in range(2, n + 1):
		while n % i == 0:
			n = n // i
			Ret.append(i)
	if len(Ret) == 0:
		return [n]
	else:
		return Ret
n = int(input())
fact = []
for i in range(2, n + 1):
	fact += factor(i)
ans = 1
for (k, v) in Counter(fact).items():
	ans *= v + 1
	ans %= 10 ** 9 + 7
print(ans)


n = int(input())
cnt = [0] * (n + 1)
for i in range(2, n + 1):
	s = i
	while s != 1:
		for j in range(2, n + 1):
			if s % j == 0:
				s //= j
				cnt[j] += 1
				break
c = 1
for i in range(2, n + 1):
	c *= cnt[i] + 1
	c %= 10 ** 9 + 7
print(c)


n = int(input())
a = 1
r = range
for x in [i for i in r(2, n + 1) if all((i % j for j in r(2, i)))]:
	a *= sum((n // x ** i for i in r(1, 11))) + 1
print(a % (10 ** 9 + 7))


import math
import collections
n = int(input())
factorial = 1
divisor = []
ans = 1

def get_prime(num):
	if num <= 1:
		return
	for i in range(2, num + 1):
		while num % i == 0:
			divisor.append(i)
			num //= i
for j in range(2, n + 1):
	get_prime(j)
count = collections.Counter(divisor)
for k in count.most_common():
	temp = list(k)[1]
	ans = ans * (temp + 1)
ans = ans % (10 ** 9 + 7)
print(ans)


N = int(input())
p = 10 ** 9 + 7
primes = []
for i in range(1, N + 1):
	for (j, prime) in enumerate(primes):
		while i % prime[0] == 0:
			primes[j][1] += 1
			i //= prime[0]
		if i < prime[0]:
			break
	if i > 1:
		primes.append([i, 2])
ans = 1
for (k, v) in primes:
	ans *= v
	ans %= p
print(ans)


N = int(input())
l = []
for i in range(2, N + 1):
	for j in l:
		if i % j == 0:
			break
	else:
		l.append(i)
a = 1
for i in l:
	t = 0
	s = 1
	while i ** s <= N:
		t += N // i ** s
		s += 1
	a = a * (t + 1) % (10 ** 9 + 7)
print(a)


from math import factorial
from collections import Counter
n = factorial(int(input()))
res = []
x = n
y = 2
while y * y <= x:
	while x % y == 0:
		res.append(y)
		x //= y
	y += 1
if x > 1:
	res.append(x)
res = Counter(res)
ans = 1
for v in res.values():
	ans = ans * (v + 1) % (10 ** 9 + 7)
print(ans)


import sys
sys.setrecursionlimit(10 ** 9)
n = int(input())

def factorial(n):
	if n == 1:
		return 1
	return n * factorial(n - 1)
num = factorial(n)
ans = 1
for i in range(2, n + 1):
	count = 0
	while num % i == 0:
		count += 1
		num = num // i
	ans *= count + 1
print(ans % (10 ** 9 + 7))


import math
N = int(input())
mod = 1000000007
x = [1 for _ in range(1001)]
Sum = 1
for i in range(1, N + 1):
	z = i
	for j in range(2, int(math.sqrt(N)) + 1):
		while z % j == 0:
			x[j] += 1
			z = int(z / j)
	if z != 1:
		x[z] += 1
for i in x:
	Sum *= i
	Sum %= mod
print(Sum)


from collections import defaultdict
N = int(input())
power = defaultdict(int)
for k in range(2, N + 1):
	_k = k
	for p in range(2, k + 1):
		while _k % p == 0:
			power[p] += 1
			_k //= p
ans = 1
for n in power.values():
	ans *= n + 1
print(ans % (10 ** 9 + 7))


import math
n = int(input())
mod = 10 ** 9 + 7

def is_prime(n):
	if n == 1:
		return False
	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False
	return True
p = []
for i in range(1, n + 1):
	if is_prime(i):
		p.append(i)
ans = 1
for i in p:
	s = 0
	x = i
	while x <= n:
		s += n // x
		x *= i
	ans *= s + 1
	ans %= mod
print(ans)


from collections import Counter
N = int(input())
div = []
for i in range(2, N + 1):
	while i != 1:
		for d in range(2, i + 1):
			while i % d == 0:
				i = i // d
				div.append(d)
C = Counter(div).most_common()
Ans = 1
for (k, v) in C:
	Ans = Ans * (v + 1) % (10 ** 9 + 7)
print(Ans)


import collections
n = int(input())
mod = 10 ** 9 + 7

def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
tmp = collections.defaultdict(int)
for i in range(1, n + 1):
	for (j, k) in factorization(i):
		tmp[j] += k
ans = 1
for (tei, si) in list(tmp.items()):
	if tei == 1:
		continue
	else:
		ans *= si + 1
		ans %= mod
print(ans)


N = int(input())
table = [True for _ in range(N + 1)]
table[0] = False
table[1] = False
for i in range(2, N + 1):
	if table[i] == False:
		continue
	for j in range(2, N // i):
		table[i * j] = False
p = []
for i in range(N + 1):
	if table[i]:
		p.append(i)
n = len(p)
cnt = [0 for _ in range(n)]
for i in range(2, N + 1):
	x = i
	j = 0
	while x > 1:
		while x % p[j] == 0:
			cnt[j] += 1
			x //= p[j]
		j += 1
ans = 1
MOD = 1000000007
for i in range(n):
	ans *= cnt[i] + 1
	ans %= MOD
print(ans)


n = int(input())
ans = 1
r = [1] * (n + 1)
s = n
for i in range(1, n + 1):
	p = i
	while p % 2 == 0:
		p = p // 2
		r[1] += 1
	for j in range(3, i + 1, 2):
		while p % j == 0:
			p = p // j
			r[j - 1] += 1
for k in range(n + 1):
	ans *= r[k]
ans = ans % (10 ** 9 + 7)
print(ans)


N = int(input())
mod = 1000000007
from collections import defaultdict as dd
Y = dd(lambda : 1)
for i in range(2, N + 1):
	M = i
	for j in range(2, i + 1):
		while M % j == 0:
			Y[j] += 1
			M //= j

def product(X):
	res = 1
	for x in X:
		res *= x
		res %= mod
	return res
ans = product(list(Y.values()))
print(ans)


N = int(input())
MOD = 10 ** 9 + 7
d = dict()
for i in range(2, N + 1):
	for j in d.keys():
		while i % j == 0:
			i //= j
			d[j] += 1
	if i != 1:
		d[i] = 1
ans = 1
for i in d.values():
	ans *= i + 1
	ans %= MOD
print(ans)


N = int(input())
F = {}
for n in range(2, N + 1):
	_n = n
	f = 2
	while f * f <= _n:
		if n % f == 0 and f not in F:
			F[f] = 0
		while n % f == 0:
			n //= f
			F[f] += 1
		f += 1
	if n > 1:
		if n not in F:
			F[n] = 0
		F[n] += 1
ans = 1
mod = 10 ** 9 + 7
for (_, k) in F.items():
	ans = ans * (k + 1) % mod
print(ans)


import collections
n = int(input())
t = 1
for i in range(1, n + 1):
	t *= i

def prime_factorize(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
c = collections.Counter(prime_factorize(t))
ans = 1
for (_, v) in c.items():
	ans *= v + 1
print(ans % (10 ** 9 + 7))


N = int(input())
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
mod = int(1000000000.0 + 7)
memo = {}
for n in range(1, N + 1):
	for p in primes:
		while not n % p:
			memo[p] = memo.get(p, 0) + 1
			n = n // p
	if n != 1:
		memo[n] = memo.get(n, 0) + 1
answer = 1
for v in memo.values():
	answer = answer * (v + 1) % mod
print(answer)


import math
MOD = 10 ** 9 + 7
N = int(input())
ans = 1
prime = set()
prime.add(2)
numofdiv = [0] * (N + 2)
for h in range(2, N + 1):
	flag = 1
	for j in prime:
		if h % j == 0:
			flag = 0
			break
	if flag == 1:
		prime.add(h)
for i in range(2, N + 1):
	for p in prime:
		while i % p == 0:
			numofdiv[p] += 1
			i //= p
for q in range(N + 2):
	ans *= numofdiv[q] + 1
	ans %= MOD
print(ans)


n = int(input())
p = [2]
for i in range(3, n + 1, 2):
	for j in range(3, int(i ** 0.5) + 1, 2):
		if i % j == 0:
			break
	else:
		p.append(i)
l = [0] * len(p)
for i in range(1, n + 1):
	while i != 1:
		for (j, k) in enumerate(p):
			if i % k == 0:
				l[j] += 1
				i //= k
ans = 1
for i in l:
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


from collections import Counter

def f(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
n = int(input())
if n == 1:
	print(1)
	return
d = {}
mod = 10 ** 9 + 7
d[2] = 1
for i in range(3, n + 1):
	x = f(i)
	c = Counter(x)
	for j in c.keys():
		if j not in d:
			d[j] = c[j]
		else:
			d[j] += c[j]
		d[j] = d[j] % mod
ans = 1
for i in d.keys():
	ans *= d[i] + 1
print(ans % mod)


N = int(input())
num = 1
factors = []
for i in range(N, 1, -1):
	num *= i
r = 2
while num != 1:
	x = 0
	while num % r == 0:
		num //= r
		x += 1
	if x:
		factors.append(x)
	r += 1
result = 1
for i in factors:
	result *= i + 1
print(result % 1000000007)


n = int(input())
temp = [1, 1] + [0] * (n - 2)
for i in range(3, n + 1):
	for j in range(2, i):
		while i % j == 0:
			i = i // j
			temp[j - 1] += 1
	if i != 1:
		temp[i - 1] += 1
ans = 1
for i in range(n - 1):
	ans = ans * (temp[i + 1] + 1) % (10 ** 9 + 7)
print(ans)


N = int(input())
es = [0] * 1001
ans = 1

def div(n):
	b = 2
	while b <= n:
		while n % b == 0:
			n //= b
			es[b] += 1
		b += 1
for i in range(1, N + 1):
	div(i)
for e in es:
	ans *= e + 1
	ans %= 10 ** 9 + 7
print(ans)


n = int(input())
histogram = [0] * (n + 1)
for i in range(2, n + 1):
	x = i
	p = 2
	while x > 1:
		while x % p == 0:
			histogram[p] += 1
			x //= p
		p += 1
answer = 1
for a in filter(lambda x: x > 0, histogram):
	answer = answer * (a + 1) % (1000000000.0 + 7)
print(int(answer))


n = int(input())
prime = []
for i in range(2, 1001):
	f = True
	for j in range(2, i):
		if i % j == 0:
			f = False
			break
	if f == True:
		prime.append(i)
(c, total) = (1, 1)
for p in prime:
	if p > n:
		continue
	for i in range(1, 100):
		if p ** i <= n:
			c += n // p ** i
		else:
			total *= c
			c = 1
			break
print(total % (10 ** 9 + 7))


import collections
n = int(input())
mod = 10 ** 9 + 7

def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
d = collections.defaultdict(int)
for i in range(2, n + 1):
	for j in factorization(i):
		d[j[0]] += j[1]
ans = 1
for v in d.values():
	ans *= v + 1
print(ans % mod)


import math
import collections
N = int(input())
a = math.factorial(N)
check = []
ans = 1
i = 2
while a != 1:
	if a % i == 0:
		a //= i
		check.append(i)
	else:
		i += 1
check = collections.Counter(check).values()
for i in check:
	ans *= i + 1
	ans %= 10 ** 9 + 7
print(ans)


N = int(input())
R = [0] * (N - 1)
for i in range(1, N + 1):
	for r in range(2, N + 1):
		count = 0
		while i % r == 0:
			i = i / r
			count += 1
		R[r - 2] += count
count = 1
for r in range(N - 1):
	count = count * (R[r] + 1)
print(count % (10 ** 9 + 7))


n = int(input())
p = []
for k in range(2, n + 1):
	flag = True
	for i in p:
		if k % i == 0:
			flag = False
			break
	if flag:
		p += [k]
a = 1
for i in p:
	s = 1
	x = n // i
	while x > 0:
		s += x
		x = x // i
	a = a * s % 1000000007
print(a)


n = int(input())
t = [0] * (n + 1)
for j in range(2, n + 1):
	y = j
	for i in range(2, n + 1):
		while y % i == 0:
			t[i] += 1
			y = y // i
ans = 1
p = 10 ** 9 + 7
for i in t:
	if i != 0:
		ans *= i + 1
		ans %= p
print(ans)


n = int(input())
ans = 1
rec = [True] * (n + 1)
for i in range(2, n + 1):
	if rec[i]:
		x = 1
		for j in range(1, n + 1):
			y = j
			if y % i == 0:
				rec[y] = False
			while y % i == 0:
				x += 1
				y = y // i
		ans = ans * x % 1000000007
print(ans)


from math import factorial
n = int(input())
f = factorial(n)
mod = 10 ** 9 + 7

def primes(n):
	is_prime = [True] * (n + 1)
	is_prime[0] = False
	is_prime[1] = False
	for i in range(2, int(n ** 0.5) + 1):
		if not is_prime[i]:
			continue
		for j in range(i * 2, n + 1, i):
			is_prime[j] = False
	return [i for i in range(n + 1) if is_prime[i]]
ans = 1
for p in primes(n):
	temp = 1
	while f % p == 0:
		temp += 1
		f //= p
	ans = ans * temp % mod
print(ans)


import sys
n = int(input())
lis = [0 for i in range(n)]
for i in range(2, n + 1):
	ib = i
	for j in range(2, ib + 1):
		while ib % j == 0:
			lis[j - 1] += 1
			ib = ib // j
pat = 1
for i in lis:
	pat *= i + 1
print(pat % (10 ** 9 + 7))


mod = 10 ** 9 + 7
import math
n = int(input())
ans = 1
l = [0] * n
for ii in range(2, n + 1):
	i = ii
	for j in range(2, int(math.sqrt(i)) + 1):
		if i % j == 0:
			cnt = 0
			while i % j == 0:
				cnt += 1
				i //= j
			l[j - 1] += cnt
	if i != 1:
		l[i - 1] += 1
for i in l:
	ans *= i + 1
	ans %= mod
print(ans)


import math
import collections
N = int(input())
nums = [i for i in range(2, N + 1)]

def prime_factorization(num):
	sqrt_num = math.sqrt(num)
	prime_numbers = []
	for i in range(2, int(sqrt_num) + 1):
		while num % i == 0:
			num = num / i
			prime_numbers.append(i)
	if num != 1:
		prime_numbers.append(int(num))
	return prime_numbers
nums_counter = {}
for num in nums:
	prime_numbers = prime_factorization(num)
	for prime_num in prime_numbers:
		if prime_num in nums_counter:
			nums_counter[prime_num] += 1
		else:
			nums_counter[prime_num] = 1
ans = 1
for (key, value) in list(nums_counter.items()):
	ans *= value + 1
	ans %= 10 ** 9 + 7
print(ans)


N = int(input())
q = 1
t = [0] * N
for i in range(2, N + 1):
	s = 1
	while i > 1:
		s += 1
		while i % s == 0:
			i = i // s
			t[s - 2] += 1
for j in range(N):
	q = q * (t[j] + 1) % (10 ** 9 + 7)
print(q)


from collections import defaultdict

def prime_factorization(n):
	arr = []
	temp = n
	for i in range(2, int(n ** 0.5) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
N = int(input())
mod = 10 ** 9 + 7
primes = defaultdict(int)
for n in range(1, N + 1):
	for (num, cnt) in prime_factorization(n):
		primes[num] += cnt
ans = 1
for (n, cnt) in primes.items():
	if n == 1:
		continue
	ans *= cnt + 1
	ans %= mod
print(ans)


from collections import defaultdict
N = int(input())
MOD = 10 ** 9 + 7
mp = defaultdict(int)
for i in range(2, N + 1):
	x = i
	for j in range(2, x + 1):
		while x % j == 0:
			x /= j
			mp[j] += 1
ans = 1
for v in mp.values():
	ans = ans % MOD * (v + 1) % MOD % MOD
print(ans)


def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
n = int(input())
count = [0] * (n + 1)
for i in range(1, n + 1):
	if i == 1:
		pass
	else:
		soinsuu_list = factorization(i)
		for (soinsu, jisu) in soinsuu_list:
			count[soinsu] += jisu
ans = 1
mod = 10 ** 9 + 7
for i in count:
	ans *= i + 1
	ans = ans % mod
print(ans)


from collections import Counter

def p_fact(n):
	m = n
	i = 2
	a = []
	while n > 1:
		if i > m ** 0.5:
			a += [n]
			break
		if n % i == 0:
			n //= i
			a += [i]
		else:
			i += 1
	return a
a = []
for i in range(1, int(input()) + 1):
	a += p_fact(i)
ans = 1
mod = 10 ** 9 + 7
for i in list(Counter(a).values()):
	ans *= i + 1
	ans %= mod
print(ans)


n = int(input())
if n == 1:
	print(1)
	exit()
mod = 10 ** 9 + 7
ans = {}
ans[2] = 0
for i in range(2, n + 1):
	for j in ans.keys():
		while i % j == 0:
			ans[j] += 1
			i //= j
	if i != 1:
		ans[i] = 1
k = 1
for i in ans.values():
	k *= i + 1
	k %= mod
print(k)


n = int(input())
m = 10 ** 9 + 7
d = {}
for i in range(2, n + 1):
	tmp = i
	div = 2
	while tmp > 1:
		if tmp % div == 0:
			if div not in d:
				d[div] = 1
			else:
				d[div] += 1
			tmp //= div
		else:
			div += 1
ans = 1
for div in d:
	ans = ans * (d[div] + 1) % m
print(ans)


n = int(input())
m = 10 ** 9 + 7
p = [1 for i in range(10000)]
p[0] = 0
p[1] = 0
for i in range(2, n + 1):
	if p[i] == 1:
		for j in range(i * i, n + 1, i):
			p[j] = 0
ans = 1
for i in range(2, n + 1):
	if p[i]:
		c = 0
		k = i
		while n // k > 0:
			c = c + n // k % m
			k = k * i
		ans = ans * ((c + 1) % m) % m
print(ans % m)


def factorize(n):
	fct = []
	(b, e) = (2, 0)
	while b * b <= n:
		while n % b == 0:
			n = n // b
			e = e + 1
		if e > 0:
			fct.append([b, e])
		(b, e) = (b + 1, 0)
	if n > 1:
		fct.append([n, 1])
	return fct
n = int(input())
num = 1
for i in range(1, n + 1):
	num *= i
fact = factorize(num)
ans = 1
for i in range(len(fact)):
	ans *= fact[i][1] + 1
print(ans % (10 ** 9 + 7))


N = int(input())
insu_list = [[2, 0]]
ans = 1
for i in range(N):
	n = i + 1
	for j in range(len(insu_list)):
		while n % insu_list[j][0] == 0:
			n /= insu_list[j][0]
			insu_list[j][1] += 1
	if n != 1:
		insu_list.append([n, 1])
for i in range(len(insu_list)):
	ans *= insu_list[i][1] + 1
print(ans % (10 ** 9 + 7))


from collections import defaultdict
import math
n = math.factorial(int(input()))
i = 2
f = defaultdict(int)
a = 1
while i ** 2 <= n:
	while n % i == 0:
		n //= i
		f[i] += 1
	i += 1
if n > 1:
	f[n] += 1
for (n, m) in f.items():
	a = a * (m + 1) % (10 ** 9 + 7)
print(a)


n = int(input())
x = [0 for i in range(2, 1001)]

def soinsu(a):
	for i in range(2, a + 1):
		t = 0
		while a % i == 0:
			a /= i
			t += 1
		x[i - 2] += t
for i in range(2, n + 1):
	soinsu(i)
a = 1
for i in x:
	a *= i + 1
	a %= 10 ** 9 + 7
print(a)


n = int(input())
v = [2]
for i in range(3, n + 1):
	sosu = True
	for j in v:
		if i % j == 0:
			sosu = False
	if sosu:
		v.append(i)
ans = 1
for j in v:
	count = 0
	for i in range(1, n + 1):
		while i % j == 0:
			count += 1
			i = i // j
	ans = ans * (count + 1) % (10 ** 9 + 7)
print(ans)


n = int(input())
div_map = dict()
mod = 10 ** 9 + 7
for i in range(1, n + 1):
	is_prime_number = True
	for j in range(2, int(i ** (1 / 2)) + 1):
		if i % j == 0:
			is_prime_number = False
			break
	if is_prime_number:
		if i not in div_map:
			div_map[i] = 1
		else:
			div_map[i] += 1
	else:
		j = 2
		while i != 1:
			if i % j == 0:
				if j not in div_map:
					div_map[j] = 1
				else:
					div_map[j] += 1
				i //= j
			else:
				j += 1
res = 1
div_map[1] = 0
for (key, value) in list(div_map.items()):
	res = res * (value + 1) % mod
print(res % mod)


N = int(input())
ps = [0] * (N + 1)
for i in range(2, N + 1):
	x = i
	p = 2
	while x > 1:
		while x % p == 0:
			ps[p] += 1
			x //= p
		p += 1
ans = 1
for c in ps:
	ans = ans * (c + 1) % 1000000007
print(ans)


N = int(input())
P = [0] * N
D = 1
if N >= 2:
	for i in range(2, N + 1):
		for j in range(2, i + 1):
			while i % j == 0:
				P[j - 1] = P[j - 1] + 1
				i = i / j
for i in range(N):
	D = D * (P[i] + 1)
print(D % 1000000007)


from collections import defaultdict
d = defaultdict(int)

def prime_factorize(n):
	while n % 2 == 0:
		d[2] += 1
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			d[f] += 1
			n //= f
		else:
			f += 2
	if n != 1:
		d[n] += 1
	return
N = int(input())
MOD = int(1000000000.0) + 7
ans = 1
for i in range(1, N + 1):
	prime_factorize(i)
for v in d.values():
	ans = ans * (v + 1) % MOD
print(ans)


n = int(input())
if n == 1:
	print(1)
	exit()
l = [0] * (n + 1)
for i in range(2, n + 1):
	x = i
	j = 2
	while j < n + 1:
		if x % j == 0:
			x //= j
			l[j] += 1
		else:
			j += 1
ans = 1
for i in range(len(l)):
	ans *= l[i] + 1
	ans %= 10 ** 9 + 7
print(ans)


N = int(input())
MOD = 10 ** 9 + 7
x = 1
for i in range(2, N + 1):
	x *= i
count = 1
ans = 1
for i in range(2, N + 1):
	if x % i != 0:
		continue
	count = 1
	while x % i == 0:
		x //= i
		count += 1
	ans *= count
print(ans % MOD)


import math
n = int(input())
if n == 1:
	print(1)
	return
dp = [0] * (n + 1)
mod = 10 ** 9 + 7

def sieve_of_erastosthenes(num):
	input_list = [False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(num)]
	input_list[0] = input_list[1] = False
	input_list[2] = input_list[3] = input_list[5] = True
	sqrt = math.sqrt(num)
	for serial in range(3, num, 2):
		if serial >= sqrt:
			return input_list
		for s in range(serial ** 2, num, serial):
			input_list[s] = False
prime = sieve_of_erastosthenes(1000)
prime = [i for (i, t) in enumerate(prime) if t]
for i in range(2, n + 1):
	v = i
	while v < n + 1:
		dp[i] += 1
		v += i
dp2 = [0] * (n + 1)
for p in prime:
	v = p
	k = 1
	while v < n + 1:
		dp2[p] += dp[v]
		v *= p
		k += 1
ans = 1
for i in range(n + 1):
	ans = ans * (dp2[i] + 1) % mod
print(ans)


n = int(input())

def prime_factorize(n):
	n_origin = n + 0
	primelist = []
	a = 2
	while a * a <= n_origin:
		if n % a != 0:
			a += 1
			continue
		ex = 0
		while n % a == 0:
			ex += 1
			n = n // a
		primelist.append([a, ex])
		a += 1
	if n != 1:
		primelist.append([n, 1])
	return primelist
ex = {}
mod = 10 ** 9 + 7
for i in range(2, n + 1):
	res = prime_factorize(i)
	for (p, e) in res:
		ex[p] = ex.get(p, 0) + e
ans = 1
for (k, v) in ex.items():
	ans = ans * (v + 1) % mod
print(ans)


n = int(input())
p = 10 ** 9 + 7
cnt = [0 for i in range(n + 1)]

def cnt_factor(n):
	i = 2
	k = n
	while i <= n:
		if k % i == 0:
			k = k // i
			cnt[i] += 1
		else:
			i += 1
for i in range(2, n + 1):
	cnt_factor(i)
ans = 1
for i in range(2, n + 1):
	ans *= (cnt[i] + 1) % p
print(ans % p)


import math
n = int(input())
l = [2]
for i in range(3, n + 1):
	for p in l:
		if i % p == 0:
			break
	else:
		l.append(i)
a = 1
for p in l:
	s = 0
	for i in range(1, int(math.log(n, p)) + 1):
		s += n // p ** i
	a = a * (s + 1) % (10 ** 9 + 7)
print(a)


def factrial(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n //= 2
	for i in range(3, int(n ** 0.5) + 1):
		while n % i == 0:
			factors.append(i)
			n //= i
	if n != 1:
		factors.append(n)
	return factors
n = int(input())
mod = 10 ** 9 + 7
d = {}
for i in range(1, n + 1):
	fac = factrial(i)
	for j in fac:
		if j in d:
			d[j] += 1
		else:
			d[j] = 1
ans = 1
for (k, v) in d.items():
	ans *= v + 1
	ans %= mod
print(ans)


n = int(input())
(x, answer) = ([2], 1)
if n != 1:
	for i in range(2, n + 1):
		if all((i % j != 0 for j in x)):
			x.append(i)
	for i in x:
		(num, num2) = (1, 0)
		while i ** num <= n:
			a = i ** num
			num2 += (n - n % a) // a
			num += 1
		answer = answer * (num2 + 1) % (10 ** 9 + 7)
print(answer)


N = int(input())
mod = 10 ** 9 + 7
memo = {}
for i in range(2, N + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			i = i // j
			try:
				memo[j] += 1
			except:
				memo[j] = 1
ans = 1
for key in memo.keys():
	ans *= memo[key] + 1
print(ans % mod)


import collections
import numpy
n = int(input())
x = []

def factorization(n):
	d = []
	while n % 2 == 0:
		d.append(2)
		n /= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			d.append(int(f))
			n /= f
		else:
			f += 2
	if n != 1:
		d.append(n)
	return d
for i in range(n, 1, -1):
	x += factorization(i)
c = collections.Counter(x)
l = list(c.values())
ans = 1
for i in range(len(l)):
	ans *= 1 + l[i]
print(ans % (7 + 10 ** 9))


from collections import Counter
from functools import reduce
n = int(input())
l = []
for j in range(2, n + 1):
	b = j
	for i in range(2, j + 1):
		while not b % i:
			l.extend([i])
			b //= i
o = Counter(l)
p = int(1000000000.0 + 7)
if n != 1:
	v = reduce(lambda x, y: x * y, map(lambda x: x + 1, o.values())) % p
else:
	v = 1
print(v)


import collections

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	divisors.sort()
	return divisors

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

def main():
	dd = collections.defaultdict(int)
	n = int(input())
	MOD = 10 ** 9 + 7
	for i in range(1, n + 1):
		k = factorization(i)
		for j in k:
			dd[j[0]] += j[1]
	res = 1
	for j in list(dd.keys()):
		if j != 1:
			res *= (dd[j] + 1) % MOD
			res %= MOD
	print(res)

def __starting_point():
	main()
__starting_point()


import math

def factor(x):
	for i in range(2, x + 1):
		count = 0
		while x % i == 0:
			x = x / i
			count = count + 1
		else:
			L[i - 1] = L[i - 1] + count
N = int(input())
L = [0] * N
for i in range(1, N):
	factor(i + 1)
M = 1
for i in range(N):
	M = M * (L[i] + 1)
print(M % (10 ** 9 + 7))


MOD = 10 ** 9 + 7
N = int(input())
C = [0] * (N + 1)
for i in range(2, N + 1):
	k = i
	for j in range(2, i + 1):
		while k % j == 0:
			k //= j
			C[j] += 1
		if k == 1:
			break
ans = 1
for c in C:
	ans *= c + 1
	ans %= MOD
print(ans)


mod = 10 ** 9 + 7
N = int(input())
M = 1
y = [1 for k in range(N)]
for k in range(2, N + 1):
	for j in range(2, k + 1):
		if k == 1:
			break
		if k % j == 0:
			count = 0
			while k % j == 0:
				k = k // j
				count += 1
			y[j - 1] += count
ans = 1
for k in range(len(y)):
	ans = ans * y[k] % mod
print(ans)


import math
N = int(input())
plist = [2]
for i in range(3, N + 1):
	for prime in plist:
		if i % prime == 0:
			break
	else:
		plist.append(i)
ans = 1
for prime in plist:
	s = 0
	for i in range(1, int(math.log(N, prime)) + 1):
		s += N // prime ** i
	ans = ans * (s + 1) % (10 ** 9 + 7)
print(ans)


n = int(input())
s = [2]
q = 1
for i in range(n + 1):
	if i < 3:
		continue
	t = []
	for j in range(len(s)):
		t.append(i % s[j])
	if 0 in t:
		q = 3
	else:
		s.append(i)
x = 1
for i in range(len(s)):
	m = 0
	for j in range(10):
		m += n // s[i] ** (j + 1)
	x *= m + 1
print(x % (10 ** 9 + 7))


n = int(input())
dp = list((0 for _ in range(n + 1)))
for i in range(2, n + 1):
	while i % 2 == 0:
		dp[2] += 1
		i //= 2
	f = 3
	while f * f <= i:
		if i % f == 0:
			dp[f] += 1
			i //= f
		else:
			f += 2
	if i != 1:
		dp[i] += 1
s = 1
for i in dp:
	if i != 0:
		s *= i + 1
print(s % (10 ** 9 + 7))


MOD = 10 ** 9 + 7
N = int(input())
e = [0 for _ in range(N + 1)]
for x in range(2, N + 1):
	for p in range(2, x + 1):
		while x % p == 0:
			x //= p
			e[p] += 1
a = tuple(filter(lambda v: v > 0, e))
t = 1
for aa in a:
	t *= aa + 1
	t %= MOD
print(t)


N = int(input())
mod = 10 ** 9 + 7
prime = [2]
for i in range(3, N + 1):
	if all((i % p for p in prime)):
		prime.append(i)
ans = 1
for p in prime:
	tmp = N
	cnt = 0
	while tmp != 0:
		cnt += tmp // p
		tmp //= p
	ans = ans * (cnt + 1) % mod
print(ans)


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
mod = 10 ** 9 + 7
n = int(input())
l = []
for i in range(1, n + 1):
	l += factorization(i)
ans = 1
for i in set(l):
	ans *= l.count(i) + 1
print(ans % mod)


N = int(input())
mod = 1000000007
from collections import Counter
Y = Counter()
for i in range(2, N + 1):
	M = i
	for j in range(2, i + 1):
		while M % j == 0:
			Y[j] += 1
			M //= j

def product(X):
	res = 1
	for x in X:
		res *= x + 1
		res %= mod
	return res
ans = product(Y.values())
print(ans)


from collections import Counter
n = int(input())
prime = []

def P(x):
	i = 2
	while x != 1:
		if x % i == 0:
			prime.append(i)
			x //= i
		else:
			i += 1
for j in range(1, n + 1):
	P(j)
D = Counter(prime)
ans = 1
for v in D.values():
	ans = ans * (v + 1) % (10 ** 9 + 7)
print(ans)


n = int(input())
klist = []
MOD = 10 ** 9 + 7
ans = 1
kaijo = list(range(n + 1))
for i in range(2, n + 1):
	kaisu = 0
	for j in range(1, n + 1):
		while kaijo[j] % i == 0:
			kaijo[j] = kaijo[j] // i
			kaisu += 1
	if kaisu != 0:
		klist.append(kaisu % MOD)
for i in range(len(klist)):
	ans *= (klist[i] + 1) % MOD
ans = ans % MOD
print(ans)


n = int(input())
d = {}
for x in range(2, n + 1):
	while x % 2 < 1:
		x //= 2
		d[2] = d.get(2, 0) + 1
	for i in range(3, int(x ** 0.5) + 1, 2):
		while x % i < 1:
			x //= i
			d[i] = d.get(i, 0) + 1
		if x < 2:
			break
	if x > 1:
		d[x] = d.get(x, 0) + 1
a = 1
for v in d.values():
	a = a * (v + 1) % (10 ** 9 + 7)
print(a)


n = int(input())
ji = {}
ans = 1
for i in range(n):
	tmp = i + 1
	j = 2
	while tmp != 1:
		if tmp % j == 0:
			if not j in ji:
				ji[j] = 0
			ji[j] += 1
			tmp /= j
		else:
			j += 1
for i in list(ji.values()):
	ans *= i + 1
print(ans % 1000000007)


from collections import deque
p = 10 ** 9 + 7

def primelist(n):
	l = deque([2])
	stack = deque()
	t = 1
	for x in range(3, n + 1, 2):
		flag = 0
		for y in tuple(l):
			if x % y == 0:
				flag = 1
				break
		if flag == 0:
			l.append(x)
	return l

def main():
	n = int(input())
	l = primelist(n)
	ans = 1
	while l:
		q = l.pop()
		s = 0
		c = 1
		while n // q ** c:
			s += n // q ** c
			c += 1
		ans = ans * (s + 1) % p
	print(ans)
main()


N = int(input())
prime = []
l = [False] * (N + 1)
for i in range(2, N + 1):
	if l[i]:
		continue
	prime.append(i)
	j = 1
	while i * j <= N:
		l[i * j] = True
		j += 1
ans = 1
for i in prime:
	r = 1
	j = 1
	while i ** j <= N:
		k = 1
		while i ** j * k <= N:
			r += 1
			k += 1
		j += 1
	ans = ans * r % (10 ** 9 + 7)
print(ans)


from math import factorial as fact
ans = 1
n = int(input())
m = fact(n)
for i in range(2, n + 1):
	tmp = 1
	while m % i == 0:
		m //= i
		tmp += 1
	ans *= tmp
print(ans % (10 ** 9 + 7))


n = int(input())
a = [1] * n
ans = 1
for i in range(1, n + 1):
	b = 2
	while i != 1:
		if i % b == 0:
			i //= b
			a[b - 1] += 1
		else:
			b += 1
for i in a:
	if 1 < i:
		ans *= i
		ans %= 10 ** 9 + 7
print(ans)


import math
insu = [[0] * 1001 for i in range(1001)]
for i in range(1, 1001):
	n = i
	for j in range(2, 1001):
		while n % j == 0:
			n = n // j
			insu[i][j] += 1
n = int(input())
new = [1] * 1001
for i in range(1, n + 1):
	for j in range(1001):
		new[j] += insu[i][j]
ans = 1
for n in new:
	ans *= n
print(ans % (10 ** 9 + 7))


n = int(input())
if n < 2:
	print(1)
else:
	l = [2]
	L = [1]
	for i in range(3, n + 1):
		c = 0
		for j in range(len(l)):
			if i % l[j] == 0:
				c += 1
				while i % l[j] == 0:
					i = int(i / l[j])
					L[j] += 1
		if c == 0:
			l.append(i)
			L.append(1)
	ans = 1
	for k in range(len(L)):
		ans *= L[k] + 1
		ans = ans % (10 ** 9 + 7)
	print(ans)


n = int(input())
ans = 1
mod = 1000000007
a = [0 for i in range(n + 1)]
for i in range(2, n + 1):
	b = i
	for j in range(2, i + 1):
		while b % j == 0:
			a[j] += 1
			b //= j
for i in range(2, n + 1):
	if a[i] > 0:
		ans *= a[i] + 1
		ans %= mod
print(ans)


import math
N = int(input())
ans = 1
q = [1 for i in range(N + 1)]
for i in range(2, N + 1):
	k = i
	for i2 in range(2, i + 1):
		while k % i2 == 0:
			k /= i2
			q[i2] += 1
for i in range(N + 1):
	ans *= q[i]
	ans %= 10 ** 9 + 7
print(ans)


import math
n = int(input())
d = math.factorial(n)
k = 1
ans = 1
for i in range(2, n + 1):
	while d % i == 0:
		d //= i
		k += 1
	ans *= k
	k = 1
print(ans % (10 ** 9 + 7))


N = int(input())
count = [1] * (N + 1)
ans = 1
mod = 10 ** 9 + 7
for i in range(2, N + 1):
	wari = i
	for w in range(2, i + 1):
		while wari % w == 0:
			count[w] += 1
			wari /= w
for i in range(N + 1):
	ans *= count[i]
print(ans % mod)


n = int(input())
mod = 10 ** 9 + 7
ans = 1
L = [0] * (n + 1)
for i in range(2, n + 1):
	f = i
	for j in range(2, i + 1):
		while f != 1 and f % j == 0:
			f //= j
			L[j] += 1
for i in range(2, len(L)):
	if L[i] > 0:
		ans = ans * (L[i] + 1) % mod
print(ans)


n = int(input())
mod = 10 ** 9 + 7
n_prime = [[2, 0]]
x = 1
ans = 1
for i in range(2, n + 1):
	for j in range(x):
		while i % n_prime[j][0] == 0:
			n_prime[j][1] += 1
			i /= n_prime[j][0]
	if i != 1:
		n_prime.append([i, 1])
		x += 1
for k in range(x):
	ans = ans * (n_prime[k][1] + 1) % mod
print(ans)


from math import factorial as f
n = int(input())
m = f(n)
ans = 1
p = [1] * 1000
for i in range(2, 1001):
	while m % i == 0:
		m //= i
		p[i] += 1
for i in p:
	ans *= i
	ans %= 10 ** 9 + 7
print(ans)


n = int(input())
mod = 10 ** 9 + 7
ans = 1
from math import factorial
f = factorial(n)
p = [2]
for i in range(2, 1001):
	flag = 0
	for j in p:
		if i % j == 0:
			flag = 1
			break
	if flag == 1:
		continue
	p.append(i)
for i in p:
	k = 0
	while f % i ** k == 0:
		k += 1
	ans = ans * k
print(ans % mod)


pr = [True] * 1001
n = int(input())
ans = 1
MOD = 10 ** 9 + 7
for i in range(2, n + 1):
	if pr[i]:
		for j in range(i * 2, n + 1, i):
			pr[j] = False
		cnt = 0
		now = n
		while now:
			cnt += now // i
			now //= i
		ans = ans * (cnt + 1) % MOD
print(ans)


import sys
input = lambda : sys.stdin.readline()
import collections
N = int(input())
d = collections.Counter()
if N == 1:
	print(1)
else:
	for n in range(2, N + 1):
		while n % 2 == 0:
			d[2] += 1
			n //= 2
		i = 3
		while i * i <= n:
			if n % i == 0:
				while n % i == 0:
					d[i] += 1
					n //= i
			i += 2
		if n > 1:
			d[n] += 1
	ans = 1
	for (k, v) in d.items():
		ans = ans * (v + 1) % 1000000007
	print(ans)


def soin(n):
	ans = []
	l = int(n ** 0.5) + 1
	for i in range(2, l + 1):
		if n % i == 0:
			a = [i, 0]
			while n % i == 0:
				n //= i
				a[1] += 1
			ans += [a]
	if n > 1:
		ans += [[n, 1]]
	return ans
d = {}
n = int(input())
for i in range(2, n + 1):
	a = soin(i)
	for j in a:
		if j[0] in d:
			d[j[0]] += j[1]
		else:
			d[j[0]] = j[1]
k = 1
for i in d.values():
	k *= i + 1
print(k % (10 ** 9 + 7))


import sys
N = int(input())

def prime_factorize(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
res = []
result = 1
for I in range(2, N + 1):
	res += prime_factorize(I)
for J in set(res):
	result *= res.count(J) + 1
print(result % (10 ** 9 + 7))


n = int(input())
counter = [0] * (n + 1)
for i in range(2, n + 1):
	num = i
	j = 2
	while j * j <= num:
		cnt = 0
		while num % j == 0:
			counter[j] += 1
			num //= j
		j += 1
	if num != 1:
		counter[num] += 1
ans = 1
for i in range(n + 1):
	if counter[i] > 0:
		ans *= counter[i] + 1
		ans %= int(1000000000.0 + 7)
print(ans)


prime = [False] * 1001
for i in range(2, 1001):
	if prime[i] == False:
		for j in range(i * i, 1001, i):
			prime[j] = True
n = int(input())
cnt = [0] * 1001
for i in range(2, n + 1):
	for j in range(2, n + 1):
		if prime[j] == False:
			val = i
			while val % j == 0:
				cnt[j] += 1
				val /= j
ans = 1
for x in cnt:
	ans *= x + 1
	ans %= 1000000007
print(ans)


n = int(input())
l = [0] * n
for i in range(1, n + 1):
	b = 2
	while b <= i:
		while i % b == 0:
			i //= b
			l[b - 1] += 1
		b += 1
x = 1
for i in l:
	if i != 0:
		x = x * (i + 1) % (10 ** 9 + 7)
print(x)


N = int(input())
p = 10 ** 9 + 7
T = [0] * 1001
for m in range(2, N + 1):
	pf = {}
	for i in range(2, int(m ** 0.5) + 1):
		while m % i == 0:
			pf[i] = pf.get(i, 0) + 1
			m //= i
	if m > 1:
		pf[m] = 1
	for key in pf.keys():
		T[key] += pf[key]
out = 1
for i in range(1001):
	out = out * (T[i] + 1) % p
print(out)


from math import factorial
n = int(input())
fcr = []
for i in range(1, n + 1):
	p = 2
	while p * p <= i:
		while i % p == 0:
			fcr.append(p)
			i //= p
		p += 1
	if i > 1:
		fcr.append(i)
ans = 1
s_fcr = set(fcr)
for i in s_fcr:
	ans *= fcr.count(i) + 1
print(ans % (10 ** 9 + 7))


N = int(input())
A = [0 for x in range(1001)]

def devPrime(a):
	cnt = 2
	res = a
	while res > 1:
		while res % cnt == 0:
			res /= cnt
			A[cnt] += 1
		cnt += 1
for i in range(2, N + 1):
	devPrime(i)
ans = 1
for i in range(len(A)):
	ans *= A[i] + 1
	ans %= 1000000007
print(ans)


N = int(input())
num = 1
factors = []
for i in range(N, 1, -1):
	num *= i
r = 2
while num != 1:
	x = 0
	while num % r == 0:
		num //= r
		x += 1
	if x:
		factors.append(x)
	r += 1
result = 1
for i in factors:
	result *= i + 1
print(result % (10 ** 9 + 7))


import math
n = int(input())
mod = 10 ** 9 + 7
ans = 1
k = 1
i = 2
N = math.factorial(n)
while N != 1:
	if N % i == 0:
		N = N // i
		k += 1
	else:
		ans *= k
		k = 1
		i += 1
ans *= k
print(ans % mod)


def main():
	n = int(input())
	a = [0] * (n + 1)
	ans = 1
	for i in range(1, n + 1):
		num = i
		for j in range(2, i + 1):
			if num % j == 0:
				while num > 1 and num % j == 0:
					num //= j
					a[j] += 1
	for i in a:
		ans = ans * (i + 1) % (10 ** 9 + 7)
	print(ans)
	return
main()


import sys
input = sys.stdin.readline
n = int(input())
INF = 10 ** 9 + 7
Num = [0] * (n + 1)
for x in range(2, n + 1):
	i = 2
	while i * 2 <= x:
		while x % i == 0:
			x = x // i
			Num[i] += 1
		i = i + 1
	if not x == 1:
		Num[x] += 1
ans = 1
for i in Num:
	ans = ans * (i + 1) % INF
print(ans)


mod = 1000000000 + 7

def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
n = int(input())
dat = [0] * 2000
res = 1
for i in range(1, n + 1):
	d = factorization(i)
	for j in range(len(d)):
		dat[d[j][0]] += d[j][1]
for i in range(2, n + 1):
	res *= dat[i] + 1
	res %= mod
print(res)


n = int(input())
m = 10 ** 9 + 7
p = []
for k in range(2, n + 1):
	f = 1
	for i in p:
		if k % i == 0:
			f = 0
			break
	if f == 1:
		p += [k]
l = [1] * len(p)
for i in range(len(p)):
	d = p[i]
	x = n // d
	while x > 0:
		l[i] += x
		x //= d
a = 1
for i in l:
	a *= i
	a %= m
print(a)


n = int(input())
sum = 1
dict = {}
for i in range(2, n + 1):
	j = 2
	while i > 1:
		if i % j == 0:
			i = i // j
			if j in dict:
				dict[j] += 1
			else:
				dict[j] = 1
			j -= 1
		j += 1
for i in dict.values():
	sum *= i + 1
print(sum % 1000000007)


n = int(input())
array = []
for i in range(2, n + 1):
	s = i
	while s != 1:
		turn = 0
		for j in range(2, s + 1):
			if s % j == 0:
				s = s // j
				array.append(j)
				break
ans = 1
import collections
c = collections.Counter(array)
l = list(c.values())
for i in range(len(l)):
	ans *= l[i] + 1
print(ans % (10 ** 9 + 7))


n = int(input())
arr = [0] * (n + 1)
for i in range(1, n + 1):
	x = []
	while i % 2 == 0:
		x.append(2)
		i = i // 2
	f = 3
	while f * f <= i:
		if i % f == 0:
			x.append(f)
			i = i // f
		else:
			f += 2
	if i != 1:
		x.append(i)
	for k in range(len(x)):
		arr[x[k]] += 1
ans = 1
for i in range(len(arr)):
	ans *= arr[i] + 1
print(ans % (10 ** 9 + 7))


import math
MOD = 1000000007
N = int(input())
f = [0] * 1000

def factors(n):
	for i in range(2, n + 1):
		if n == 1:
			return
		if n % i == 0:
			while n % i == 0:
				f[i] += 1
				n //= i
for i in range(2, N + 1):
	factors(i)
ans = 1
for i in range(1000):
	if f[i] > 0:
		ans *= f[i] + 1
		ans %= MOD
print(ans)


n = int(input())
data = [0] * (n + 1)
for i in range(2, n + 1):
	while i % 2 == 0:
		i //= 2
		data[2] += 1
	j = 3
	while i > 1:
		if i % j == 0:
			i //= j
			data[j] += 1
		else:
			j += 2
ans = 1
mod = 10 ** 9 + 7
for i in range(n + 1):
	if data[i] != 0:
		ans = ans * (data[i] + 1) % mod
print(ans)


MOD = 10 ** 9 + 7
memo = [0] * 10000
N = int(input())

def primeLst(k):
	acc = []
	if k == 1:
		return acc
	f = 2
	while f * f <= k:
		if k % f == 0:
			acc.append(f)
			k //= f
		else:
			f += 1
	if k != 1:
		acc.append(k)
	return acc
for i in range(N):
	l = primeLst(i + 1)
	for x in l:
		memo[x] += 1
res = 1
for i in range(1, N):
	res *= memo[i + 1] + 1
	res %= MOD
print(res)


import math
prime = [2, 3, 5]
for i in range(7, 1001, 2):
	sqi = math.sqrt(i)
	for j in prime:
		if i % j == 0:
			break
		if sqi < j:
			prime.append(i)
			break

def legendre(n, p):
	if n == 0:
		return 0
	else:
		return n // p + legendre(n // p, p)
N = int(input())
power_of_prime = [legendre(N, p) for p in prime]
cnt = 1
for i in range(len(power_of_prime)):
	cnt = cnt * (power_of_prime[i] + 1) % 1000000007
print(cnt)


import math
N = int(input())
f = math.factorial(N)
i = 2
ans = 1
cnt = 0
while f != 1:
	if f % i == 0:
		f //= i
		cnt += 1
	else:
		ans *= cnt + 1
		cnt = 0
		i += 1
print(ans * (cnt + 1) % (10 ** 9 + 7))


from collections import Counter
n = int(input())
l = []
for i in range(2, n + 1):
	k = 2
	t = i
	while k * k <= t:
		if t % k == 0:
			l.append(k)
			t = t // k
		else:
			k += 1
	if n > 0:
		l.append(t)
c = Counter(l)
ans = 1
for (key, value) in c.items():
	ans *= value + 1
print(ans % (10 ** 9 + 7))


import math
N = int(input())

def factrize(N):
	L = {}
	for n in range(2, N + 1):
		L[n] = 0
		while N % n == 0:
			L[n] += 1
			N = N / n
	return L
f_ = {}
for n in range(2, int(N) + 1):
	f_[n] = 0
for n in range(1, N + 1):
	F = factrize(n)
	for f in F.keys():
		f_[f] += F[f]
ans = 1
for f in f_.keys():
	if f_[f] != 0:
		ans = ans * (f_[f] + 1)
print(ans % (10 ** 9 + 7))


N = int(input())
mul_num = [1] * (N + 1)
for i in range(N, 2, -1):
	for j in range(2, i):
		if i % j == 0:
			mul_num[int(i / j)] += mul_num[i]
			mul_num[j] += mul_num[i]
			mul_num[i] = 0
ans = 1
for i in mul_num[2:]:
	if i > 0:
		ans *= i + 1
print(ans % (10 ** 9 + 7))


import sys
import math
from collections import defaultdict
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda : sys.stdin.readline().strip()
NI = lambda : int(input())
NMI = lambda : map(int, input().split())
NLI = lambda : list(NMI())
SI = lambda : input()

def prime_fact(n):
	root = int(math.sqrt(n))
	prime_dict = {}
	for i in range(2, root + 1):
		cnt = 0
		while n % i == 0:
			cnt += 1
			n = n // i
		if cnt:
			prime_dict[i] = cnt
	if n != 1:
		prime_dict[n] = 1
	return prime_dict

def main():
	N = NI()
	D = defaultdict(int)
	if N == 1:
		print(1)
		return
	for n in range(2, N + 1):
		ND = prime_fact(n)
		for (p, a) in list(ND.items()):
			D[p] += a
	ans = 1
	for (p, a) in list(D.items()):
		ans = ans * (a + 1) % MOD
	print(ans)

def __starting_point():
	main()
__starting_point()


n = int(input())
x = 1
for i in range(1, n + 1):
	x *= i
res = 1
for i in range(2, n + 1):
	cnt = 1
	while x % i == 0:
		x = x // i
		cnt += 1
	res *= cnt
print(res % (10 ** 9 + 7))


def factor(n):
	for i in range(2, n + 1):
		if n % i == 0:
			l = factor(n // i)
			l.append(i)
			return l
	return []
from collections import Counter
N = int(input())
c = Counter()
for i in range(1, N + 1):
	c += Counter(factor(i))
p = 1
for (_, i) in c.items():
	p *= i + 1
	p %= 1000000007
print(p)


import math

def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
n = int(input())
ex = [1] * 1001
ans = 1
for i in range(2, n + 1):
	n_fact = factorization(i)
	for (j, k) in n_fact:
		ex[j] += k
for i in ex:
	ans *= i
	ans %= 10 ** 9 + 7
print(ans)


from collections import Counter
from math import factorial
N = int(input())
MOD = 10 ** 9 + 7

def prime(n):
	b = 2
	while b * b <= n:
		while n % b == 0:
			n //= b
			a.append(b)
		b += 1
	if n > 1:
		a.append(n)
a = []
prime(factorial(N))
A = Counter(a)
X = 1
for (k, v) in A.items():
	X *= (v + 1) % MOD
print(X % MOD)


def prime_fact(N):
	M = N
	primes = []
	K = 2
	while K * K <= M:
		while N % K == 0:
			primes.append(K)
			N = N // K
		K += 1
	if N != 1:
		primes.append(N)
	return primes
N = int(input())
nums = [0] * 1000
ans = 1
for i in range(2, N + 1):
	P = prime_fact(i)
	for j in range(len(P)):
		nums[P[j] - 1] += 1
for k in range(1000):
	ans = ans * (nums[k] + 1) % 1000000007
print(ans)


import math
n = int(input())
s = math.factorial(n)
mod = 10 ** 9 + 7
i = 2
cnt = 0
ans = 1
while s != 1:
	if s % i == 0:
		cnt += 1
		s //= i
	else:
		ans *= cnt + 1
		cnt = 0
		i += 1
print(ans * (cnt + 1) % mod)


from collections import defaultdict
N = int(input())
prime_counts = defaultdict(int)
for i in range(2, N + 1):
	n = i
	for p in prime_counts:
		while True:
			if n % p == 0:
				prime_counts[p] += 1
				n = n // p
			else:
				break
	if n > 1:
		prime_counts[n] += 1
d = 1
for c in prime_counts.values():
	d *= 1 + c
print(d % (10 ** 9 + 7))


N = int(input())
pList = {}
mod = 10 ** 9 + 7

def soinsuu(x):
	if x == 1:
		return
	for p in pList:
		if x % p == 0:
			pList[p] += 1
			return soinsuu(x // p)
	pList[x] = pList.get(x, 0) + 1
	return
for n in range(2, N + 1):
	soinsuu(n)
ans = 1
for i in pList.values():
	ans = ans * (i + 1) % mod
print(ans)


from collections import defaultdict
INF = 10 ** 9 + 7
N = int(input())
d = defaultdict(int)
for i in range(1, N + 1):
	for j in range(2, int(i ** 0.5) + 1):
		while i % j == 0:
			d[j] += 1
			i //= j
	if i > 1:
		d[i] += 1
ans = 1
for i in d.values():
	ans *= i + 1
	ans %= INF
print(ans)


n = int(input())
prime = [2]
for i in range(3, n + 1):
	if all((i % x for x in prime)):
		prime.append(i)
ans = 1
p = 1000000007
for x in prime:
	a = n
	cnt = 0
	while a != 0:
		cnt += a // x
		a //= x
	ans = ans * (cnt + 1) % p
print(ans)


from collections import defaultdict
n = int(input())
mod = 10 ** 9 + 7
d = defaultdict(int)
for i in range(2, n + 1):
	c = i
	for j in range(2, c + 1):
		if c % j == 0:
			cnt = 0
			while c % j == 0:
				cnt += 1
				c //= j
			d[j] += cnt
ans = 1
for v in d.values():
	ans = ans * (v + 1) % mod
print(ans)


N = int(input())
l = [0] * 1000

def divisor_enu(N):
	l = []
	for i in range(2, int(N ** 0.5) + 1):
		cnt = 0
		if N % i == 0:
			while N % i == 0:
				cnt += 1
				N //= i
			l.append((i, cnt))
	if N != 1:
		l.append((N, 1))
	return l
for i in range(1, N + 1):
	s = divisor_enu(i)
	for j in s:
		l[j[0]] += j[1]
ans = 1
mod = 10 ** 9 + 7
for i in l:
	if 0 < i:
		ans = ans * (i + 1) % mod
print(ans)


N = int(input())
K = eval('*'.join(map(str, list(range(1, N + 1)))))
ans = 1
for i in range(2, N + 1):
	num = 0
	while K % i == 0:
		num += 1
		K //= i
	ans *= num + 1
print(ans % (10 ** 9 + 7))


import math
mod = 10 ** 9 + 7
n = int(input())

def nprf(n):
	E = [0] * (n + 1)
	for i in range(2, n + 1):
		for j in range(2, i + 1):
			while i % j == 0:
				E[j] += 1
				i //= j
	return E
ans = 1
for i in nprf(n):
	ans *= i + 1
print(ans % mod)


N = int(input())
c = {}
for i in range(1, N + 1):
	t = 0
	for k in range(2, i + 1):
		t = 0
		if i % k == 0:
			while i % k == 0:
				i //= k
				t += 1
			c[k] = c.get(k, 0) + t
ans = 1
for k in c.keys():
	ans *= c[k] + 1
print(ans % (10 ** 9 + 7))


n = int(input())
mod = 10 ** 9 + 7
s = [0] * (n + 1)
for i in range(2, n + 1):
	p = 2
	while i > 1:
		while i % p == 0:
			i //= p
			s[p] += 1
		p += 1
ans = 1
for i in s:
	ans *= i + 1
	ans %= mod
print(ans)


MOD = int(1000000000.0 + 7)
n = int(input())
es = [0] * 1010

def div(x):
	if x == 1:
		return
	for i in range(2, x + 1):
		while x % i == 0:
			es[i] += 1
			x //= i
for i in range(1, n + 1):
	div(i)
ans = 1
for i in range(1, n + 1):
	ans *= es[i] + 1
print(ans % MOD)


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

def soinsu(n, e):
	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
soinsu(n, e)
ans = 1
for i in range(n + 1):
	ans *= e[i] + 1
	ans %= 10 ** 9 + 7
print(ans)


n = int(input())
d = dict()
for i in range(n + 1):
	while i > 1:
		for j in range(2, i + 1):
			if i % j == 0:
				d[j] = d.get(j, 0) + 1
				break
		i = i // j
ans = 1
for i in d:
	ans = ans * (d[i] + 1) % (10 ** 9 + 7)
print(ans)


n = int(input())
lis = [i for i in range(n + 1)]
cnt = [0 for i in range(n + 1)]
for i in range(2, n + 1):
	for j in range(i, n + 1, i):
		while lis[j] % i == 0:
			cnt[i] += 1
			lis[j] //= i
ans = 1
for i in cnt:
	ans = ans * (i + 1) % 1000000007
print(ans)


N = int(input())
shisuu = [0] * (N + 1)
for i in range(2, N + 1):
	x = i
	for j in range(2, N + 1):
		while x % j == 0:
			x //= j
			shisuu[j] += 1
ans = 1
mod = 10 ** 9 + 7
for s in shisuu:
	ans *= s + 1
	ans %= mod
print(ans)


import math
import collections
N = int(input())
n = math.factorial(N)
a = []
ans = 1
while n % 2 == 0:
	a.append(2)
	n //= 2
f = 3
while f * f <= n:
	if n % f == 0:
		a.append(f)
		n //= f
	else:
		f += 2
if n != 1:
	a.append(n)
a = collections.Counter(a)
for i in a.values():
	ans *= i + 1
print(ans % 1000000007)


n = int(input())
ans = 1
mod = 10 ** 9 + 7
m = 1
for i in range(n):
	m *= i + 1
for j in range(2, n + 1):
	b = 1
	while m % j == 0:
		m = m // j
		b += 1
	ans *= b
ans = ans % mod
print(ans)


n = int(input())
arr = dict()
k = set()
for h in range(2, n + 1):
	i = h
	for j in range(2, int(-(-i ** 0.5 // 1)) + 1):
		if i % j == 0:
			cnt = 0
			while i % j == 0:
				cnt += 1
				i //= j
			if j not in arr:
				arr[j] = cnt
				k.add(j)
			else:
				arr[j] += cnt
	if i != 1:
		if i in arr:
			arr[i] += 1
		else:
			arr[i] = 1
		k.add(i)
ans = 1
for num in k:
	ans *= arr[num] + 1
	ans = ans % (10 ** 9 + 7)
print(ans)


from collections import defaultdict
MOD = 10 ** 9 + 7
N = int(input())
ans = 1
ary = defaultdict(int)
for i in range(1, N + 1):
	n = i
	m = 2
	while n > 1:
		if not n % m:
			ary[m] += 1
			n //= m
			m = 1
		m += 1
for v in dict(ary).values():
	ans *= v + 1
	ans %= MOD
print(ans)


N = int(input())
soinsu = []
ans = 1
if N == 1:
	print(1)
	exit()
for i in range(2, N + 1):
	num_tmp = i
	for j in range(2, i + 1):
		while num_tmp % j == 0 and num_tmp != 1:
			num_tmp /= j
			soinsu.append(j)
for i in range(2, N + 1):
	cnt_tmp = soinsu.count(i)
	if cnt_tmp > 0:
		ans *= cnt_tmp + 1
print(ans % (10 ** 9 + 7))


import math

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			return False
	return True
sosu = []
for i in range(1, 1001):
	if is_prime(i):
		sosu.append(i)
N = int(input())
mod = 10 ** 9 + 7
x = math.factorial(N)
a = 1
for i in range(len(sosu)):
	cnt = 0
	if sosu[i] > x:
		break
	while x % sosu[i] == 0:
		x = x // sosu[i]
		cnt += 1
	if cnt:
		a *= cnt + 1
		a %= mod
print(a)


from math import factorial
N = int(input())
F = factorial(N)
result = 1
for i in range(2, N + 1):
	count = 1
	while F % i == 0:
		F //= i
		count += 1
	result *= count
print(result % (10 ** 9 + 7))


N = int(input())
a = {}
for i in range(N):
	b = i + 1
	j = 2
	while j * j <= b:
		while b % j == 0:
			if j in a:
				a[j] += 1
			else:
				a[j] = 1
			b /= j
		j += 1
	if b != 1:
		if b in a:
			a[b] += 1
		else:
			a[b] = 1
c = 1
for i in a.values():
	c *= i + 1
print(c % 1000000007)


from collections import defaultdict
N = int(input())
factors = defaultdict(int)
for n in range(2, N + 1):
	for i in range(2, int(n ** 0.5) + 1):
		while n % i == 0:
			n //= i
			factors[i] += 1
	if n > 1:
		factors[n] += 1
ans = 1
for c in factors.values():
	ans *= c + 1
	ans %= 1000000007
print(ans)


def PrimeDecomp(N, ConcFlag):
	if ConcFlag:
		if N <= 1:
			return ([1], 1)
		else:
			I = 2
			PrimeDec = []
			DivCount = 1
			while I * I <= N:
				Cnt = 0
				while N % I == 0:
					N //= I
					PrimeDec.append(I)
				DivCount *= Cnt + 1
				I += 1
			if N >= 2:
				PrimeDec.append(N)
				DivCount *= 2
			return (PrimeDec, DivCount)
	elif N <= 1:
		return ([1], [1], 1)
	else:
		I = 2
		PrimeDec = []
		PrimeCnt = []
		DivCount = 1
		while I * I <= N:
			Cnt = 0
			while N % I == 0:
				N //= I
				Cnt += 1
			if Cnt >= 1:
				PrimeDec.append(I)
				PrimeCnt.append(Cnt)
				DivCount *= Cnt + 1
			I += 1
		if N >= 2:
			PrimeDec.append(N)
			PrimeCnt.append(1)
			DivCount *= 2
		return (PrimeDec, PrimeCnt, DivCount)

def DivisorFactorial(N, FactDec, FactCnt, MemoFlag, Mod, ModFlag):
	if MemoFlag:
		if N <= 1:
			FDivCnt = 1
			return (FactDec, FactCnt, FDivCnt)
		else:
			(PrimeDec, PrimeCnt, _) = PrimeDecomp(N, False)
			for TP in range(0, len(PrimeDec)):
				if PrimeDec[TP] in set(FactDec):
					FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
				else:
					FactDec.append(PrimeDec[TP])
					FactCnt.append(PrimeCnt[TP])
			FDivCnt = 1
			for TF in FactCnt:
				FDivCnt = [FDivCnt * (TF + 1), FDivCnt * (TF + 1) % Mod][ModFlag]
			return (FactDec, FactCnt, FDivCnt)
	elif N <= 1:
		FDivCnt = 1
		return (FactDec, FactCnt, FDivCnt)
	else:
		for TN in range(2, N + 1):
			(PrimeDec, PrimeCnt, _) = PrimeDecomp(TN, False)
			for TP in range(0, len(PrimeDec)):
				if PrimeDec[TP] in set(FactDec):
					FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
				else:
					FactDec.append(PrimeDec[TP])
					FactCnt.append(PrimeCnt[TP])
		FDivCnt = 1
		for TF in FactCnt:
			FDivCnt = [FDivCnt * (TF + 1), FDivCnt * (TF + 1) % Mod][ModFlag]
		return (FactDec, FactCnt, FDivCnt)
(FactDec, FactCnt, FDivCnt) = DivisorFactorial(int(input()), [], [], False, 10 ** 9 + 7, True)
print(FDivCnt)


from math import factorial
N = int(input())
mod = 10 ** 9 + 7
fn = factorial(N)
ans = 1
for i in range(2, N + 1):
	count = 1
	while fn % i == 0:
		count += 1
		fn //= i
	ans *= count
print(ans % mod)


def factorization(n):
	arr = []
	temp = n
	for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
		if temp % i == 0:
			cnt = 0
			while temp % i == 0:
				cnt += 1
				temp //= i
			arr.append([i, cnt])
	if temp != 1:
		arr.append([temp, 1])
	if arr == []:
		arr.append([n, 1])
	return arr
N = int(input())
mod = 10 ** 9 + 7
if N == 1:
	print(1)
else:
	ans = 1
	dp = [0] * 1001
	for i in range(2, N + 1):
		p = factorization(i)
		for (i, j) in p:
			dp[i] += j
	for i in range(1001):
		ans *= dp[i] + 1
		ans %= mod
	print(ans)


import math

def solve(N):
	F = math.factorial(N)
	ans = 1
	for i in range(2, N + 1):
		count = 1
		while F % i == 0:
			F //= i
			count += 1
		ans *= count
	print(ans % (10 ** 9 + 7))
N = int(input())
solve(N)


N = int(input())
from collections import defaultdict
arr = defaultdict(int)
for i in range(2, N + 1):
	temp = i
	f = True
	for j in range(2, int(-(-i ** 0.5 // 1)) + 1):
		if temp % j == 0:
			cnt = 0
			while temp % j == 0:
				cnt += 1
				temp //= j
			f = False
			arr[j] += cnt
	if temp != 1:
		f = False
		arr[temp] += 1
	if f:
		arr[i] += 1
ans = 1
for i in arr.values():
	ans *= i + 1
	ans %= 10 ** 9 + 7
print(ans)


n = int(input())
multiplier = [0 for _ in range(n)]
for m in range(2, n + 1):
	a = m
	i = 2
	while i ** 2 <= m:
		while a % i == 0:
			a = int(a / i)
			multiplier[i - 1] += 1
		i += 1
	if a != 1:
		multiplier[a - 1] += 1
ans = 1
for x in multiplier:
	ans *= x + 1
print(ans % (10 ** 9 + 7))


from collections import defaultdict
n = int(input())
factors = defaultdict(int)
for i in range(2, n + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			factors[j] += 1
			i //= j
if n == 1:
	print(1)
else:
	a = '*'.join((str(value + 1) for value in factors.values()))
	print(eval(a) % (10 ** 9 + 7))


N = int(input())
A = [0 for i in range(1001)]
mod = 10 ** 9 + 7
for n in range(2, N + 1):
	m = n
	k = 2
	while m > 1:
		while m % k == 0:
			m //= k
			A[k] += 1
		k += 1
ans = 1
for i in range(1, 1001):
	ans = ans * (A[i] + 1) % mod
print(ans)


n = int(input())
mod = 10 ** 9 + 7

def factors(N):
	factors = []
	while N % 2 == 0:
		factors.append(2)
		N //= 2
	for f in range(3, int(N ** 0.5) + 1, 2):
		while N % f == 0:
			factors.append(f)
			N //= f
	if N != 1:
		factors.append(N)
	return factors
cd = dict()
for i in range(1, n + 1):
	facs = factors(i)
	for f in facs:
		cd.setdefault(f, 0)
		cd[f] += 1
ans = 1
for (key, v) in list(cd.items()):
	ans *= v + 1
	ans %= mod
print(ans)


import collections
N = int(input())
ls = [0] + [0] * N
couterls = collections.Counter(ls)
for i in range(1, N + 1):
	for j in range(2, N + 1):
		if i % j == 0:
			while i % j == 0:
				couterls[j] += 1
				i = i // j
		elif i == 1:
			break
		else:
			pass
ans = 1
couterls.pop(0)
for i in couterls.values():
	ans = ans * (i + 1) % (10 ** 9 + 7)
print(ans)


N = int(input())
t = [0] * (N + 1)
for i in range(2, N + 1):
	x = i
	p = 2
	while x > 1:
		while x % p == 0:
			t[p] += 1
			x //= p
		p += 1
ans = 1
for c in t:
	ans = ans * (c + 1) % (10 ** 9 + 7)
print(ans)


N = int(input())
p = 1
for i in range(2, N + 1):
	p *= i
ans = 1
for i in range(2, N + 1):
	if p % i != 0:
		continue
	c = 1
	while p % i == 0:
		p //= i
		c += 1
	ans *= c
print(ans % 1000000007)


import math
N = int(input())
F = math.factorial(N)
ans = 1
for i in range(2, N + 1):
	cnt = 1
	while F % i == 0:
		F //= i
		cnt += 1
	ans *= cnt
print(ans % (10 ** 9 + 7))


N = int(input())
mod = 10 ** 9 + 7
fact = {}
for j in range(2, N + 1):
	for i in range(2, j + 1):
		while j % i == 0:
			if i in fact.keys():
				fact[i] += 1
			else:
				fact[i] = 2
			j //= i
ans = 1
for v in fact.values():
	ans *= v
	ans %= mod
print(ans)


MOD = 10 ** 9 + 7
max_n = 1000
n = int(input())
ans = 0
nums = [0] * (n + 1)
for i in range(1, n + 1):
	v = i
	j = 2
	while v > 0 and i >= j:
		if v % j == 0:
			nums[j] += 1
			v = v // j
		else:
			j += 1
ans = 1
for i in range(n + 1):
	if nums[i] > 0:
		ans *= 1 + nums[i]
	ans %= MOD
print(ans)


from collections import defaultdict
mod = 10 ** 9 + 7

def factorize(n):
	out = []
	i = 2
	while 1:
		if n % i == 0:
			out.append(i)
			n //= i
		else:
			i += 1
		if n == 1:
			break
		if i > int(n ** 0.5 + 3):
			out.append(n)
			break
	return out
N = int(input())
if N == 1:
	print(1)
	return
count = defaultdict(int)
for i in range(2, N + 1):
	f = factorize(i)
	for j in range(len(f)):
		count[f[j]] += 1
ans = 1
for k in count.keys():
	ans *= count[k] + 1 % mod
print(ans % mod)


n = int(input())
d = {i: 0 for i in range(2, n + 1)}

def prime_factorize(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n //= 2
	f = 3
	while f * f <= n:
		if n % f == 0:
			a.append(f)
			n //= f
		else:
			f += 2
	if n != 1:
		a.append(n)
	return a
for i in range(2, n + 1):
	for j in prime_factorize(i):
		d[j] += 1
a = 1
for v in d.values():
	a = a * (v + 1)
print(a % (10 ** 9 + 7))


mod = 1000000007
N = int(input())
dic = {}
for i in range(1, N + 1):
	tmp = i
	k = 2
	while tmp != 1:
		if tmp % k == 0:
			if k in dic:
				dic[k] += 1
			else:
				dic[k] = 1
			tmp //= k
			k = 2
		else:
			k += 1
ans = 1
for i in dic.values():
	ans = ans * (i + 1) % mod
print(ans)


from functools import reduce
N = int(input())
prime_table = [1] * (N + 1)
for x in range(2, N + 1):
	for t in range(2, x + 1):
		while x % t == 0:
			prime_table[t] += 1
			x //= t
print(reduce(lambda x, y: x * y % (int(1000000000.0) + 7), prime_table))


import math
from collections import defaultdict
N = int(input())
MOD = 10 ** 9 + 7
d = defaultdict(int)
d[1] = 0
for i in range(2, N + 1):
	for j in range(2, N + 1):
		while i % j == 0:
			i //= j
			d[j] += 1
ans = 1
for i in d.values():
	ans = ans * (i + 1) % MOD
print(ans)


from math import sqrt
n = int(input())
d = {}
mod = 10 ** 9 + 7
for i in range(1, n):
	m = i + 1
	for j in range(2, int(sqrt(i + 1)) + 1):
		if m % j == 0:
			while m % j == 0:
				d[j] = d.get(j, 0) + 1
				m //= j
	if m > 1:
		d[m] = d.get(m, 0) + 1
ans = 1
for i in d:
	ans *= d[i] + 1
	ans %= mod
print(ans)


def erat(n):
	n += 1
	l = [1 for _ in range(n)]
	(l[0], l[1]) = (0, 0)
	for i in range(4, n, 2):
		l[i] = 0
	for i in range(9, n, 6):
		l[i] = 0
	for i in range(6, n, 6):
		if l[i - 1]:
			for j in range((i - 1) * (i - 1), n, i - 1):
				l[j] = 0
		if l[i + 1]:
			for j in range((i + 1) * (i + 1), n, i + 1):
				l[j] = 0
	return l
prime = []
for i in range(1001):
	if erat(1000)[i]:
		prime.append(i)
n = int(input())
u = [0] * 1001
for i in range(1, n + 1):
	for j in prime:
		while i % j == 0:
			i //= j
			u[j] += 1
ans = 1
for i in u:
	ans *= i + 1
print(ans % (10 ** 9 + 7))


N = int(input())
ans = 1
divine = [1 for _ in range(N + 1)]
for i in range(1, N + 1):
	for j in range(2, i + 1):
		while i % j == 0:
			i //= j
			divine[j] += 1
for k in divine:
	ans *= k
print(ans % 1000000007)


n = int(input())
pf = {}
mod = 10 ** 9 + 7
for m in range(1, n + 1):
	for i in range(2, int(m ** 0.5) + 1):
		while not m % i:
			pf[i] = pf.get(i, 0) + 1
			m //= i
	if m > 1:
		if m in pf:
			pf[m] += 1
		else:
			pf[m] = 1
res = 1
for (i, j) in pf.items():
	res *= j + 1
print(res % mod)


n = int(input())
P = [2]
for i in range(3, n + 1, 2):
	for j in range(3, int(i ** 0.5 + 1)):
		if i % j == 0:
			break
	else:
		P.append(i)
p = [1] * len(P)
for i in range(1, n + 1):
	for j in range(len(P)):
		x = i
		c = 0
		while x % P[j] == 0:
			x //= P[j]
			c += 1
		p[j] += c
a = 1
for x in p:
	a *= x
print(a % (10 ** 9 + 7))


def bunkai(n):
	b = 2
	fct = []
	while b * b <= n:
		while n % b == 0:
			n //= b
			fct.append(b)
		b = b + 1
	if n > 1:
		fct.append(n)
	return fct
n = int(input())
s = [0] * (n + 1)
for i in range(1, n + 1):
	fact = bunkai(i)
	for j in fact:
		s[j] += 1
ans = 1
for i in range(0, n + 1):
	ans *= s[i] + 1
	ans %= 10 ** 9 + 7
print(ans)