mod = 1 << 61 - 1

class Prime():
  def __init__(self,N):
    self.N = N
    self.Is_prime = [1 for i in range(N+1)]
    self.Is_prime[0] = self.Is_prime[1] = 0
    self.P = []
    #self.Fact = [[] for i in range(N+1)]   #################
    #self.Fact[1] = [(1,1)]  ################################
    for p in range(2,N + 1):
      if self.Is_prime[p] == 0:
        continue
      self.P.append(p)
      #self.Fact[p].append((p,1))  ##########################
      for d in range(2,N//p + 1):
        self.Is_prime[p*d] = 0
        q = 1
        r = p
        while (p*d) % (p*r) == 0:
          q += 1
          r *= p
        #self.Fact[p*d].append((p,q))  ######################
  
  def is_prime(self,p):
    return self.Is_prime[p]
  
  def primelist(self):
    return self.P
  
  def fact(self,n): #########のところを外して使う.
    return self.Fact[n]

P = Prime(400000)

def sum_of_multiplicative_function(N):
  M = 0
  while (M + 1) * (M + 1) <= N:
    M += 1
  
  Q = [i for i in range(1,M + 1)]
  for i in range(M,0,-1):
    if Q[-1] == N // i:
      continue
    Q.append(N // i)
  idx = {}
  for i in range(len(Q)):
    idx[Q[i]] = i
  le = len(Q)

  Sp = [0 for i in range(le)] # Sp_i:1 ~ Q[i]

  mul = [((1,0))]
  for a,c in mul:
    S = [0 for i in range(le)]
    for i in range(1,le):
      res = Q[i]
      # cによって値が違う.(c乗和)
      S[i] = (res - 1) * a % mod
    SS = S[:]
    for x in range(2,M + 1):
      # not prime
      if not P.is_prime(x):
        continue
      for i in range(le - 1, -1, -1):
        n = Q[i]
        if n < x * x:
          for j in range(i, le):
            SS[j] = S[j]
          break
        S[i] = (S[i] - SS[idx[n // x]] + SS[idx[x - 1]]) % mod
    for i in range(le):
      Sp[i] = (Sp[i] + S[i]) % mod
  return Sp[-1]

# N!の約数の個数?

mod = 1000000007
inv_2 = (mod + 1) // 2
N = int(input())
n = sum_of_multiplicative_function(N)
x = 1
ans = 1
for d in range(2, N + 1):
  if d * d >= N:
    break
  m = sum_of_multiplicative_function(N // d)
  ans = ans * pow(x + 1, n - m, mod) % mod
  x += 1
  n = m

for p in P.P:
  if p * p > N:
    break
  r = 1 + (N // p) + (N // (p * p))
  q = p * p
  while q * p <= N:
    q *= p
    r += N // q
  ans = ans * r % mod

print(ans)