package main

import (
	"fmt"
	"log"
	"math/big"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Count struct {
	Two int64
}

func dropTwoAndFive(n int64, cnt *Count) int64 {
	for n%2 == 0 {
		n /= 2
		cnt.Two++
	}
	for n%5 == 0 {
		n /= 5
		cnt.Two--
	}
	return n
}

func Recover(n *big.Int, cnt *Count) {
	if cnt.Two > 0 {
		for cnt.Two > 0 {
			n = n.Mul(n, big.NewInt(2))
			cnt.Two--
		}

	} else if cnt.Two < 0 {
		for cnt.Two < 0 {
			n = n.Mul(n, big.NewInt(5))
			cnt.Two++
		}
	}
}

func fact(c chan<- *big.Int, begin, end int64, cnt *Count, wg *sync.WaitGroup) {
	defer wg.Done()
	f := big.NewInt(1)
	//start specail cond.
	if begin == 0 {
		begin = 1
	}
	if begin >= end {
		c <- f
		return
	}
	for i := begin; i < end; i++ {
		f = f.Mul(f, big.NewInt(dropTwoAndFive(i, cnt)))
	}
	c <- f
}

func Factorial(c chan int64, n int64, w *sync.WaitGroup) {
	//wait get result
	defer w.Done()
	var wg sync.WaitGroup
	NUM := int64(4)

	f := big.NewInt(1)

	per := n / NUM

	channels := make([]chan *big.Int, NUM+1)
	cnts := make([]Count, NUM+1)

	wg.Add(int(NUM + 1))
	for i := int64(0); i < NUM; i++ {
		channels[i] = make(chan *big.Int, 1)
		go fact(channels[i], i*per, (i+1)*per, &(cnts[i]), &wg)
	}

	channels[NUM] = make(chan *big.Int, 1)
	go fact(channels[NUM], NUM*per, n+1, &(cnts[NUM]), &wg)

	//wait all calc channel
	wg.Wait()

	//slice to get result
	done := 0
	for {
		select {
		case res, ok := <-channels[0]:
			if ok {
				//log.Printf("channel[%d]res:%v\n", 0, res)
				if res.Cmp(big.NewInt(1)) != 0 {
					f = f.Mul(f, res)
				}
				close(channels[0])
				done++
			}

		case res, ok := <-channels[1]:
			if ok {
				//log.Printf("channel[%d]res:%v\n", 1, res)
				if res.Cmp(big.NewInt(1)) != 0 {
					f = f.Mul(f, res)
				}
				close(channels[1])
				done++
			}

		case res, ok := <-channels[2]:
			if ok {
				//log.Printf("channel[%d]res:%v\n", 2, res)
				if res.Cmp(big.NewInt(1)) != 0 {
					f = f.Mul(f, res)
				}
				close(channels[2])
				done++
			}
		case res, ok := <-channels[3]:
			if ok {
				//log.Printf("channel[%d]res:%v\n", 3, res)
				if res.Cmp(big.NewInt(1)) != 0 {
					f = f.Mul(f, res)
				}
				close(channels[3])
				done++
			}
		case res, ok := <-channels[4]:
			if ok {
				//log.Printf("channel[%d]res:%v\n", 4, res)
				if res.Cmp(big.NewInt(1)) != 0 {
					f = f.Mul(f, res)
				}
				close(channels[4])
				done++
			}

		}
		if int64(done) == (NUM + 1) {
			break
		}
	}
	//recover
	sum := int64(0)
	for _, cnt := range cnts {
		sum += cnt.Two
	}
	//log.Println("sum(2):", sum, "\torigin:", f)

	Recover(f, &Count{sum})
	s := f.String()
	if len(s) > 9 {
		s = s[len(s)-9:]
	}
	result, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		log.Fatal(err)
	}
	c <- result
}

func TrimZero(n *big.Int) {
	s := strings.TrimRight(n.String(), "0")
	var ok bool
	n, ok = n.SetString(s, 10)
	if !ok {
		log.Fatal("convert failed!")
	}
}

func main() {
	n := int64(0)
	fmt.Scanln(&n)

	start := time.Now()
	var wg sync.WaitGroup
	wg.Add(1)
	//cnt := new(Count)
	c := make(chan int64, 1)
	//go fact(c, 1, n, cnt, &wg)
	go Factorial(c, n, &wg)
	wg.Wait()

	fmt.Println(<-c, "time:", time.Now().Sub(start).Seconds())
	close(c)
}