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 Go (1.6) (judge verdict: Accepted)

package main

import (
        "bufio"
        "fmt"
        "math/big"
        "os"
        "strconv"
        "strings"
)

var sc = bufio.NewScanner(os.Stdin)

func readInt() int              { return readIntArray()[0] }
func readInt2() (int, int)      { a := readIntArray(); return a[0], a[1] }
func readInt3() (int, int, int) { a := readIntArray(); return a[0], a[1], a[2] }
func readIntArray() []int {
        a := make([]int, 0, 1000)
        sc.Scan()
        for _, v := range strings.Split(sc.Text(), " ") {
                vv, _ := strconv.Atoi(v)
                a = append(a, vv)
        }
        return a
}
func readString() string        { return readStringArray()[0] }
func readStringArray() []string { sc.Scan(); return strings.Split(sc.Text(), " ") }

func main() {
        n := big.NewInt(int64(0))
        n.SetString(readString(), 10)

        if n.Cmp(big.NewInt(int64(10))) == -1 {
                fmt.Println(0)
                return
        }

        m := big.NewInt(int64(0))
        if m.Mod(n, big.NewInt(int64(2))).Cmp(big.NewInt(int64(0))) != 0 {
                fmt.Println(0)
                return
        }

        base := big.NewInt(int64(10))
        count := big.NewInt(int64(0))
        for i := 0; i < 10000000; i++ {
                tmp := new(big.Int)
                tmp.Div(n, base)
                if tmp.Cmp(big.NewInt(int64(0))) == 0 {
                        break
                }
                count.Add(count, tmp)
                base.Mul(base, big.NewInt(int64(5)))
        }

        fmt.Println(count)

}