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 C (GCC 5.4.1) (judge verdict: Runtime Error)

#include <stdio.h>
#include <stdlib.h>

int cmp(const void* x, const void* y) {
	int a = *(const int*)x, b = *(const int*)y;
	return a < b ? -1 : a > b;
}

int N, M;

int yc;
int yakusu[128];

int ayane[128];
int asumi[128][128];

int yukachi(int tomatu) {
	int l = 0, r = yc - 1;
	while (l <= r) {
		int m = l + (r - l) / 2;
		if (yakusu[m] == tomatu) return m;
		else if (yakusu[m] < tomatu) l = m + 1;
		else r = m - 1;
	}
	printf("ERROR: %d not found\n", tomatu);
	exit(2);
	return 0;
}

#define MOD_BY 1000000007

int add(int a, int b) {
	return a + b - MOD_BY * (a + b >= MOD_BY);
}

int memo[114514][128];

int search(int pos, int current) {
	int answer = 0;
	int i;
	if (pos >= N) return yakusu[current] == 1;
	if (memo[pos][current]) return ~memo[pos][current];
	for (i = 0; i < ayane[current]; i++) {
		int next = yukachi(yakusu[current] / yakusu[asumi[current][i]]);
		answer = add(answer, search(pos + 1, next));
	}
	return ~(memo[pos][current] = ~answer);
}

int main(void) {
	int i, j;
	if (scanf("%d%d", &N, &M) != 2) return 1;
	yakusu[0] = 1;
	yakusu[1] = M;
	yc = 2;
	for (i = 2; i * i <= M; i++) {
		if (M % i == 0) {
			yakusu[yc++] = i;
			if (M / i != i) yakusu[yc++] = M / i;
			if (yc >= 125) {
				printf("ERROR: too many dividers!\n");
				return 2;
			}
		}
	}
	qsort(yakusu, yc, sizeof(*yakusu), cmp);
	for (i = 0; i < yc; i++) {
		for (j = 0; j < yc; j++) {
			if (yakusu[i] % yakusu[j] == 0) {
				asumi[i][ayane[i]++] = j;
			}
		}
	}
	printf("%d\n", search(0, yukachi(M)));
	return 0;
}