output_description: Print the maximum number of divisors that can be chosen to satisfy the
  condition.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      A B
attempt: #!/usr/bin/env python
  import os
  import sys
  from io import BytesIO, IOBase
  from typing import List
  from math import gcd
  
  
  def get_common_divisors(a: int, b: int) -> List[int]:
      i = 1
      ret = []
      # print(a, b)
      while i * i <= a:
          # print(i)
          if a % i == 0 and b % i == 0:
              ret.append(i)
              other = a // i
              if i == other:
                  i += 1
                  continue
              if a % other == 0 and b % other == 0:
                  ret.append(other)
          i += 1
  
      ret.sort()
      return ret
  
  
  def main() -> None:
      a, b = map(int, input().split())
      if a > b:
          a, b = b, a
  
      divisors = get_common_divisors(a, b)
      ret = []
  
      for div in divisors:
          ok = True
          for i in ret:
              if gcd(i, div) != 1:
                  ok = False
                  break
          if ok:
              ret.append(div)
  
      print(len(ret))
  
  
  # region fastio
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self, **kwargs):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # endregion
  
  if __name__ == "__main__":
      main()
  
problem_description: 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.
samples: [{"input": "12 18", "output": "3\n    \n\n12 and 18 have the following positive common divisors: 1, 2, 3, and 6.\n\n1 and 2 are coprime, 2 and 3 are coprime, and 3 and 1 are coprime, so we can\nchoose 1, 2, and 3, which achieve the maximum result.\n\n* * *"}, {"input": "420 660", "output": "4\n    \n\n* * *"}, {"input": "1 2019", "output": "1\n    \n\n1 and 2019 have no positive common divisors other than 1."}]