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 Ruby (2.3.3) (judge verdict: Accepted)

#a = gets.split(" ").map{|x| x.to_i}
=begin
n = gets.to_i
count = 0
n.times do |i|
  if((i + 1) % 2 == 1)
    count += 1
  end
end
p count.to_f / n.to_f
=end

=begin
nk = gets.split(" ").map{|x| x.to_i}
N = nk[0]
K = nk[1]

h = gets.split(" ").map{|x| x.to_i}
count = 0

N.times do |i|
  if(K <= h[i])
    count += 1
  end
end
p count
=end

=begin
N = gets.to_i
a = gets.split(" ").map{|x| x.to_i}

array = Array.new(N)
N.times do |i|
  array[a[i] - 1] = i + 1
end
N.times do |i|
  print "#{array[i]} "
end
=end

require 'prime'

#約数を求めるやつ
class Integer
  def my_divisor_list3
    return [1] if self == 1
    first, *rest = Prime.prime_division(self).map do |p, k|
      (0..k).map{|i| p**i}
    end
    first.product(*rest).map do |a|
      a.inject(&:*)
    end.sort
  end
end

ab = gets.split(" ").map{|x| x.to_i}
A = ab[0]
B = ab[1]
#aとbの約数を求める
a_yakusu = A.my_divisor_list3
b_yakusu = B.my_divisor_list3

#配列の論理積で公約数を出す(なぜ出るかは謎)
koyakusu = a_yakusu & b_yakusu
=begin
ans = Array.new()
koyakusu2 = koyakusu
(koyakusu.size).times do |i|
  #break if(koyakusu[-(i + 1)] < koyakusu[-1]**(0.5))
  hoge = koyakusu[-(i + 1)].my_divisor_list3 & koyakusu
  if hoge.size <= 2
    ans.push(koyakusu[-(i + 1)])
  end
end
p ans
=end
i = 1
while(true)
  list = Array.new()
  for j in (i + 1)..(koyakusu.size - 1) do
    if(koyakusu[j] % koyakusu[i] == 0)
      list.push(koyakusu[j])
    end
  end

  list.each do |item|
    koyakusu.delete(item)
  end
  i += 1
  break if(i >= koyakusu.size)
end
p koyakusu.size