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


import java.math.BigInteger;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

public class Main {
    private static final long MOD = 1000000007;

    public static void main(final String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final int n = scanner.nextInt();
        final int m = scanner.nextInt();

        final Map<Integer, AtomicInteger> countMap = new HashMap<>();

        int num = m;
        for (int i = 2; i <= num; i++) {
            if (num % i == 0) {
                countMap.computeIfAbsent(i, counter -> new AtomicInteger())
                        .incrementAndGet();
                num /= i;
                i--;
            }
        }

        final List<Long> answerList = countMap.values().stream()
                .map(AtomicInteger::get)
                .map(value -> calculateCombination(value + n - 1, value))
                .collect(Collectors.toList());

        long answer = 1;
        for (final Long value : answerList) {
            answer = answer * value % MOD;
        }

        System.out.println(answer);

    }

    private static long calculateCombination(final long left, final long right) {
        BigInteger denominator = BigInteger.ONE;
        BigInteger numerator = BigInteger.ONE;

        for (long i = 0; i < right; i++) {
            denominator = denominator.multiply(BigInteger.valueOf(right - i));
            numerator = numerator.multiply(BigInteger.valueOf(left - i));
        }

        return (numerator.divide(denominator)).mod(BigInteger.valueOf(MOD)).longValue();
    }
}