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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::*;
use std::str::*;
use std::collections::*;

pub fn read_from<T: FromStr, R: Read>(s: &mut R) -> T {
    let s = s.bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    if !s.is_empty() {
        if let Ok(s) = s.parse::<T>() {
            s
        } else {
            panic!("faild to parse {}", s);
        }
    } else {
        if cfg!(local) {
            // eprintln!("reached to EOF");
        }
        std::process::exit(0)
    }
}

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let mut stdin = stdin.lock();
    read_from(&mut stdin)
}

const MOD: u64 = 1000000007;

fn main() {
    loop {
        let n: usize = read();
        let mut m: u64 = read();

        let mut dp = vec![vec![0; 30]; n+1];

        for i in 0..n+1 {
            for j in 0..30 {
                if i == 0 {
                    dp[i][j] = if j == 0 { 1 } else { 0 };
                } else {
                    for k in 0..j+1 {
                        dp[i][j] += dp[i-1][j-k];
                    }
                    dp[i][j] %= MOD;
                }
            }
        }

        let mut ans = 1;
        for i in 2..100000 {
            if m % i == 0 {
                let mut exp = 0;
                while m % i == 0 {
                    m /= i;
                    exp += 1;
                }
                ans *= dp[n][exp];
                ans %= MOD;
            }
        }
        if m != 1 {
            ans = n as u64
        }

        println!("{}", ans);
    }
}