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.42.0) (judge verdict: Time Limit Exceeded)

use std::io;
use std::str::FromStr;
use std::collections::HashMap;

static MOD: u64 = 1_000_000_007;

fn input_tuple() -> (u64, u64) {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    let vec: Vec<u64> = line.split_whitespace().map(|s| s.parse().unwrap()).collect();
    (vec[0], vec[1])
}

fn calc_divisors(n: u64, memo: &mut HashMap<u64, Vec<u64>>) -> Vec<u64> {
    if memo.contains_key(&n) {
        return memo.get(&n).unwrap().to_vec();
    }
    let mut divisors: Vec<u64> = Vec::new();
    for i in 1..(n+1) {
        if i * i > n {
            break;
        }
        if n % i == 0 {
            divisors.push(i);
            if i * i != n {
                divisors.push(n / i);
            }
        }
    }
    memo.insert(n, divisors.to_vec());
    divisors
}

fn main() {
    let (n, m) = input_tuple();
    let mut memo: HashMap<u64, Vec<u64>> = HashMap::new();
    let divisors = calc_divisors(m, &mut memo);

    let mut dp: Vec<HashMap<u64, u64>> = vec![HashMap::new(); n as usize + 1];
    for i in &divisors {
        dp[0].insert(*i, 0);
    }
    dp[0].insert(m, 1);
    for i in 1..n as usize + 1 {
        // println!("{}", i);
        // println!("{:?}", dp);
        for j in &divisors {
            let mut sum = 0;
            for k in &calc_divisors(m/j, &mut memo) {
                // println!("{} {} {}", i, j, k);
                sum += dp[i-1].get(&(j * k)).unwrap();
                sum %= MOD;
            }
            dp[i].insert(*j, sum);
        }
    }
    // println!("{:?}", dp);
    println!("{}", dp[n as usize].get(&1).unwrap());
}