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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Control.Arrow
import Data.List
import qualified Data.ByteString.Char8 as B

main :: IO ()
main = breads >>= print . solve 

solve :: [Int] -> Int
solve [n, m] = prodOnVal . map mf . group $ sort es
    where
        mf x = fact (calcH $ head x) (length x)
        prodOnVal = foldl' (\l r -> val $ l * r) 1

        calcH v = val $ x * y
            where
                x = prodOnVal [n..(n + v - 1)]
                y = prodOnVal $ map inv [2..v]

        es = dcmp m [2..m]
        
        dcmp v (x : xs)
            | x > v = []
            | v `mod` x /= 0 = dcmp v xs
            | otherwise = c : dcmp w xs
            where
                (c, w) = count x v
        dcmp _ _ = []

        
        count = loop 0
            where
                loop acc x v
                    | b == 0 = loop (acc + 1) x a
                    | otherwise = (acc, v)
                    where
                        (a, b) = v `divMod` x

inv :: Int -> Int 
inv = (`fact` m)
    where
        m = 10 ^ 9 + 5

fact :: Int -> Int -> Int
fact b e
    | e == 0 = 1
    | odd e = val $ b * fact b (e - 1)
    | otherwise = val $ v * v
    where
        v = fact b $ e `div` 2

val :: Int -> Int 
val = (`mod` m)
    where
        m = 10 ^ 9 + 7

breads :: IO [Int]
breads = unfoldr (\s -> second (maybe B.empty snd . B.uncons) <$> B.readInt s) <$> B.getLine