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::cmp::*;
use std::collections::HashSet;
use std::io::*;
use std::num::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn string() -> String {
    read()
}

fn int() -> i64 {
    read()
}

fn char() -> char {
    read::<String>().pop().unwrap()
}

fn vecchar() -> Vec<char> {
    string().chars().collect()
}

fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let n = int();

    let mut divisor = HashSet::new();

    let mut l = 1;
    while l * l <= n {
        if n % l == 0 {
            divisor.insert(l);
            divisor.insert(n / l);
        }
        l += 1;
    }

    let mut mdivisor = HashSet::new();
    let m = n - 1;
    let mut l = 1;
    while l * l <= m {
        if m % l == 0 {
            mdivisor.insert(l);
            mdivisor.insert(m / l);
        }
        l += 1;
    }

    divisor.remove(&1);
    //println!("{:?}", divisor);

    mdivisor.remove(&1);
    //println!("{:?}", mdivisor);

    for d in divisor {
        let mut k = n;
        while k % d == 0 {
            k = k / d;
        }
        if k == 1 || k % d == 1 {
            mdivisor.insert(d);
        }
    }
    //println!("{:?}", mdivisor);
    println!("{}", mdivisor.len())
}