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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeFamilies #-}
import           Data.Maybe
import           Data.Int
import           Data.List
import           Data.Char
-- import qualified Data.Vector.Unboxing as VU
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8 as BS
import           Data.List (scanl')
import           Data.IORef
import           Control.Monad
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Control.Applicative
import           Debug.Trace
import           Text.Printf


readInt = BS.readInt . BS.dropWhile isSpace
getVector f = VU.unfoldr f <$> BS.getLine
getIntVector = getVector readInt
getBSVector = getVector BS.uncons
getInt = readLn :: IO Int
getInt2Tuple = (\vec -> (vec VU.! 0, vec VU.! 1)) <$> getIntVector
getInt3Tuple = (\vec -> (vec VU.! 0, vec VU.! 1, vec VU.! 2)) <$> getIntVector


main = do
  (a,b) <- getInt2Tuple
  print . length $ solve a b

divisor n = loop 1
  where
    loop d
      | n < d^2 = []
      | n == d^2 = [d]
      | otherwise = if r == 0 then d : q : loop (d+1) else loop (d+1)
      where (q,r) = n `divMod` d

divisorTow a b = sort $ loop 1
  where
    minAB = min a b
    loop d
      | minAB < d^2 = []
      | minAB == d^2 = if ra == 0 && rb == 0 then [d] else []
      | otherwise = if ra == 0 && rb == 0
                    then case (bModqa, aModqb) of (0,0) -> d : qa : qb : loop (d+1)
                                                  (0,_) -> d : qa : loop (d+1)
                                                  (_,0) -> d : qb : loop (d+1)
                                                  (_,_) -> d : loop (d+1)
                    else case (bModqa, aModqb) of (0,0) -> qa : qb : loop (d+1)
                                                  (0,_) -> qa : loop (d+1)
                                                  (_,0) -> qb : loop (d+1)
                                                  (_,_) -> loop (d+1)
      where
        (qa,ra) = a `divMod` d
        (qb,rb) = b `divMod` d
        bModqa = b `mod` qa
        aModqb = a `mod` qb

disjoint [] = []
disjoint (1:xs) = 1 : disjoint (filter (/= 1) xs)
disjoint (x:xs) = x : disjoint (filter (\n -> n `mod` x /= 0) xs)

solve a b = disjoint $ divisorTow a b