output_description: Print the number of the sequences consisting of positive integers that satisfy
  the condition, modulo 10^9 + 7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
attempt: # a module for any prime implication
  import random
  
  
  def primesbelow(N):
      # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
      # """ Input N>=6, Returns a list of primes, 2 <= p < N """
      correction = N % 6 > 1
      N = {0: N, 1: N - 1, 2: N + 4, 3: N + 3, 4: N + 2, 5: N + 1}[N % 6]
      sieve = [True] * (N // 3)
      sieve[0] = False
      for i in range(int(N**0.5) // 3 + 1):
          if sieve[i]:
              k = (3 * i + 1) | 1
              sieve[k * k // 3 :: 2 * k] = [False] * (
                  (N // 6 - (k * k) // 6 - 1) // k + 1
              )
              sieve[(k * k + 4 * k - 2 * k * (i % 2)) // 3 :: 2 * k] = [False] * (
                  (N // 6 - (k * k + 4 * k - 2 * k * (i % 2)) // 6 - 1) // k + 1
              )
      return [2, 3] + [(3 * i + 1) | 1 for i in range(1, N // 3 - correction) if sieve[i]]
  
  
  smallprimeset = set(primesbelow(100000))
  _smallprimeset = 100000
  
  
  def isprime(n, precision=7):
      # http://en.wikipedia.org/wiki/Miller-Rabin_primality_test#Algorithm_and_running_time
      if n < 1:
          raise ValueError("Out of bounds, first argument must be > 0")
      elif n <= 3:
          return n >= 2
      elif n % 2 == 0:
          return False
      elif n < _smallprimeset:
          return n in smallprimeset
  
      d = n - 1
      s = 0
      while d % 2 == 0:
          d //= 2
          s += 1
  
      for repeat in range(precision):
          a = random.randrange(2, n - 2)
          x = pow(a, d, n)
  
          if x == 1 or x == n - 1:
              continue
  
          for r in range(s - 1):
              x = pow(x, 2, n)
              if x == 1:
                  return False
              if x == n - 1:
                  break
          else:
              return False
  
      return True
  
  
  # https://comeoncodeon.wordpress.com/2010/09/18/pollard-rho-brent-integer-factorization/
  def pollard_brent(n):
      if n % 2 == 0:
          return 2
      if n % 3 == 0:
          return 3
  
      y, c, m = (
          random.randint(1, n - 1),
          random.randint(1, n - 1),
          random.randint(1, n - 1),
      )
      g, r, q = 1, 1, 1
      while g == 1:
          x = y
          for i in range(r):
              y = (pow(y, 2, n) + c) % n
  
          k = 0
          while k < r and g == 1:
              ys = y
              for i in range(min(m, r - k)):
                  y = (pow(y, 2, n) + c) % n
                  q = q * abs(x - y) % n
              g = gcd(q, n)
              k += m
          r *= 2
      if g == n:
          while True:
              ys = (pow(ys, 2, n) + c) % n
              g = gcd(abs(x - ys), n)
              if g > 1:
                  break
  
      return g
  
  
  smallprimes = primesbelow(
      1000
  )  # might seem low, but 1000*1000 = 1000000, so this will fully factor every composite < 1000000
  
  
  def primefactors(n, sort=False):
      factors = []
  
      for checker in smallprimes:
          while n % checker == 0:
              factors.append(checker)
              n //= checker
          if checker > n:
              break
  
      if n < 2:
          return factors
  
      while n > 1:
          if isprime(n):
              factors.append(n)
              break
          factor = pollard_brent(
              n
          )  # trial division did not fully factor, switch to pollard-brent
          factors.extend(
              primefactors(factor)
          )  # recurse to factor the not necessarily prime factor returned by pollard-brent
          n //= factor
  
      if sort:
          factors.sort()
  
      return factors
  
  
  def factorization(n):
      factors = {}
      for p1 in primefactors(n):
          try:
              factors[p1] += 1
          except KeyError:
              factors[p1] = 1
      return factors
  
  
  def gcd(a, b):
      if a == b:
          return a
      while b > 0:
          a, b = b, a % b
      return a
  
  
  N = 1000000007
  
  
  def c(n, r):
      a = 1
      b = 1
      for i in range(n, n - r, -1):
          a = (a * i) % N
      for i in range(1, r + 1):
          b = (b * i) % N
      binv = pow(b, N - 2, N)
      return (a * binv) % N
  
  
  n, m = map(int, input().strip().split(" "))
  d = factorization(m)
  ans = 1
  for i in d.values():
      ans = (ans * c(i + n - 1, n - 1)) % N
  
  print(ans)
  
problem_description: Statement
  
  You are given positive integers N and M.
  
  How many sequences a of length N consisting of positive integers satisfy a_1
  \times a_2 \times ... \times a_N = M? Find the count modulo 10^9+7.
  
  Here, two sequences a' and a'' are considered different when there exists some
  i such that a_i' \neq a_i''.
samples: [{"input": "2 6", "output": "4\n    \n\nFour sequences satisfy the condition: \\\\{a_1, a_2\\\\} = \\\\{1, 6\\\\}, \\\\{2, 3\\\\},\n\\\\{3, 2\\\\} and \\\\{6, 1\\\\}.\n\n* * *"}, {"input": "3 12", "output": "18\n    \n\n* * *"}, {"input": "100000 1000000000", "output": "957870001"}]