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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        int n = sc.nextInt();
        int m = sc.nextInt();
        int mod = 1_000_000_007;
        
        //約数
        ArrayList<Integer> mfac = new ArrayList<>();
        
        for(int i=1; i*i<=m; i++){
            if(m%i==0){
                mfac.add(i);
                if(i*i!=m){
                    mfac.add(m/i);
                }
            }
        }
        
        int[] f = mfac.stream().mapToInt((Integer i)->i).toArray();
        Arrays.sort(f);
        
        //
        for(int i=0; i<f.length; i++){
            //System.out.println(f[i]);
        }
        //
        
        //DPする
        long[][] dp = new long[2][f.length];
        dp[0][0] = 1L;
        
        for(int i=0; i<n; i++){
            for(int j=0; j<f.length; j++){
                //System.out.println("j"+j);
                for(int k=0; k<f.length; k++){
                    int idx = bs(f, f[j]*f[k]);
                    //System.out.println(idx);
                    if(f.length <= idx) continue;
                    dp[1][idx] += dp[0][k];
                    dp[1][idx] %= mod;
                }
                /*
                for(int k=0; k<dp[0].length; k++){
                    System.out.println("i:" + k +"   val:" + dp[1][k]);
                }
                */
            }
            for(int j=0; j<f.length; j++){
                dp[0][j] = dp[1][j]%mod;
                dp[1][j] = 0;
            }
        }
        
        /*
        for(int i=0; i<dp[0].length; i++){
            System.out.println("i:" + i +"   val:" + dp[0][i]);
        }*/
        
        System.out.println(dp[0][dp[0].length-1]);
        
    }
    
    public static int bs(int[] f, int key){
        int result = Arrays.binarySearch(f, key);
        int idx = (result >= 0) ? result : 1_000_000_000;
        return idx;
    }
}