Problem:
Score : 500 points

Problem Statement

For an integer n not less than 0, let us define f(n) as follows:

f(n) = 1 (if n < 2)

f(n) = n f(n-2) (if n \geq 2)

Given is an integer N. Find the number of trailing zeros in the decimal notation of f(N).

Constraints

0 \leq N \leq 10^{18}

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of trailing zeros in the decimal notation of f(N).

Sample Input 1

12

Sample Output 1

1

f(12) = 12 × 10 × 8 × 6 × 4 × 2 = 46080, which has one trailing zero.

Sample Input 2

5

Sample Output 2

0

f(5) = 5 × 3 × 1 = 15, which has no trailing zeros.

Sample Input 3

1000000000000000000

Sample Output 3

124999999999999995

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

use std::cmp::min;

macro_rules! extract {
    (String, $iter:expr) => {
        $iter.next().unwrap().trim().to_owned()
    };
    ($t:tt, $iter:expr) => {
        $iter.next().unwrap().trim().parse::<$t>().unwrap()
    };
}

macro_rules! read_split_impl {
    ( $e:expr, $( $t:tt ),* ) => {{
        let mut s = String::new();
        $e.read_line(&mut s).unwrap();
        let s = s.trim_right();
        let mut iter = s.split_whitespace();
        ( $(extract!($t, iter)),* )
    }};
}

macro_rules! read_split {
    ( $( $t:tt ),* ) => {
        read_split_impl!(std::io::stdin(), $($t),* )
    };
}

fn index_of_factorial(n: u64, base: u64) -> u64 {
    let mut power = base;
    let mut result = 0;
    loop {
        let q = n / power;
        if q == 0 {
            break;
        }
        result += q;
        if let Some(p) = power.checked_mul(base) {
            power = p;
        } else {
            break;
        }
    }
    result
}

fn solve(n: u64) -> u64 {
    if n % 2 == 0 {
        let n = n / 2;
        let n2 = index_of_factorial(n, 2);
        let n5 = index_of_factorial(n, 5);
        min(n2 + n, n5)
    } else {
        let n2 = index_of_factorial(n, 2);
        let n5 = index_of_factorial(n, 5);

        let m = n / 2;
        let m2 = index_of_factorial(m, 2);
        let m5 = index_of_factorial(m, 5);
        min(n2 - m2 - m, n5 - m5)
    }
}

fn main() {
    let n = read_split!(u64);

    print!("{}", solve(n));
}