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: Accepted)

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 solve(n: usize, k: usize, dp: &mut Vec<Vec<Option<u64>>>) -> u64 {
    if let Some(ans) = dp[n][k] {
        ans
    } else {
        let ans = if n == 0 {
            if k == 0 { 1 } else { 0 }
        } else {
            let mut ans = 0;
            for i in 0..k+1 {
                ans += solve(n-1, k-i, dp);
                ans %= MOD;
            }
            ans
        };
        dp[n][k] = Some(ans);
        ans
    }
}

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

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

        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;
                }
                // println!("{} {}", i, exp);
                ans *= solve(n, exp, &mut dp);
                ans %= MOD;
            }
        }
        if m != 1 {
            ans *= solve(n, 1, &mut dp);
            ans %= MOD;
        }

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