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

#[allow(unused_macros)]
macro_rules! input {
	(source = $s:expr, $($r:tt)*) => {
		let mut iter = $s.split_whitespace();
		input_inner!{iter, $($r)*}
	};
	($($r:tt)*) => {
		let s = {
			use std::io::Read;
			let mut s = String::new();
			std::io::stdin().read_to_string(&mut s).unwrap();
			s
		};
		let mut iter = s.split_whitespace();
		input_inner!{iter, $($r)*}
	};
}
#[allow(unused_macros)]
macro_rules! input_inner {
	($iter:expr) => {};
	($iter:expr, ) => {};

	($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
		let $var = read_value!($iter, $t);
		input_inner!{$iter $($r)*}
	};
}
#[allow(unused_macros)]
macro_rules! read_value {
	($iter:expr, ( $($t:tt),* )) => {
		( $(read_value!($iter, $t)),* )
	};

	($iter:expr, [ $t:tt ; $len:expr ]) => {
		(0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
	};

	($iter:expr, chars) => {
		read_value!($iter, String).chars().collect::<Vec<char>>()
	};

	($iter:expr, usize1) => {
		read_value!($iter, usize) - 1
	};

	($iter:expr, $t:ty) => {
		$iter.next().unwrap().parse::<$t>().expect("Parse error")
	};
}

fn gcd(a: i64, b: i64) -> i64 {
	if b == 0 { a }
	else 	{ gcd(b, a%b) }
}

fn dfs(s: usize, graph: &Vec<Vec<usize>>, used: &mut Vec<bool>) {
	used[s] = true;
	for g in &graph[s] {
		if !used[*g] { 
			dfs(*g, graph, used);
		}
	}
}

fn main(){
	input! {
		a: i64,
		b: i64,
	}
	let mut ab = gcd(a, b);
	let mut i = 2;
	let mut ans = 1;
	'outer: while i*i <= ab {
		if ab%i == 0 {
			ans += 1;
			while ab%i == 0 {
				ab /= i;
				if ab == 1 { break 'outer; }
			}
		}
		i += 1;
	}
	if ab != 1 { ans += 1; }
	println!("{}", ans);
	// let mut comv = Vec::new();
	// let mut i = 1;
	// while i*i <= a && i*i <= b { 
	// 	if a%i == 0 && b%i == 0 { 
	// 		comv.push(i); 
	// 		if i != a/i && b%(a/i) == 0{
	// 			comv.push(a/i); 
	// 		}
	// 	}
	// 	i += 1;
	// }
	// let mut graph = vec![vec![]; comv.len()];
	// for i in 0..comv.len() {
	// 	for j in i+1..comv.len() { 
	// 		if gcd(comv[i], comv[j]) == 1 {
	// 			graph[i].push(j);
	// 			graph[j].push(i);
	// 		}
	// 	}
	// }
	// let mut ans = 0;
	// let mut used = vec![false; comv.len()];
	// for i in 0..comv.len() {
	// 	if !used[i] {
	// 		dfs(i, &graph, &mut used);
	// 		ans += 1;
	// 	}
	// }
	// println!("{}", ans);
	// println!("{:?}", comv);
	// println!("{:?}", graph);
}