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

#[allow(unused_macros)]
macro_rules! input {
    ( $($t:ty),* ) => {{
        let mut s = String::new();
        std::io::stdin().read_line(&mut s);
        let mut splits = s.trim().split_whitespace();
        ($( { splits.next().unwrap().parse::<$t>().unwrap() },)*)
    }}
}

#[allow(dead_code)]
pub fn gcd(n: u64, m: u64) -> u64 {
    match (n, m) {
        (0, 0) => return 0,
        (0, _) => return 0,
        (_, 0) => return 0,
        (n, m) => {
            let r = n % m;
            if r == 0 {
                m
            } else {
                gcd(m, r)
            }
        }
    }
}


#[allow(dead_code)]
fn prime_factorization(n: u64) -> std::collections::HashMap<u64, u32> {
    let primes = primes((n / 2) + 2);
    let mut h = std::collections::HashMap::new();
    let mut current = n;
    while current != 1 {
        let mut found = false;
        for p in &primes {
            if current % p == 0 {
                let count = h.entry(*p).or_insert(0);
                *count += 1;
                current /= *p;
                found = true;
            }
        }
        if !found {
            let count = h.entry(n).or_insert(0);
            *count += 1;
            break;
        }
    }
    return h;
}


#[allow(dead_code)]
fn primes(n: u64) -> Vec<u64> {
    if n < 3 {
        return vec![];
    }
    let mut res: Vec<u64> = vec![2];
    for i in 3..n {
        let i = i as u64;
        let root = ((n as f64).sqrt().ceil() as usize + 1) as u64;
        let composite = res.iter().take_while(|&&x| x <= root).any(|x| i % x == 0);
        if !composite {
            res.push(i);
        }
    }
    return res;
}

#[allow(unused_must_use)]
#[allow(unused_variables)]
fn solve() {
    let (a, b) = input!(u64, u64);

    let gcd = gcd(a, b);
    let ps = prime_factorization(gcd);
    let set: std::collections::HashSet<_> = ps.iter().collect();

    println!("{}", set.len() + 1);
}

fn main() {
    solve();
}