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.

Difficulty: introductory

Starter code:

Solutions:
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)

# 高速素因数分解
# """2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""

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)


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)


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()


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)

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(1e9) + 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)

import math
N = int(input())
m = math.factorial(N)
A = 1000*[1]
ans = 1

for n in range(2,1001):
  while m%n==0:
    m//=n
    A[n]+=1

for a in A:
  ans*=a

print(ans%(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

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)


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())

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))

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 # 約数として求められたある数の合計

# N! の各要素の素因数分解をする
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)

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 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())
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())
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))

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)

import collections
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))

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)

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)


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 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())

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
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)

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())

ji = {}
ans = 1
m = 1000000007
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)
    ans %= m
    

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)

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 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()

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)


# エラトステネスの篩, 素因数分解
def make_prime_table(n):
    sieve = list(range(n + 1))
    sieve[0] = -1
    sieve[1] = -1
    for i in range(2, int(n ** 0.5) + 1):
        if sieve[i] != i:
            continue
        for j in range(i * i, n + 1, i):
            if sieve[j] == j:
                sieve[j] = i
    return sieve


def prime_factorize(n):
    result = []
    while n != 1:
        p = prime_table[n]
        c = 0
        while n % p == 0:
            n //= p
            c += 1
        result.append((p, c))
    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)


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())

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))


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(1e9+7)
print(ans)
        


#!/usr/bin/env python3

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)

#print('ind =', ind)
ans = 1 
for i in range(len(ind)):
    ans *= (ind[i]+1)

print((ans%mod))


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

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)

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)

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)

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()

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        
    else:
        if 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
    else:
        if 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)

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


# 約数の数 = (素数xの個数+1)(素数yの個数+1)(素数zの個数+1)...
# 方針：入力値を素因数分解し、各素因数の個数を求める

# n-iの素因数を求める
for j in range(2, n+1):
    get_prime(j)

# print(divisor)

# 各素因数の組み合わせ数を求める
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)

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)

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())
s = 1
ans = 1
for i in range(1, n+1):
  s *= i
for i in range(2, n+1):
  k = 1
  while s % i == 0:
    s = s // i
    k += 1
  ans *= k
print(ans % (10 ** 9 + 7))

d={}
for i in range(int(input())+1):
  for j in d:
    while 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)

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))

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        
    else:
        if 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
    else:
        if 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))

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))

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)

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)

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)

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 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**.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)

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))

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())
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)

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): # 1〜nまでの各値を素因数分解
  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():
  # 取得した要素に1を足した値を合計値にかけ合わせる
  # 約数として"1"はカウントされていない為、このタイミングで追加する
  ans *= (v+1) 
  ans %= mod
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 # 約数として求められたある数の合計

# N! の各要素の素因数分解をする
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)

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)


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())
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)

import sys
import math
n = int(input())
if n == 1:
  print(1)
  return
prime_list = []
    #2からnまでの数字をsearch_listに入れる
search_list = list(range(2,n+1))
while True:
      #search_listの先頭の値が√nの値を超えたら処理終了
      if search_list[0] > math.sqrt(n):
        #prime_listにsearch_listを結合
          prime_list.extend(search_list)
          break
      else:
        #search_listの先頭をprime_listに入れる
          head_num = search_list[0]
          prime_list.append(head_num)
        #search_listの先頭をpopする
          search_list.pop(0)
        #head_numの倍数を取り除く
          search_list = [num for num in search_list if num % head_num != 0]
#print(prime_list)
########ここから本問を解く#########
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)

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)

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)

#!/usr/bin/env python3
import sys
from functools import reduce

MOD = 1000000007  # type: int


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))

# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    print((solve(N)))

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

def __starting_point():
    #test()
    main()

__starting_point()

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())
if n==1:
    print(1)
    return
l=[0]*(n+1)#約数0~1000の各総数
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
#print(l)
ans=1
for i in range(len(l)):
    ans*=(l[i]+1)
    ans%=(10**9 +7)
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)

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)

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))
    
    
      
      


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)

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)))


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

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
#print(numofdiv)
for q in range(N+2):
    ans*=numofdiv[q]+1
    ans%=MOD
print(ans)


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())
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)

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)






n=int(input())

sosuu = [2]
A = 1000
for L in range(3, A, 2): # 2 以外の素数は奇数なので
    for L2 in sosuu:
        if L % L2 == 0:
            break # 素数でないことがわかったらそれ以上ループする必要はない
    else: # break で抜けることがなかったら L は素数（Python 特有の制御構文）
        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)

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())
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
    # print(pn)
    i=1
    cnt=0
    while (pn**i<=N):
        cnt+=(N//pn**i)
        i+=1
    divN[pn]=cnt

# print(divN)
ans=1
for d in divN:
    if d==0:
        continue
    ans=(ans*(d+1))%p
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 math
import collections
N = int(input())
# N!の約数の個数を10**9+7で割ったあまりを出す
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):
        # print(num)
        while num % i == 0:
            # print(num)
            num = num / i
            prime_numbers.append(i)
    if num != 1:
        prime_numbers.append(int(num))

    return prime_numbers


# print(nums)
nums_counter = {}
for num in nums:
    prime_numbers = prime_factorization(num)
    # print(prime_numbers)
    for prime_num in prime_numbers:
        # print(nums_counter)
        # print(prime_num in nums_counter)
        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())
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)


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))

# -*- coding: utf-8 -*-
"""
Created on Wed Sep 30 01:24:22 2020

@author: liang
"""

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]
    
#print(table)
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(res)
print(ans)

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()

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
        pn = sieve(m)
        for p in pn:
            while m % p == 0:
                res[p] = res.get(p, 0) + 1
                m //= p
        if m > 1:
            res[m] = res.get(m, 0) + 1
    return res

N = int(input())
fn = trial_division(N)
res = 1
for f in fn.values():
    res *= (f + 1)
    res %= MOD
print(res)

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())
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))

n=int(input())
#a,b=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

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)

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)

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()

def factrial(n):
  factors = []
  while n%2 == 0:
    factors.append(2)
    n //= 2
    
  for i in range(3, int(n**0.5)+1, 2):
    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)

def factorize(n):
    #https://python.ms/factorize/#%E5%AE%9F%E8%A3%85
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    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)
#print(fact)
ans = 1
for i in range(len(fact)):
    ans *= (fact[i][1]+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))

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 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)