Problem:
Score : 600 points

Problem 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?

Constraints

2 \leq N \leq 10^{12}

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of choices of K in which N becomes 1 in the end.

Sample Input 1

6

Sample Output 1

3

There are three choices of K in which N becomes 1 in the end: 2, 5, and 6.

In each of these choices, N will change as follows:

When K=2: 6 \to 3 \to 1

When K=5: 6 \to 1

When K=6: 6 \to 1

Sample Input 2

3141

Sample Output 2

13

Sample Input 3

314159265358

Sample Output 3

9

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io;
use std::str::FromStr;

fn input<T:FromStr>() -> T {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().parse().ok().unwrap()
}

fn divisors(n: u64) -> Vec<u64> {
    let mut divisors: Vec<u64> = Vec::new();
    for i in 1..n {
        if i * i > n {
            break;
        }
        if n % i == 0 {
            if i != 1 {
                divisors.push(i);
            }
            if i * i != n {
                divisors.push(n / i);
            }
        }
    }
    divisors
}

fn main() {
    let n: u64 = input();
    let mod1_vec = divisors(n - 1);
    let mod0_vec = divisors(n);
    // println!("{:?}", mod0_vec);
    // println!("{:?}", mod1_vec);
    let mut count = 0usize;
    for m0 in mod0_vec {
        let mut buf = n;
        while buf % m0 == 0 {
            buf /= m0;
        }
        if buf % m0 == 1 {
            count += 1;
        }
        // println!("{}, {}, {}", buf, m0, buf%m0);
    }
    println!("{}", mod1_vec.len() + count);
}