Problem:
Score : 400 points

Problem Statement

Given are positive integers A and B.

Let us choose some number of positive common divisors of A and B.

Here, any two of the chosen divisors must be coprime.

At most, how many divisors can we choose?

Definition of common divisor

An integer d is said to be a common divisor of integers x and y when d divides both x and y.

Definition of being coprime

Integers x and y are said to be coprime when x and y have no positive common divisors other than 1.

Definition of dividing

An integer x is said to divide another integer y when there exists an integer \alpha such that y = \alpha x.

Constraints

All values in input are integers.

1 \leq A, B \leq 10^{12}

Input

Input is given from Standard Input in the following format:

A B

Output

Print the maximum number of divisors that can be chosen to satisfy the condition.

Sample Input 1

12 18

Sample Output 1

3

12 and 18 have the following positive common divisors: 1, 2, 3, and 6.

1 and 2 are coprime, 2 and 3 are coprime, and 3 and 1 are coprime, so we can choose 1, 2, and 3, which achieve the maximum result.

Sample Input 2

420 660

Sample Output 2

4

Sample Input 3

1 2019

Sample Output 3

1

1 and 2019 have no positive common divisors other than 1.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

//#include "stdafx.h"
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;

/*----------------------------------------------------------------------------- 
	定義
-------------------------------------------------------------------------------*/
#define REP(i, n) for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n) for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define REP_REV(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (int (i) = (int)(n) - 1 ; (i) >= m ; --(i))
#define INF			2e9
#define MOD			1e9+7
#define MIN(a, b)	((a) < (b) ? a : b)
#define MAX(a, b)	((a) > (b) ? a : b)

typedef long long int QWORD;
typedef long long int ll;

/*-----------------------------------------------------------------------------
	処理
-------------------------------------------------------------------------------*/
bool IsPrime(QWORD num)
{
	if (num <= 2) return true;

	QWORD sqrtNum = sqrt(num);
	for (QWORD i = 2; i <= sqrtNum; i++) {
		if (num % i == 0) {
			// 素数ではない
			return false;
		}
	}

	// 素数である
	return true;
}


QWORD gcd(QWORD a, QWORD b)
{
	QWORD r;

	r = a % b;
	while (r != 0) {
		a = b;
		b = r;
		r = a % b;
	}
	return b;
}


int main()
{
	QWORD A;
	QWORD B;

	// 最大公約数
	cin >> A;
	cin >> B;

#if 0
	QWORD maxYakusu;
	vector<QWORD>	yakusuA;
	vector<QWORD>	yakusuB;
	
	maxYakusu = sqrt(A);
	for (QWORD i = 1; i <= maxYakusu; i++) {
		if ((A % i) == 0) {
			if (IsPrime(i)) {
				yakusuA.push_back(i);
			}
			if (IsPrime(A / i)) {
				if (i != (A / i)) {
					yakusuA.push_back(A / i);
				}
			}
		}
	}
	reverse(yakusuA.begin(), yakusuA.end());

	maxYakusu = sqrt(B);
	for (QWORD i = 1; i <= maxYakusu; i++) {
		if ((B % i) == 0) {
			if (IsPrime(i)) {
				yakusuB.push_back(i);
			}
			if (IsPrime(B / i)) {
				if (i != (B / i)) {
					yakusuB.push_back(B / i);
				}
			}
		}
	}
	reverse(yakusuB.begin(), yakusuB.end());

	QWORD cnt = 0;
	QWORD nextPos = 0;
	for (QWORD i = 0; i < yakusuA.size(); i++) {
		QWORD	yakusuOne = yakusuA[i];
		for (QWORD j = nextPos; j < yakusuB.size(); j++) {
			if (yakusuOne < yakusuB[j]) {
				// continue
			} else if (yakusuOne == yakusuB[j]) {
				nextPos = j + 1;
				cnt++;
				break;
			} else {
				nextPos = j;
				break;
			}
		}
	}

#else
	QWORD maxYaksuu = gcd(A, B);

	// 素数をカウント
	QWORD cnt = 1;
	QWORD sqrtNum = sqrt(maxYaksuu);
	for (int i = 2; i <= sqrtNum; i++) {
		if ((maxYaksuu % i) == 0) {
			if (IsPrime(i)) {
				cnt++;
			}
			if (i != (maxYaksuu / i)) {
				if (IsPrime((maxYaksuu / i))) {
					cnt++;
				}
			}
		}
	}
#endif

	cout << cnt;
	return 0;
}