Problem:
Score : 400 points

Problem 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''.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq M \leq 10^9

Input

Input is given from Standard Input in the following format:

N M

Output

Print the number of the sequences consisting of positive integers that satisfy the condition, modulo 10^9 + 7.

Sample Input 1

2 6

Sample Output 1

4

Four sequences satisfy the condition: \{a_1, a_2\} = \{1, 6\}, \{2, 3\}, \{3, 2\} and \{6, 1\}.

Sample Input 2

3 12

Sample Output 2

18

Sample Input 3

100000 1000000000

Sample Output 3

957870001

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Runtime Error)

(defmacro defmemo (name args &body exprs)
  "Define memoized function with referential transparency."
  (let ((fn (gensym))
        (memo (gensym)))
    `(labels ((,fn ,args ,@exprs))
       (let ((,memo (make-hash-table :test #'equal)))
         (defun ,name ,args
           (or (gethash (list ,@args) ,memo)
               (setf (gethash (list ,@args) ,memo) (apply (function ,fn) (list ,@args)))))))))

(defparameter *n* (read))
(defparameter *m* (read))

(defun f (m)
  (labels ((f1 (m div lst)
             (let ((x (/ m div)))
               (cond ((= x 1) (cons div lst))
                     ((integerp x) (f1 x div (cons div lst)))
                     ((< m (* div div)) m)
                     ((oddp div) (f1 m (+ div 2) lst))
                     (t (f1 m (1+ div) lst))))))
    (f1 m 2 nil)))

(defun combination (n r)
  (if (zerop r)
      1
      (* (/ n r)
         (combination (1- n) (1- r)))))

(defun g (lst)
  (mapcar (lambda (n) (count n lst)) (remove-duplicates lst)))

(defun h (n lst)
  (apply #'* (mapcar (lambda (x)
                       (combination (+ x (1- n)) x))
                     lst)))

(defun i (n m)
  (mod (h n (g (f m))) (+ 1000000000 7)))

(princ (i *n* *m*))