output_description: Print the number of choices of K in which N becomes 1 in the end.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
attempt: def gcd(a, b):
      while b:
          a, b = b, a % b
      return a
  
  
  def isPrimeMR(n):
      d = n - 1
      d = d // (d & -d)
      L = (
          [2, 7, 61]
          if n < 1 << 32
          else (
              [2, 3, 5, 7, 11, 13, 17]
              if n < 1 << 48
              else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
          )
      )
      for a in L:
          t = d
          y = pow(a, t, n)
          if y == 1:
              continue
          while y != n - 1:
              y = y * y % n
              if y == 1 or t == n - 1:
                  return 0
              t <<= 1
      return 1
  
  
  def findFactorRho(n):
      m = 1 << n.bit_length() // 8
      for c in range(1, 99):
          f = lambda x: (x * x + c) % n
          y, r, q, g = 2, 1, 1, 1
          while g == 1:
              x = y
              for i in range(r):
                  y = f(y)
              k = 0
              while k < r and g == 1:
                  ys = y
                  for i in range(min(m, r - k)):
                      y = f(y)
                      q = q * abs(x - y) % n
                  g = gcd(q, n)
                  k += m
              r <<= 1
          if g == n:
              g = 1
              while g == 1:
                  ys = f(ys)
                  g = gcd(abs(x - ys), n)
          if g < n:
              if isPrimeMR(g):
                  return g
              elif isPrimeMR(n // g):
                  return n // g
              return findFactorRho(g)
  
  
  def primeFactor(n):
      i = 2
      ret = {}
      rhoFlg = 0
      while i * i <= n:
          k = 0
          while n % i == 0:
              n //= i
              k += 1
          if k:
              ret[i] = k
          i += i % 2 + (3 if i % 3 == 1 else 1)
          if i == 101 and n >= 2**20:
              while n > 1:
                  if isPrimeMR(n):
                      ret[n], n = 1, 1
                  else:
                      rhoFlg = 1
                      j = findFactorRho(n)
                      k = 0
                      while n % j == 0:
                          n //= j
                          k += 1
                      ret[j] = k
  
      if n > 1:
          ret[n] = 1
      if rhoFlg:
          ret = {x: ret[x] for x in sorted(ret)}
      return ret
  
  
  def divisors(N):
      pf = primeFactor(N)
      ret = [1]
      for p in pf:
          ret_prev = ret
          ret = []
          for i in range(pf[p] + 1):
              for r in ret_prev:
                  ret.append(r * (p**i))
      return sorted(ret)
  
  
  def calc(n, k):
      if n % k == 0:
          return n // k
      return n % k
  
  
  def chk(n, k):
      while n >= k:
          n = calc(n, k)
      return 1 if n == 1 else 0
  
  
  N = int(input())
  L = list(set(divisors(N) + divisors(N - 1)))
  print(len([l for l in L if l > 1 and chk(N, l)]))
  
problem_description: Statement
  
  Given is a positive integer N.
  
  We will choose an integer K between 2 and N (inclusive), then we will repeat
  the operation below until N becomes less than K.
  
    * Operation: if K divides N, replace N with N/K; otherwise, replace N with N-K.
  
  In how many choices of K will N become 1 in the end?
samples: [{"input": "6", "output": "3\n    \n\nThere are three choices of K in which N becomes 1 in the end: 2, 5, and 6.\n\nIn each of these choices, N will change as follows:\n\n  * When K=2: 6 \\to 3 \\to 1\n  * When K=5: 6 \\to 1\n  * When K=6: 6 \\to 1\n\n* * *"}, {"input": "3141", "output": "13\n    \n\n* * *"}, {"input": "314159265358", "output": "9"}]