package main

import "fmt"

func main() {
	var n,k int
	fmt.Scanf("%d%d",&n,&k)
	remain := 240 - k
	sum := 0
	var ans int = 0
	for var i int = 1;i<=n&&sum<=remain;i++{
		sum += 5*i
		if sum<=remain
			ans = i
	}
	fmt.Println(ans)
}


package "main"

import "fmt"

func main() {
    var n,k int
    fmt.Scanf("%d%d", &n, &k)
    for i := 1; i <= n; i++ {
        if 5 * i * (i + 1) / 2 + k > 240 {
            fmt.Println(i - 1)
            return
        }
    }
    fmt.Println(n)
}


package "main"

import "fmt"

func main() {
    var n,k int
    fmt.Scanf("%d%d", &n, &k)
    for i := 0; i < n; i++ {
        if 5 * i * (i + 1) / 2 + k > 360 {
            fmt.Println(i)
            return
        }
    }
    fmt.Println(n)
}


package "main"

import "fmt"

func main() {
    var n,k int
    fmt.Scanf("%d%d", &n, &k)
    for i := 0; i < n; i++ {
        if (5 * i * (i + 1) / 2 + k > 360) {
            fmt.Println(i)
            return
        }
    }
    fmt.Println(n)
}


package main

import (
        "bufio"
        "fmt"
        "os"
        "strconv"
)

func solve() {
    n, k := readInt(), readInt()
    cur := 4*60-k
    ans := 0
    for i := 1; i <= n; i++ {
        cur -= 5*i
        if cur >= 0 {
            ans++
        }
    }
    fmt.Println(ans)
}

// Helpers

var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)

func main() {
        const MaxTokenLength = 1024 * 1024
        scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
        scanner.Split(bufio.ScanWords)
        solve()
}

// Helpers

var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)

func main() {
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

// Math

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

// IO

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}

func readIntArray(sz int) []int {
	a := make([]int, sz)
	for i := 0; i < sz; i++ {
		a[i] = readInt()
	}
	return a
}

func readInt64Array(n int) []int64 {
	res := make([]int64, n)
	for i := 0; i < n; i++ {
		res[i] = readInt64()
	}
	return res
}

// Sort

type Ints64 []int64

func (a Ints64) Len() int           { return len(a) }
func (a Ints64) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a Ints64) Less(i, j int) bool { return a[i] < a[j] }

/* Sort tempalte
func (a ) Len() int           { return len(a) }
func (a ) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ) Less(i, j int) bool { return  }
*/


package main

import (
	"fmt"
)

func solve339a() {
	// digits can only be {1,2,3}
	// input is <= 100 characters
	// no spaces
	// digit and/or plus sign
	// could be a single character(digit)

	// if we use sorting in stdlib, then parse by "+", sort, and join with "+"

	// if we implement sorting, a good constraint is that numbers are {1,2,3}.

	// count 1, 2 and 3 digits in a map(nah just variables)
	// create a string with "+" between each counted digit if sum of count > 1
	// else just print

	equation := ""
	fmt.Scan(&equation)

	one := 0
	two := 0
	three := 0

	for _, c := range equation {
		switch c {
		case '1':
			one++
		case '2':
			two++
		case '3':
			three++
		}
	}

	if one+two+three <= 1 {
		fmt.Println(equation)
	} else {
		result := ""
		result = appendNumber(result, one, 1)
		result = appendNumber(result, two, 2)
		result = appendNumber(result, three, 3)
		result = result[:len(result)-1]
		fmt.Println(result)
	}
}

func appendNumber(result string, count, num int) string {
	for count > 0 {
		result += fmt.Sprintf("%d+", num)
		count--
	}
	return result
}


package main

import (
	"fmt"
	"strings"
	"math/rand"
	"sort"
	"sync"
)

const MAX = 3

func Sort(A []int, N int) []int {
	q := len(A) / N
	r := len(A) % N
	splits := make([][]int, N)
	pos := 0
	for i := 0; i < N; i++ {
		var delta int
		if i < r {
			delta = q + 1;
		} else {
			delta = q;
		}
		splits[i] = A[pos : pos + delta]
		pos += delta
	}
	waitGroup := new(sync.WaitGroup)
	for i := 0; i < N; i++ {
		waitGroup.Add(1)
		go func(B []int) {
			sort.Ints(B)
			waitGroup.Done()
		}(splits[i])
	}
	waitGroup.Wait()
	B := make([]int, 0);
	next := make([]int, N)
	for len(B) < len(A) {
		idx := -1
		for i := 0; i < N; i++ {
			if next[i] < len(splits[i]) && (idx == -1 || splits[i][next[i]] < splits[idx][next[idx]]) {
				idx = i
			}
		}
		B = append(B, splits[idx][next[idx]])
		next[idx]++
	}
	return B
}

func main() {
	var input string
	fmt.Scanln(&input)
	digits := strings.Split(input, "+")
	ints := make([]int, 0)
	for i := 0; i < len(digits); i++ {
		ints = append(ints, int(digits[i][0]) - '0')
	}
	N := rand.Intn(len(A)) + 1
	ints = Sort(ints, N)
	for i := 0; i < len(ints); i++ {
		if i > 0 {
			fmt.Print("+")
		}
		fmt.Print(ints[i])
	}
	fmt.Println()
}


package main

import "fmt"

func main() {
    var n int64
    fmt.Scanf("%d", &n)
    r := int64(0)
    for i := 2; i < n/2; i+=2 {
        r += 1
    }
    fmt.Println(r)
}


func main() {
	var (
		n, m, a int
	)
	fmt.Scanln(&n, &m, &a)
	if n % a != 0 {
		n = ((n / a) + 1)
	}
	if m % a != 0 {
		m = ((m / a) + 1)
	}
	fmt.Println(n*m)
}


package main

import (
    "fmt"
    "math"
)

func main() {
  var n, m , a, ndiva, mdiva float64

  fmt.Scanf("%f %f %f", &n, &m, &a)

/*
  if n % a == 0 {
    ndiva = n / a
  } else {
    ndiva = n / a + 1
  }

  if m % a == 0 {
    mdiva = m / a
  } else {
    mdiva = m / a + 1
  }
*/

  fmt.Println(math.Ceil(n / a) * math.Ceil(m / a))

  //fmt.Println(ndiva * mdiva)
}


func main() {
    var a int
    var m int
    var n int
    fmt.Scanf("%d %d %d", &m, &n, &a)
    // fmt.Println("m:",m)
    // fmt.Println("n:",n)
    // fmt.Println("a:",a)
    m = m/a
    n = n/a
    // m = int(float32(m/a) + 0.5)
    // n = int(float32(n/a) + 0.5)
    if m%a!=0 || m==0 {m++}
    if n%a!=0 || n==0 {n++}
    // fmt.Println(m)
    // fmt.Println(n)
    // fmt.Println(m*n)
    // fmt.Println("m:",m)
    // fmt.Println("n:",n)
    fmt.Println(m*n)
}


/*A. Theatre Square
time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Theatre Square in the capital city of Berland has a rectangular shape with the size n × m meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size a × a.

What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.

Input
The input contains three positive integer numbers in the first line: n,  m and a (1 ≤  n, m, a ≤ 109).

Output
Write the needed number of flagstones.

Examples
inputCopy
6 6 4
outputCopy
4
*/

package main

import (
	"fmt"
	"math"
)

func main() {
	var n, m, a float64
	fmt.Scanf("%b %b %b", &n, &m, &a)

	a_in_n_ceil := uint64(math.Ceil(n / a))

	a_in_m_ceil := uint64(math.Ceil(m / a))

	a_in_n_and_m = a_in_n_ceil * a_in_m_ceil

	square_volume := n * m
	flagstone_volume := a * a

	if flagstone_volume >= square_volume {
		a_in_n_and_m = 1
	}

	fmt.Println(a_in_n_and_m)

}


package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
	"strings"
	"fmt"
	"time"
	"log"
	"math"
)

////////////////////////////////////////////////////////////////////////////////

// INPUT TEMPLATE START

type MyInput struct {
	rdr         io.Reader
	lineChan    chan string
	initialized bool
}

func (mi *MyInput) start(done chan struct{}) {
	r := bufio.NewReader(mi.rdr)
	defer func() {
		close(mi.lineChan)
	}()
	for {
		line, err := r.ReadString('\n')
		if !mi.initialized {
			mi.initialized = true
			done <- struct{}{}
		}
		mi.lineChan <- strings.TrimSpace(line)
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}
	}
}

func (mi *MyInput) readLine() string {
	// if this is the first call, initialize
	if !mi.initialized {
		mi.lineChan = make(chan string)
		done := make(chan struct{})
		go mi.start(done)
		<-done
	}

	res, ok := <-mi.lineChan
	if !ok {
		panic("trying to read from a closed channel")
	}
	return res
}

func (mi *MyInput) readInt() int {
	line := mi.readLine()
	i, err := strconv.Atoi(line)
	if err != nil {
		panic(err)
	}
	return i
}

func (mi *MyInput) readInt64() int64 {
	line := mi.readLine()
	i, err := strconv.ParseInt(line, 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func (mi *MyInput) readInts() []int {
	line := mi.readLine()
	parts := strings.Split(line, " ")
	res := []int{}
	for _, s := range parts {
		tmp, err := strconv.Atoi(s)
		if err != nil {
			panic(err)
		}
		res = append(res, tmp)
	}
	return res
}

func (mi *MyInput) readInt64s() []int64 {
	line := mi.readLine()
	parts := strings.Split(line, " ")
	res := []int64{}
	for _, s := range parts {
		tmp, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			panic(err)
		}
		res = append(res, tmp)
	}
	return res
}

func (mi *MyInput) readWords() []string {
	line := mi.readLine()
	return strings.Split(line, " ")
}

// INPUT TEMPLATE END

////////////////////////////////////////////////////////////////////////////////

func main() {
	/*tn := time.Now()
	solve([]int64{6, 6, 4})
	log.Println(time.Since(tn))
	return*/
	mi := MyInput{rdr: os.Stdin}
	solve(mi.readInt64s())
	/*
	for caseNo := 1; caseNo <= t; caseNo++ {
		//solve(mi.readLine())
		fmt.Printf("Case #%d: %v\n", caseNo)
	}
	*/
}

func solve(args []int64) {
	w:=args[0]
	h:=args[1]
	p:=args[2]
	wc:=math.Ceil(float64(w)/float64(p))
	hc:=math.Ceil(float64(h)/float64(p))

	fmt.Println(int(wc*hc))

}


package main

import (
	"bufio"
	"fmt"
	"io"
	"strconv"
	"os"
)

func main() {
	n, m, a := s.NextInt(), s.NextInt(), s.NextInt()
	x, y := n / a, m / a
	if n % a != 0 {
		x++
	}
	if m % a != 0 {
		y++
	}
	s.Println(x * y)
	s.Flush()
}

var (
	s *InOut
)

func init() {
	s = NewInOut(os.Stdin, os.Stdout)
}

type InOut struct {
	*bufio.Reader
	*bufio.Writer
}

func NewInOut(r io.Reader, w io.Writer) *InOut {
	return &InOut{bufio.NewReader(r), bufio.NewWriter(w)}
}

// Get Next Integer
func (s *InOut) Next() (r int) {
	b, _ := s.ReadByte()
	p := 1
	for (b < '0' || '9' < b) && b != '-' {
		b, _ = s.ReadByte()
	}
	if b == '-' {
		p = -1
		b, _ = s.ReadByte()
	}
	for '0' <= b && b <= '9' {
		r = 10*r + int(b-'0')
		b, _ = s.ReadByte()
	}
	return r * p
}

// Get Next Line String
func (s *InOut) NextLine() (r string) {
	b, _ := s.ReadByte()
	for b == '\n' {
		b, _ = s.ReadByte()
	}
	buf := make([]byte, 0)
	for ; b != '\n'; b, _ = s.ReadByte() {
		buf = append(buf, b)
	}
	return string(buf)
}

// Get Next String using delimiter whitespace
func (s *InOut) NextStr() (r string) {
	b, _ := s.ReadByte()
	for b == '\n' || b == ' ' {
		b, _ = s.ReadByte()
	}
	buf := make([]byte, 0)
	for ; b != '\n' && b != ' '; b, _ = s.ReadByte() {
		buf = append(buf, b)
	}
	return string(buf)
}

// Print Strings using the suitable way to change type
func (s *InOut) Print(os ...interface{}) {
	for _, o := range os {
		switch o.(type) {
		case byte:
			s.WriteByte(o.(byte))
		case string:
			s.WriteString(o.(string))
		case int:
			s.WriteString(strconv.Itoa(o.(int)))
		case int64:
			s.WriteString(strconv.FormatInt(o.(int64), 10))
		default:
			s.WriteString(fmt.Sprint(o))
		}
	}
}

// Print Strings using the suitable way to change type with new line
func (s *InOut) Println(os ...interface{}) {
	for _, o := range os {
		s.Print(o)
	}
	s.Print("\n")
}

// Print immediately with new line (for debug)
func (s *InOut) PrintlnNow(o interface{}) {
	fmt.Println(o)
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var n, m, a uint64
	fmt.Scan(&n, &m, &a)
	fmt.Println(math.Ceil(n/a) * math.Ceil(m/a))
}


package main
import "fmt"

func main (){
    var m,n,a int
    fmt.scanln(&m,&n,&a)
    fmt.print(((m+a-1)/a)*((n+a-1)/a))
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"strconv"
	"os"
)

func main() {
	n, m, a := s.NextInt64(), s.NextInt64(), s.NextInt64()
	x, y := n / a, m / a
	if n % a != 0 {
		x++
	}
	if m % a != 0 {
		y++
	}
	s.Println(x * y)
	s.Flush()
}

var (
	s *InOut
)

func init() {
	s = NewInOut(os.Stdin, os.Stdout)
}

type InOut struct {
	*bufio.Reader
	*bufio.Writer
}

func NewInOut(r io.Reader, w io.Writer) *InOut {
	return &InOut{bufio.NewReader(r), bufio.NewWriter(w)}
}

// Get Next Integer
func (s *InOut) Next() (r int) {
	b, _ := s.ReadByte()
	p := 1
	for (b < '0' || '9' < b) && b != '-' {
		b, _ = s.ReadByte()
	}
	if b == '-' {
		p = -1
		b, _ = s.ReadByte()
	}
	for '0' <= b && b <= '9' {
		r = 10*r + int(b-'0')
		b, _ = s.ReadByte()
	}
	return r * p
}

func (s *InOut) NextInt64() (r int64) {
	b, _ := s.ReadByte()
	p := 1
	for (b < '0' || '9' < b) && b != '-' {
		b, _ = s.ReadByte()
	}
	if b == '-' {
		p = -1
		b, _ = s.ReadByte()
	}
	for '0' <= b && b <= '9' {
		r = 10*r + int64(b-'0')
		b, _ = s.ReadByte()
	}
	return r * p
}

// Get Next Line String
func (s *InOut) NextLine() (r string) {
	b, _ := s.ReadByte()
	for b == '\n' {
		b, _ = s.ReadByte()
	}
	buf := make([]byte, 0)
	for ; b != '\n'; b, _ = s.ReadByte() {
		buf = append(buf, b)
	}
	return string(buf)
}

// Get Next String using delimiter whitespace
func (s *InOut) NextStr() (r string) {
	b, _ := s.ReadByte()
	for b == '\n' || b == ' ' {
		b, _ = s.ReadByte()
	}
	buf := make([]byte, 0)
	for ; b != '\n' && b != ' '; b, _ = s.ReadByte() {
		buf = append(buf, b)
	}
	return string(buf)
}

// Print Strings using the suitable way to change type
func (s *InOut) Print(os ...interface{}) {
	for _, o := range os {
		switch o.(type) {
		case byte:
			s.WriteByte(o.(byte))
		case string:
			s.WriteString(o.(string))
		case int:
			s.WriteString(strconv.Itoa(o.(int)))
		case int64:
			s.WriteString(strconv.FormatInt(o.(int64), 10))
		default:
			s.WriteString(fmt.Sprint(o))
		}
	}
}

// Print Strings using the suitable way to change type with new line
func (s *InOut) Println(os ...interface{}) {
	for _, o := range os {
		s.Print(o)
	}
	s.Print("\n")
}

// Print immediately with new line (for debug)
func (s *InOut) PrintlnNow(o interface{}) {
	fmt.Println(o)
}


package main
import "fmt"

func main(){
    var n,m,a int
    fmt.Scan(&n,&m,&a)
    var tiles1,tiles2 uint = n/a, m/a

    if(n%a!=0) {tiles1++}
    if(m%a!=0) {tiles2++}

    var hasil uint  = tiles1 * tiles2
    fmt.Println(hasil)
}


package main

import (
  "fmt"
)

func main(){
  var i, j, k int
  fmt.Scanf("%d %d %d\n", &i, &j, &k)
  var int n = i/k
  var int m = j/k
  if n%k!=0{
  n++
  }
  if m%k!=0{
    m++
  }
  fmt.Println(n*m)
}


package main

import "fmt"

func main () {
	var a, b, c int32
	result := 1
	fmt.Scan(&a);
	fmt.Scan(&b);
	fmt.Scan(&c);
	if (a%c == 0) {
		result *= a/c
	} else {
		result *= (a/c)+1
	}
	if (b%c == 0) {
		result *= b/c
	} else {
		result *= (b/c)+1
	}
	fmt.Println(result)
}


// 1a
package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b, c int64
	fmt.Scan(&a, &b, &c)
	fmt.Println ((a-1)/c + 1) * ((b-1)/c + 1)
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var n, m, a float64
	_, err := fmt.Scanf("%f %f %f", &n, &m, &a)
	fmt.Println(math.Ceil(m/a) * math.Ceil(n/a))
}


package main

import (
  "fmt"
)

func main(){
  var i, j, k int
  fmt.Scanf("%d %d %d\n", &i, &j, &k)
  var int n = i/k
  var int m = j/k
  if i%k!=0{
    n++
  }
  if j%k!=0{
    m++
  }
  fmt.Println(n*m)
}


import (
	"fmt"
)

func main() {
	var n, m, a int
	fmt.Scanf("%d %d %d",&n, &m, &a)
	width := n/a+1;
	height := m/a+1;
	fmt.Println(width*height)
}


package main

import (
	"fmt"
)

func main() {
	var n, m, a, result, x1, x2 int64
	fmt.Scan(&n)
	fmt.Scan(&m)
	fmt.Scan(&a)

	if n%a != 0 {
		x1 = (n / a) + 1
	} else {
		x1 = n / a
	}
	if m%a != 0 {
		x2 = (m / a) + 1
	} else {
		x2 := m / a
	}
	result = x1 * x2
	fmt.Println(result)

}


package main
import "fmt"

func main(){
    var n,m,a int
    fmt.Scan(&n,&m,&a)
    var tiles1,tiles2 int64 = n/a, m/a

    if(n%a!=0) {tiles1++}
    if(m%a!=0) {tiles2++}

    var hasil int = tiles1 * tiles2
    fmt.Println(hasil)
}


package main

import "fmt"
func main() {
	var a, b, c int64
	fmt.Scan(&a, &b, &c)
	fmt.Println ((a-1)/c + 1) * ((b-1)/c + 1)
}


package main
import "fmt"

func main(){
    var n,m,a int64
    fmt.Scan(&n,&m,&a)
    var tiles1,tiles2 int = n/a, m/a

    if(n%a!=0) {tiles1++}
    if(m%a!=0) {tiles2++}

    var hasil int = tiles1 * tiles2
    fmt.Println(hasil)
}


package main

import "fmt"

func main() {
	var n, m, a uint64
	fmt.Scanf("%d %d %d", &n, &m, &a)
	rem := 0
	if n % a != 0 {
		rem = 1
	}
	cols := (n / a) + rem
	rem = 0
	if m % a != 0 {
		rem = 1
	}
	rows := (m / a) + rem
	fmt.Print(cols * rows)
}


package main

import(
    "fmt"
)

var(
    n,m,a int
)
func main(){
    fmt.Scanln(&n, &m, &a)
    widthNum := m / a
    if(m % a != 0){)
	widthNum++
    }
    LengthNum := n / a
    if(n % a != 0){
	LengthNum++
    }
    fmt.Println(widthNum * LengthNum)
}


package main

import "fmt"
import "math"

func main() {
   var n, m, a uint64
   fmt.Scanf("%d%d%d", &n, &m, &a)
   fmt.Println((n + a - 1) / a * (n + b - 1) / b)
}


package main

import "fmt"

func main() {
	var n, m, a int64
	fmt.Scanf("%d%d%d", &n, &m, &a)
	var inN, inM int64 = n / a, m / a
	var count int64 = inN * inM
	var add bool = true
	if n % a == 0 {
		count = n / a
	} else {
		count = n / a + 1
	}
	if m % a == 0 {
		count *= m / a
	} else {
		count *= m / a + 1
	}
	fmt.Println(count)
}


package main

import (
  "fmt"
  "strconv"
  "math"
  "math/big"
)

func main() {
    var w1, w2, w3 string
    fmt.Scanln(&w1, &w2, &w3)
    n := big.NewInt(strconv.ParseFloat(w1, 64))
    m := big.NewInt(strconv.ParseFloat(w2, 64))
    a := big.NewInt(strconv.ParseFloat(w3, 64))
    fmt.Println(math.Ceil(n/a) * math.Ceil(m/a))
}


package main

import "fmt"

func main() {
    var n,m,a,v,h int
    fmt.Scan(&n,&m)
    fmt.Scan(&a)
    v= (int)n/a
    if v%a!= 0 {
        v=v+1
    }
    h= (int)m/a
    if h%a!=0 {
        h=h+1
    }
    fmt.Println(v*h)
}


package main
import "fmt"

func main (){
    var m,n,a int
    fmt.scanf("%d",&m,&n,&a)
    fmt.println(((m+a-1)/a)*((n+a-1)/a))
}


package main

import "fmt"

func round(n float64) int {
	if  n1-float64(n2) < 0.00000001 {
		return int(n)
	} else {
		return int(n) +1
	}
}
func main() {
	var n, m, a int
	fmt.Scanf("%d,%d,%d", &n, &m, &a)
	fmt.Println(round(float64(n)/float64(a)) * round(float64(m)/float64(a)))
}


package main

import (
  "fmt"
)

func main(){
  var i, j, k int
  fmt.Scanf("%d %d %d\n", &i, &j, &k)
  var int n = i/k
  var int m = j/k
  if i%k!=0{
  n++
  }
  if j%k!=0{
    m++
  }
  fmt.Println(n*m)
}


package main

import (
	"fmt"
)

var m,n,a int64
func main() {
	fmt.Scanf("%d %d %d",&m,&n,&a)

	var s int
	y:=n/a
	if float64(n)/float64(a)>float64(y){
	y=y+1
	}

	x:=m/a
	if float64(m)/float64(a)>float64(x){
	x=x+1
	}

	s=y*x
	fmt.Println(s)
}


package main
import "fmt"

func main(){
    var n,m,a int64
    fmt.Scan(&n,&m,&a)
    var tiles1,tiles2 float64 = n/a, m/a

    if(n%a!=0) {tiles1++}
    if(m%a!=0) {tiles2++}

    var hasil float64  = tiles1 * tiles2
    fmt.Println(hasil)
}


package codeforces

import (
	"fmt"
	"strconv"
	"strings"
)

func convertAndCount(x []string) int {
	c := 0
	for _, s := range x {
		n, _ := strconv.Atoi(s)
		c += n
	}
	return c
}

func main() {
	var n int
	fmt.Scanln(&n)
	var s1, s2 string
	fmt.Scanln(&s1)
	fmt.Scanln(&s2)

	if convertAndCount(strings.Split(s1, " ")) == convertAndCount(strings.Split(s2, " ")) {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


package main

import "fmt"

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

	inputPiles := make([]int, n)
	pilesOutput := make([]int, n)

	for i := range inputPiles {
		fmt.Scan(&inputPiles[i])
	}
	for i := range pilesOutput {
		fmt.Scan(&pilesOutput[i])
	}

	inputPilesSum := sum(inputPiles)
	outputPilesSum := sum(pilesOutput)

	if inputPilesSum >= outputPilesSum {
		fmt.println("Yes")
		return
	}
	fmt.println("No")
}

func sum(slice []int) int {
	sum := 0
	for _, value := range slice {
		sum += value
	}

	return sum
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
)

func problem(n int32, answers []int32) {
	var res int32
	for i := 0; i < int(n)3; i++ {
		res |= answers[i]
	}
	if res == 1 {
		fmt.Println("HARD")
		return
	}
	fmt.Println("EASY")
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 1024*1024)

	line1 := strings.Split(readLine(reader), " ")
	nTemp, err := strconv.ParseInt(line1[0], 10, 64)
	checkError(err)
	n := int32(nTemp)

	line2 := strings.Split(readLine(reader), " ")
	var answers []int32
	for _, v := range line2 {
		vTmp, err := strconv.ParseInt(v, 10, 64)
		checkError(err)
		answers = append(answers, int32(vTmp))
	}

	problem(n, answers)
}

func readLine(reader *bufio.Reader) string {
	str, _, err := reader.ReadLine()
	if err == io.EOF {
		return ""
	}

	return strings.TrimRight(string(str), "\r\n")
}

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}


package main

import (
	"fmt"
)

func main() {
	var n int
        var res int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		fmt.Scan(&res)
		if res == 1{
			fmt.Println("HARD")
		}
		else if i == n-1{
			fmt.Println("EASY")
		}
	}

}


package main

import (
    "fmt"
)

func main() {
    var num int
    var isHard int
    var flag bool = false
    fmt.Scanf(&num)
    for i := 0; i < num; i++ {
        fmt.Scanf(&isHard)
        if isHard == 1 {
            flag = true
        }
    }

    if flag {
        fmt.Println("HARD")
    } else {
        fmt.Println("EASY")
    }
}


package main

import (
	"fmt"
)

func main() {
	var n int
        var res int
	fmt.Scan(&n)
	for i := 0; i < n; i++ {
		fmt.Scan(&res)
		if res == 1
                {
			fmt.Println("HARD")
		}
		if i == n-1
                {
			fmt.Println("EASY")
		}
	}

}


package main

import (
    "fmt"
)

func main() {
    var num int
    var isHard int
    var flag bool = false
    fmt.Scanf("%d", &num)
    for i := 0; i < num; i++ {
        fmt.Scanf(isHard)
        if isHard == 1 {
            flag = true
        }
    }

    if flag {
        fmt.Println("HARD")
    } else {
        fmt.Println("EASY")
    }
}


package main

import (
    "fmt"
)

func main() {
    var num int
    var isHard int
    var flag bool = false
    fmt.Scanf("%d", &num)
    for i := 0; i < num; i++ {
        fmt.Scanf("%d", &isHard)
        if isHard == 1 {
            flag = true
        }
    }

    if flag {
        fmt.Println("HARD")
    } else {
        fmt.Println("EASY")
    }


var n = readline().split(" ").map(function (x) { return parseInt(x); });
var res = readline().split(" ").map(function (x) { return parseInt(x); });
var judge = false;
for (var i = 1; i <= Number(n); ++ i) {
    var tmp = res[i - 1];
    if (Number(tmp) > 0) {
        judge = true;
    }
}
if (judge == true) {
    print("HARD");
}
else {
    print("EASY");
}


package codeforces

import (
	"fmt"
	"io"
	"os"
	"strings"
	"testing"
)

func p263a(in io.Reader) int {
	abs := func(x int) int {
		if x < 0 {
			return -x
		}
		return x
	}
	n := 5
	i, j := 0, 0
	for {
		v := 0
		fmt.Fscanf(in, "%d", &v)
		if v == 1 {
			break
		}
		i++
	}
	// manhatten distance
	i, j = i/n, i%n
	if j == 0 {
		j = 5
	}
	x, y := abs(i-3), abs(j-3)
	return x + y
}

func main() {
	p263a(os.Stdin)
}


import (
	"fmt"
	"io"
	"os"
)

func p263a(in io.Reader) int {
	abs := func(x int) int {
		if x < 0 {
			return -x
		}
		return x
	}
	n := 5
	i, j := 0, 0
	for {
		v := 0
		fmt.Fscanf(in, "%d", &v)
		if v == 1 {
			break
		}
		i++
	}
	// manhatten distance
	i, j = i/n, i%n
	if j == 0 {
		j = 5
	}
	x, y := abs(i-3), abs(j-3)
	return x + y
}

func main() {
	fmt.Println(p263a(os.Stdin))
}


package main

import (
	"os"
	"fmt"
	"io"
	"strings"
	"testing"
)

func p263a(in io.Reader) int {
	abs := func(x int) int {
		if x < 0 {
			return -x
		}
		return x
	}
	n := 5
	i, j := 0, 0
	for {
		v := 0
		fmt.Fscanf(in, "%d", &v)
		if v == 1 {
			break
		}
		i++
	}
	// manhatten distance
	i, j = i/n, i%n
	if j == 0 {
		j = 5
	}
	x, y := abs(i-3), abs(j-3)
	return x + y
}

func main() {
	p263a(os.Stdin)
}


package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strconv"
	"strings"

	log "github.com/Sirupsen/logrus"
)

func init() {
	log.SetLevel(log.ErrorLevel)
	log.Println("started")
}

// Case .
type Case struct {
	a, b, x, y, z int64
}

func solve(c Case, w io.Writer) {
	a := 2*c.x + c.y - c.a
	b := c.y + 3*c.z - c.b
	if a < 0 {
		a = 0
	}
	if b < 0 {
		b = 0
	}
	w.Write(([]byte)(fmt.Sprintf("%d\n", a+b)))
}

func parseInput(lines <-chan string, res chan<- Case) {
	for {
		ab1, ok := <-lines
		if !ok {
			close(res)
			return
		}
		ab := int64s(words(ab1))
		xyz := int64s(words(<-lines))
		res <- Case{ab[0], ab[1], xyz[0], xyz[1], xyz[2]}
	}
}

func int64s(w []string) []int64 {
	res := make([]int64, 0, len(w))
	for _, word := range w {
		i, err := strconv.ParseInt(word, 10, 64)
		if err != nil {
			panic(err)
		}
		res = append(res, i)
	}
	return res
}

func words(s string) []string {
	prep := strings.Split(s, " ")
	res := make([]string, 0, len(prep))
	for _, l := range prep {
		if len(l) > 0 {
			res = append(res, l)
		}
	}
	return res
}

func run() error {
	exp, err := ioutil.ReadFile("expected.txt")
	if err == nil {
		fmt.Println("--------- expected --------- ")
		fmt.Println((string)(exp))
		fmt.Println("--------- computed --------- ")
	}

	inData, err := ioutil.ReadAll(os.Stdin)
	//inData, err := ioutil.ReadFile("in.txt")
	if err != nil {
		return fmt.Errorf("read input: %s", err)
	}
	lines := make(chan string, 8)
	cases := make(chan Case, 8)
	go func() {
		for _, line := range strings.Split((string)(inData), "\n") {
			s := strings.TrimSpace(line)
			if len(s) > 0 {
				lines <- s
			}
		}
		close(lines)
	}()
	go parseInput(lines, cases)
	for c := range cases {
		solve(c, os.Stdout)
	}
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}


package main

import "fmt"

func main() {
    var yc, bc uint64
    var y,g,b uint64
    var yn, bn uint64
    fmt.Scan(&yc, &bc, &y, &g, &b)
    yn = 2*y + 1*g
    bn = 1*g + 3*b
    var total int
    if yn > yc {
        total += yn - yc
    }
    if bn > bc {
        total += bn - bc
    }
    fmt.Print(total)
}


import(
	"fmt"
)

func main() {
	var t int
	_, err := fmt.Scan(&t)
	if err != nil {
		panic(err)
	}

	for i := 0; t > i; i++ {
		var a []int
		for j := 0; 2 > j ; j++ {
			var v1 int
			var v2 int
			_, err := fmt.Scanf("%d %d", &v1, &v2)
			if err != nil {
				panic(err)
			}
			a = append(a, v1, v2)
		}

		if a[0] + a[1] + a[2] + a[3] == 4 {
			fmt.Println("2")
		} else if a[0] + a[1] + a[2] + a[3] == 0 {
			fmt.Println("0")
		} else {
			fmt.Println("1")
		}
	}

}


package main

import "fmt"
import "os"
import "bufio"

var s string
func main() {
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &s)
	i : = 0
	zero := 0

	for i < len(s) {
		if  s[i] == '1' { break }
	}

	for i < len(s) {
		if s[i] == '0' {
			zero++
		}
	}
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var m, n int
	fmt.Scan(&m, &n)
	fmt.Println(int(math.Floor(m * n / 2)))
}


package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	c = a/2*b + a%2*b/2
	b = b/2*a + b%2*a/2
	if c < b {
		c = b
	}
	fmt.Print(c)
}


package main

import "fmt"
import "strings"

func main() {

	var a, b int;

	fmt.Scan(&a, &b);

	fmt.Println((a * b) / 2)
}


package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	fmt.Println(max(a/2*b+a%2*b/2), (b/2*a + b%2*a/2))
}


package a50

import "fmt"

func main() {
	m, n := 0, 0

	fmt.Scanln(&m)
	fmt.Scanln(&n)

	fmt.Println(" ", m*n/2)
}


package main

import ("fmt"
        "math"
)

func main (){
    var m float64
    var n float64
    fmt.Scan(&m,&n)

    h := int64(math.Floor(n*m/2)
    fmt.Println(h)
}


package main

import (
	"os"
	"bufio"
	"strconv"
	"fmt"
	"sort"
)

var scanner *bufio.Scanner

func getI64() int64 {
	scanner.Scan()
	x, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return x
}
func getI() int {
	return int(getI64())
}
func getF() float64 {
	scanner.Scan()
	x, _ := strconv.ParseFloat(scanner.Text(), 64)
	return x
}
func getS() string {
	scanner.Scan()
	return scanner.Text()
}

func max(a,b int) int { if a > b { return a } else { return b } }

func min(a,b int) int { if a < b { return a } else { return b } }

const alphabets = "abcdefghijklmnopqrstuvwxyz"

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	Problem1092B()
}

func Problem1092B() {
	n := getI()
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		arr[i] = getI()
	}
	sort.Ints(arr)
	max := 0
	for i := 0; i < n; i+=2 {
		if arr[i] != arr[i+1] {
			max += arr[i+1] - arr[i]
		}
	}
	println(max)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n, result int
	if _, err := fmt.Scanln(&n); err != nil {
		panic(err)
	}
	a := make([]int, n)
	for i := 0; i < n; i++ {
		if _, err := fmt.Scan(&a[i]); err != nil {
			panic(err)
		}
	}
	sort.Ints(a)
	for i := 0; i < n; i += 2 {
		result += a[i+1] - a[i]
	}

	fmt.Println(result)
}


package main

import (
	"fmt"
	"strings"
)
//bg менять на gb
func checking(s string) {
	flag := strings.ReplaceAll(s, "BG", "GB")
	return flag
}

func main() {
	var itog string
    var x, y int
	fmt.Scan(&itog)
    fmt.Scan(&x, &y)

	for i := 0; i++; i < y {
		itog = checking(itog)
	}
	fmt.Println(itog)
}


package main

import (
	"fmt"
	"strings"
)
//bg менять на gb
func checking(s string) {
	flag := strings.ReplaceAll(s, "BG", "GB")
	return flag
}

func main() {
	var itog string
    var x, y int
	fmt.Scan(&itog)
    fmt.Scan(&x, &y)

	for i := 0; i < y; i++ {
		itog = checking(itog)
	}
	fmt.Println(itog)
}


package main

import (
	"fmt"
)

func main() {
	var k,w,d int64
	fmt.Scan(&k,&d,&w)
	n:=(k+(w*k))*w/2
	n-=d
	if n<0{
		fmt.Printf('0')
	} else {
		fmt.Printf(n)
	}

}


package p546a

import (
	"fmt"
)

func main() {
	var k, n, w int
	fmt.Scan(&k)
	fmt.Scan(&n)
	fmt.Scan(&w)

	fmt.Print(CalcBorrow(k, n, w))
}

func CalcBorrow(k int, n int, w int) int {
	cost := (1 + w) * w * k / 2

	if cost > n {
		return cost - n
	} else {
		return 0
	}
}


package main

import (
	"fmt"
	"math"
  //"bufio"
  //"os"
)

func main() {
  //cin := bufio.NewReader(os.Stdin)
	//cout := bufio.NewWriter(os.Stdout)
	//defer cout.Flush()

    var k,n,w int
    fmt.Scan(&k)
    fmt.Scan(&n)
    fmt.Scan(&w)
    money:=0
	for x := 1; x < w+1; x++ {
    money+= k*x


package main

import (
	"bufio"
	"os"
)

type input struct {
	a string
}

func (s *input) readIn(scanner *bufio.Scanner) {
	for scanner.Scan() {
		s.a = scanner.Text()
	}
}
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	var inp input
	inp.readIn(sc)
	chr := ""
	var v1 int
	for _, b := range inp.a {
		str := string(b)
		if str == chr {
			v1++
		} else {
			v1 = 1
		}

	}

}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int
	fmt.Scan(&n)
	var altScore [n]int
	var s string
	fmt.Scan(&s)
	var defaultScore [n]uint8
	d := 1
	defaultScore[0] = 1
	for i := 1; i < n; i++ {
		if s[i] != s[i+1] {
			d++
		}
		defaultScore[i] = d
	}
	for i := 0; i < n; i++ {

	}

	fmt.Print(d)
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
)

func fastGetInt(b []byte) int {
	neg := false
	if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	n := 0
	for _, v := range b {
		n = n*10 + int(v-'0')
	}
	if neg {
		return -n
	}
	return n
}

func solveFromFile() int {
	var num int
	var numList []int
	file, err := os.Open(os.Args[1])
	if err != nil {
		log.Fatalf("failed opening file: %s", err)
	}
	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanWords)

	scanner.Scan()
	num = fastGetInt(scanner.Bytes())
	scanner.Scan()
	for scanner.Scan() {
		numList = append(numList, fastGetInt(scanner.Bytes()))
	}

	defer file.Close()

	return solution(num, numList)
}

//========== Implement Algorithm =======================
func solution(num int, numList []int) int {
	minNum := 9999999999
	sort.Ints(numList)
	for x := 0; x < (len(numList) - (num)); x++ {
		if (numList[x+num-1] - numList[x]) <= minNum {
			minNum = (numList[x+num-1] - numList[x])
		}
	}
	return minNum
}

func main() {

	//================== Variables used ====================
	var num, ret int
	var numList []int
	//======================================================

	if len(os.Args) >= 2 {
		//============== Get return value from File ============
		ret = solveFromFile()

	} else {
		//============== Get return value from STDIN ===========
		scanner := bufio.NewScanner(os.Stdin)
		scanner.Split(bufio.ScanWords)

		scanner.Scan()
		num = fastGetInt(scanner.Bytes())
		scanner.Scan()

		for scanner.Scan() {
			numList = append(numList, fastGetInt(scanner.Bytes()))
		}

		ret = solution(num, numList)
	}

	//================== OUTPUT ============================
	fmt.Println(ret)
}


package main

import "fmt"

func main() {
    var w uint

    fmt.Scanf("%d", &w)

    if (w == 2) {
        fmt.Println("NO")
    if (w % 2 == 0) {
        fmt.Println("YES")
    } else {
        fmt.Println("NO")
    }
}


package main
import "fmt"
func main() {
	var w int
	fmt.Scan(&w)
	if w%2 == 0 && w > 2 {
		fmt.Println("YES")
	}
	else {
		fmt.Println("NO")
	}
}


import (
  "bufio"
  "fmt"
  "os"
  "strconv"
  "strings"
)

func main() {
  reader := bufio.NewReader(os.Stdin)
  text, _ := reader.ReadString('\n')
  text = strings.Replace(text, "\n", "", -1)

  num, err := strconv.Atoi(text)
  if err != nil {
    fmt.Print("NO")
    return
  }

  if num <= 0 || num > 100 || num%2 != 0 {
    fmt.Printf("NO")
    return
  }

  fmt.Printf("YES")
}


package main

import "fmt"

// main function
func main() {
    var int temp
    fmt.Scanln(&temp)
    if(temp%2 == 0) {
        if((temp/2)%2 == 0) {
            fmt.Println("YES")
        }
        else {
        fmt.Println("NO")
        }
    }
}


package main

import (
  "fmt"
  "strconv"
)

func main(){
  var i int
  fmt.Scanf("%d\n", &i)
  //i, _ := strconv.Atoi(text)
  if (i%2==0 && i>2) {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


package "main"
import "fmt"
func check(weight int) String {
    if weight %2 != 0 {
        fmt.println("NO")
    }else {
        fmt.println("YES")
    }
}


package main

func main() {
	a := flag.Args()
	i, _ := strconv.Atoi(a[0])
	fl := float64(i)

	if math.Mod(fl, 2) == 0{
		println("YES")
	} else {
		println("NO")
	}
}


package main

import (
  "fmt"
  "os"
  "bufio"
  "strconv"
)

func main(){
  reader := bufio.NewReader(os.Stdin)
  fmt.Print("Enter text: ")
  text, _ := reader.ReadString('\n')
  i, _ = strconv.Atoi(text)
  if (i%2==0 && i<101 && i>0) {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


import "fmt"

func main() {
   reader := bufio.NewReader(os.Stdin)
text:= reader.ReadString('\n')
if text > 2 $ text % 2 == 0{
fmt.Println('YES')
}
else{
    fmt.Println('NO')
}
}


func main() {

    var w = 80

    for i := 0; i < w; i++ {
        other := w-i
        if other % 2 == 0 && w % 2 == 0 {
            fmt.Print("true")
            return true
        }
    }
    return false

}


package main
import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	)
func main() {
    number := 0
    fmt.Scanf("%d\n", &number)
    if number > 2 && number % 2 == 0 {
        fmt.Println("YES")
    }else{
        fmt.Println("NO")
    }

}


package main

import "fmt"

func main() {
	var w,a int
	fmt.Scan(&w)
	if (w%2)==0{
			fmt.Print("YES")
			}
		else{
			fmt.Print("NO")
			}
	}


package main

import (
  "fmt"
  "strconv"
)

func main(){
  var text string
  fmt.Scanf("%v\n", &text)
  i, _ := strconv.Atoi(text)
  if (i%2==0 i>2) {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


package main
import (
    "bufio"
	"fmt"
	"os"
	"strconv"
)

func main(){
    var n int
    fmt.Scafn(&n)
    if n % 2 == 0 && n > 2{
        fmt.Println("YES")
    }else{
        fmt.Println("NO")
    }
}


package main

import "fmt"

func check(weight int)  {
	if weight%2 != 0 || weight ==2 {
		fmt.Println("NO")
	}else {
		fmt.Println("YES")
	}
}


package main

import "fmt"

func check(n int) int {
	return n%2
}

func main() {
	var n
	fmt.Scanf("%d",&n)

	if check(n) == 0 && n != 2 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	fmt.Fprintf(writer, f, a...)
}

func scanf(f string, a ...interface{}) {
	fmt.Fscanf(reader, f, a...)
}

func main() {
	// The weight of watermelon
	var w int
	scanf("%d\n", &w)

	var b bool = false
	if w <= 2 {
		printf("NO\n")
	} else if w%2 == 0 {
		printf("YES\n")
	} else {
		printf("NO\n")
	}

	writer.Flush()
}


package main

import "fmt"

func check(n int) int {
	return n%2
}

func main() {
	var n
	fmt.Scanf("%d",&n)

	if (check(n) == 0) && (n != 2) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


import (
    "fmt"
)

func main() {

    var w int
    fmt.Scanf("%d\n",&w)

    if w % 2 == 0 {
        fmt.Println("YES")
    } else {
        fmt.Println("NO")
    }

}


func main() {
	a := flag.Args()
	i, _ := strconv.Atoi(a[0])
	fl := float64(i)

	if math.Mod(fl, 2) == 0{
		println("YES")
	} else {
		println("NO")
	}
}


package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d\n")
	fmt.Printf("%s\n", n % 2 == 0 ? "YES" : "NO")
}


for i := 0; i < w; i++ {
        other := w-i
        if other % 2 == 0 && w % 2 == 0 {
            fmt.Print("true")
            return true
        }
    }
return false


package main

import "fmt"

func main() {
  var w int
  fmt.Scanfln(&w)
  return w % 4 == 0
}


package main

import "fmt"

func check(int n) int{
	return n%2
}

func main() {
	n int
	fmt.Scanf("%d",&n)
	if check(n) == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import fmt

func main(){
    var n
    fmt.Scanln(&n)
    if(n%2==0){
        fmt.println("Yes")
    }
    else{
        fmt.println("No")
    }
}


package main
import "fmt"
func main()
{
    var n int
    fmt.Scan(&n)
    if n%2==0{
        fmt.Print("Yes")
    }
    else{
        Print("No")
    }
}


package main

import {
  "fmt"
  "os"
}

func main(){
  reader := bufio.NewReader(os.Stdin)
  fmt.Print("Enter text: ")
  text, _ := reader.ReadString('\n')
  if int(text)%2==0 {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


package main

import "fmt"

func main() {
  var w int
  fmt.Scanln(&w)
  if w % 4 == 0
    fmt.Println("YES")
  else
    fmt.Println("NO")
}


import (
	"fmt"
)

func main() {
	var kilo int8
	_, _ = fmt.Scan(&kilo)
	//reader := bufio.NewReader(os.Stdin)
	//text, _ := reader.ReadString('\n')
	//integer, _ := strconv.Atoi(text)

	if (kilo/2)%2 == 0 {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}


package main

import "fmt"

// main function
func main() {
    var int temp
    fmt.Scanln(&temp)
    if(temp%2 == 0) {
        if((temp/2)%2 == 0) {
            fmt.Println("YES")
        }
        else {
            fmt.Println("NO")
        }
    }
}


package main

import (
    "os"
    "fmt"
    "bufio"
    "strconv"
)

func prErr(err error) {
    if err != nil {
        fmt.Println(err)
    }
}

func main() {
    reader := bufio.NewReader(os.Stdin)
    text, err := reader.ReadString('\n')
    prErr(err)
    text = strings.TrimSuffix(text, "\r\n")

    w, err := strconv.Atoi(text)
    prErr(err)

    if w%2 == 0 {
        fmt.Println("YES")
    }  else {
        fmt.Println("NO")
    }
}


package main

import (
"bufio"
"fmt"
"os"
"strconv"
)

// http://codeforces.com/problemset/problem/4/A
func main() {
	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	fmt.Printf("%#v", text)
	w, _ := strconv.ParseInt(text, 10, 8)
	fmt.Printf()
	if ((w-2)%2) == 0 {
		fmt.Printf("YES")
	} else {
		fmt.Printf("NO")
	}
}


package main

import (
    "fmt"
)

func main() {
    var n int
    _, _ = fmt.Scanf("%d\n", &n)
    if n % 2 == 0 {
        return "YES"
    }
    return "NO"
}


package main

import "fmt"

func main() {
	var w int
	fmt.Scanf("%d", &w)
	if w <= 2 {
		fmt.Println('NO')
	}
	if w % 2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

func main() {
    var w int
    fmt.Scanf("%d", w)
    if var % 2 == 0 {
        fmt.Println('YES')
    } else {
        fmt.Println('NO')
    }
}


package main

import "fmt"

func main() {
  var n int
  fmt.Scanf("%d\n", &n)
  if n % 2 != 0 {
    fmt.Printf("NO\n")
  }  if n <= 2 {
    fmt.Printf("NO")
  } else {
    fmt.Printf("YES\n")
  }
}


package main

import (
	// "bufio"
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	text, _, _ := reader.ReadLine()

	att1, _ := strconv.ParseInt(text, 10, 0)
	if att1%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}


Copy
package main

import (
    "bufio"
    "strconv"
    "fmt"
    "os"
)

func main() {
    r := bufio.NewReader(os.Stdin)
	s, _ := r.ReadString('\n')
	n, _ := strconv.Atoi(s)
	if n %2 == 0 {
	    fmt.Println("YES")
	    return
	}
	fmt.Prinln("NO")
}


package main

import "fmt"

func main() bool {
  var w int
  fmt.Scanln(&w)
  return w % 4 == 0
}


package main

import (
	"fmt"
)

func main() {
	var int n
	fmt.Scanf("%d", &n)
	if n%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

// main function
func main() {
    var int temp
    fmt.Scanln(&temp)
    if(temp%2 == 0) {
        if((temp/2)%2 == 0) {
            fmt.Println("YES")
        }
        else fmt.Println("NO")
    }
}


package main

import "fmt"

func check(int n) int{
	return n%2
}

func main() {
	n int
	fmt.Scanf("%d",&n)
	if(check(n) == 0) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

// main function
func main() {
    var int temp
    fmt.Scanln(&temp)
    if(temp%2 == 0) {
        if((temp/2)%2 == 0) {
        fmt.Println("YES")
        }
        else fmt.Println("NO")
    }
}


package main

import "fmt"

func main() {
    var melon int
    fmt.Scanln(&melon)
    if melon % 2 == 1 || melon == 0: {
        fmt.Println("NO")
    } else {
        fmt.Println("YES")
    }
}


package main

import (
  "fmt"
  "os"
  "bufio"
)

func main(){
  reader := bufio.NewReader(os.Stdin)
  fmt.Print("Enter text: ")
  text, _ := reader.ReadString('\n')
  if int32(text)%2==0 {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


package main

import (
  "fmt"
  "os"
  "bufio"
  "strconv"
)

func main(){
  reader := bufio.NewReader(os.Stdin)
  fmt.Print("Enter text: ")
  text, _ := reader.ReadString('\n')
  i, _ := strconv.Atoi(text)
  x := i/2
  if (i%2==0 && i<101 && i>0 && i/2 && x%2==0) {
    fmt.Println("YES")
    return
  }
  fmt.Println("NO")
}


package main

import "fmt"

func check(weight int)  {
	if weight%2 != 0 {
		fmt.Println("NO")
	}else {
		fmt.Println("YES")
	}
}


package main

import (
    "bufio"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        i, _ := strconv.Atio(scanner.Text())
        if i % 2 == 0 {
            println(i)
        }
    }
}


import "fmt"

func check(weight int)  {
	if weight%2 != 0 || weight ==2 {
		fmt.Println("NO")
	}else {
		fmt.Println("YES")
	}
}


package cf

func Watermelon(n int) bool {
	return n%2 == 0
}


package main

import (
        "fmt"
    )

func main() {
    var kilos int = 0
    fmt.Scan(kilos)
    if kilos < 2 {
        fmt.Println("NO")
    }
    else if kilos%2 == 0 {
        fmt.Println("YES")
    }
    else {
        fmt.Println("NO")
    }

}


package main

import "fmt"

func main() {
	var inp int
	var flag bool
	var lst [12]int = [12]int{4, 7, 44, 47, 74, 77, 444, 447, 477, 744, 747, 777}
	fmt.Scan(&inp)
	for i := 0; i < len(lst); i++ {
		if inp%lst[i] == 0 {
			flag = true
			break
		}
	}
	if flag {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
}


package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
)

func getInput() string {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	for sc.Scan() {
		return sc.Text()
	}
}

func main() {
	n := getInput()
	number, _ := strconv.Atoi(n)
	if number%4 == 0 || number%7 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


import (
        "fmt"
)

var lucky = []int{4, 7, 44, 77, 47, 74, 444, 777, 477, 747, 774, 744, 474, 447}

func main() {
        var num int
        fmt.Scanf("%d\n", &num)
        var a = num
        var fuck = true
        for {
                if a == 0 {
                        break
                }
                if a%10 == 4 || a%10 == 7 {
                        fuck = true
                        a = a / 10
                } else {
                        fuck = false
                        break
                }
        }
        if !fuck {
                for _, i := range lucky {
                        if num%i == 0 {
                                fuck = true
                                break
                        }
                }
        }
        if fuck {
                fmt.Println("YES")
        } else {
                fmt.Println("NO")
        }
}


package main

import (
    "fmt"
)

func main() {
    var n uint16
    fmt.Scan(&n)
    ans := "NO"
    arr := [14]int{4,7,44,47,74,77,444,447,474,477,744,747,774,777}
    for _,v := range arr{
        if n%v==0{
            ans = "YES"
            break
        }
    }
    fmt.Println(ans)
}


package main
import (
  "fmt"
  "sort"
  )

func main(){
  var n int
  var l [12]int
  fmt.Scan(&n)
  for i:=0;i<12;i++{
    fmt.Scan(&l[i])
    }
  sort.Sort(sort.Reverse(sort.IntSlice(l)))
  if n == 0 {
    fmt.Println(0)
    } else {
     k := 0
    m := 0
    for _,i := range l {
      m += i
      if m < n {
        k++
        }
      }
    if m >= n {
      fmt.Println(k+1)
    }else{
      fmt.Println(-1)
      }
  }
}


package main

import (
	"fmt"
	"sort"
)

func read() int {
	var number int
	fmt.Scan(&number)
	return number
}

func main() {
	var growRateForMonth []int = make([]int, 12)

	growMin := readInt()

	for i := 0; i < 12; i++ {
		growRateForMonth[i] = readInt()
	}

	sort.Sort(sort.Reverse(sort.IntSlice(growRateForMonth)))

	totalMonths := 0

	for _, monthValue := range growRateForMonth {
		if growMin <= 0 {
			break
		}

		growMin -= monthValue
		totalMonths++
	}

	// wattt

	if totalMonths == 12 && growMin > 0 {
		fmt.Println(-1)
	} else {
		fmt.Println(totalMonths)
	}
}


package main
import (
  "fmt"
  "sort"
  )

func main(){
  var n int
  var l [12]int
  fmt.Scan(&n)
  for i:=0;i<12;i++{
    fmt.Scan(&l[i])
    }
  sort.Sort(sort.Reverse(sort.IntSlice(l)))
  if n == 0 {
    fmt.Println(0)
    } else {
     k := 0
    m := 0
    for _,i := range l {
      m += i
      if m < n {
        k++
        }
      }
    if m >= n {
      fmt.Println(k+1)
    }else{
      fmt.Println(-1)
      }
  }


package main
import "fmt"
import "strconv"
func main() {
    var f int
    var a,b int
    var s string
    fmt.Scanf("%d", &b)
    a=0
    for _,c := range strconv.Itoa(b) {
        if ( c == '4' || c == '7' ){
            a++
		}
	}
    f = 0
    for _,c := range strconv.Itoa(a) {
        if ( c != '4' && c != '7' ){
		    f=1;
		    break;
		}
	}
	if f == 0{
	    fmt.Println("YES")
	} else {
	    fmt.Println("NO")
	}
}


package main

import (
	"fmt"
)

func main() {
	var n,x,y int64
	a,b,c:=0,0,0
	fmt.Scan(&n)
	for i:=0;i<n;i++ {
		fmt.Scan(&x,&y)
		a+=x
		b+=y
	}
	if x%2!=y%2 {
		c++
	}
	if a%2==0 && b%2==0 {
		fmt.Print("0")
	} else if c%2==0 && c>0 {
		fmt.Print("1")
	} else {
		fmt.Print("-1")
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	var n, m uint8
	var c uint16
	var s string
	in := bufio.NewReader(os.Stdin)
	fmt.Fscanf(in, "%d %d\n", &n, &m)
	for i := uint8(0); i < n; i++ {
		for j := uint8(0); j < m; j++ {
			fmt.Fscanf(in, "%s", &s)
			if s == "W" || s == "G" || s == "B" {
				c++
			}
		}
	}
	if c == uint16(n) * uint16(m)) {
		fmt.Println("#Black&White")
	} else {
		fmt.Println("#Color")
	}
}


package main

import (
	"bufio"
	"os"
	"strconv"
)

var in *bufio.Scanner
var out *bufio.Writer

func main() {
	in = bufio.NewScanner(os.Stdin)
	out = bufio.NewWriter(os.Stdout)

	in.Split(bufio.ScanWords)
	defer out.Flush()

	in.Scan()
	n, _ := strconv.Atoi(in.Text())

	in.Scan()
	m, _ := strconv.Atoi(in.Text())

	res := "#Black&White"

	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			in.Scan()
			c := in.Text()
			if (c != "B") && (c != "W") && (c != "G") {
				res = "#Color"
			}
		}
	}

	out.WriteString(res)
	out.WriteByte('\n')
}


import "fmt"

func main() {
    var n int
    var s string
    fmt.Scan(&n,&s)
    ans := 0
    for i := 1; i < n; i++ {
        if (s[i] == s[i-1]) { ans++ }
    }
    fmt.Println(ans)
}


package main

import "fmt"

func main10() {
	// rrr g bbbbb gg
	var n int
	var cu string
	fmt.Scanf("%d", &n)
	fmt.Scanln(&cu)
	corAnterior := cu[:1]
	pomba := 1
	for i := 1; i < n; i++ {
		corAtual := cu[i : i+1] // pegar i
		if corAtual != corAnterior {
			pomba++
			corAnterior = corAtual
		}
	}
	fmt.Println(n - pomba)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	integerWord, _ := reader.ReadString('\n')
	integerSufx := strings.TrimSuffix(integerWord, "\r\n")
	intV, _ := strconv.Atoi(integerSufx)
	stones, _ := reader.ReadString('\n')
	stones = strings.TrimSuffix(stones, "\r\n")
	copyi := intV
	for _, v := range stones {
		count := strings.Count(stones, string(v))
		if count > 1 {
			count--
			stones = strings.ReplaceAll(stones, string(v), "")
			copyi = copyi - count
		}
	}

	fmt.Print(intV - copyi)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	integerWord, _ := reader.ReadString('\n')
	integerSufx := strings.TrimSuffix(integerWord, "\n")
	intV, _ := strconv.Atoi(integerSufx)
	stones, _ := reader.ReadString('\n')
	stones = strings.TrimSuffix(stones, "\r\n")
	ttl := 0
	for _, v := range stones {
		count := strings.Count(stones, string(v))
		if count > 1 {
			count--
			stones = strings.ReplaceAll(stones, string(v), "")
			ttl += count
		}
	}
	fmt.Print(ttl)
}


package main

import "fmt"
import "sort"
import "bufio"
import "os"
import "strconv"

func main() {
    var n int
    fmt.Scan(&n)
    nums := make([]int, n)

    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanWords)

    for i:=0; scanner.Scan(); i++ {
        num, _ := strconv.Atoi(scanner.Text())
        nums[i] = num
    }
    sort.Ints(nums)

    var canFormTriangle bool
    for i:=2; i<n; i++ {
        if nums[i-2]+num[i-1] > nums[i] {
            canFormTriangle = true
            break
        }
    }
    if canFormTriangle {
        fmt.Print("YES")
    } else {
        fmt.Print("NO")
    }
}


package main

import "fmt"

func max(a,b int)
int {
if a > b {
 return a
} else {
 return b
}
}

func main() {

var n int

var a [3]int

fmt.Scan(&n,&a[0],&a[1],&a[2])

dp := make([]int,n+1)

dp[0] = 0

for i := 1; i <= n; i++ {

dp[i] = -999999999

for k := 0; k < 3; k++ {

if (i-a[k]) >= 0 {

dp[i] = max(dp[i],1+dp[i-a[k]])

}

}

}

fmt.Println(dp[n])

}


package main

func main() {
    var limak, bob int
    fmt.Scanf("%d %d\n", &limak, &bob)
    var res int
    for {
        if limak > bob {
            break
        }
        limak *= 3
        bob *= 2
        res++
    }
    fmt.Println(res)
}


package main

import (
	"fmt"
	"os"
	"math"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	printf("%d", Problem791A())
}

func Problem791A () int {
	idx := 0
	var a,b int
	scanf("%d %d\n", &a, &b)

	for a < b {
		a = a * 3
		b = b * 2
		idx+=1
	}

	return idx
}

func printf(format string, x ...interface{}) {
	fmt.Fprintf(os.Stdout, format, x...)
}

func scanf(format string, x ...interface{}) {
	if _, err := fmt.Fscanf(os.Stdin, format, x...); err != nil {
		panic(err)
	}
}


package main

import (
	"fmt"
	"os"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	printf("%d", Problem379A())
}

func Problem791A () int {
	idx := 0
	var a,b int
	scanf("%d %d\n", &a, &b)

	for a < b {
		a = a * 3
		b = b * 2
		idx+=1
	}

	return idx
}

func printf(format string, x ...interface{}) {
	fmt.Fprintf(os.Stdout, format, x...)
}

func scanf(format string, x ...interface{}) {
	if _, err := fmt.Fscanf(os.Stdin, format, x...); err != nil {
		panic(err)
	}
}


package main

import (
	"fmt"
	"os"
	"math"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	printf("%d", Problem379A())
}

func Problem791A () int {
	idx := 0
	var a,b int
	scanf("%d %d\n", &a, &b)

	for a < b {
		a = a * 3
		b = b * 2
		idx+=1
	}

	return idx
}

func printf(format string, x ...interface{}) {
	fmt.Fprintf(os.Stdout, format, x...)
}

func scanf(format string, x ...interface{}) {
	if _, err := fmt.Fscanf(os.Stdin, format, x...); err != nil {
		panic(err)
	}
}


package main

import(
	"fmt"
	"bufio"
	"os"
	"strings"
	"strconv"
)

func main(){
	reader := bufio.NewReader(os.Stdin);
	for{
		text,_ := reader.ReadString('\n');
		text = strings.Replace(text, "\n", "", -1);
		splitted := strings.Split(text, " ");
		a,_ := strconv.ParseInt(splitted[0], 10, 32);
		b,_ := strconv.ParseInt(splitted[1], 10, 32);
		var cnt int = 0;
		for a<=b{
			cnt++;
			a*=3;
			b*=2;
		}
		fmt.print("AAAAA\n");
		fmt.Printf("%d\n", cnt);
		break;
	}
}


package main

import(
	"fmt"
	"bufio"
	"os"
	"strings"
	"strconv"
)

func main(){
	reader := bufio.NewReader(os.Stdin);
	for{
		text,_ := reader.ReadString('\n');
		text = strings.TrimSuffix(text, "\n");
		splitted := strings.Split(text, " ");
		a,_ := strconv.ParseInt(splitted[0], 10, 32);
		b,_ := strconv.ParseInt(splitted[1], 10, 32);
		fmt.println(b);
		fmt.Printf("%d %d\n", a, b);
		var cnt int = 0;
		for a<=b{
			cnt++;
			a*=3;
			b*=2;
		}
		fmt.Printf("%d\n", cnt);
		break;
	}
}


// https://codeforces.com/problemset/problem/888/B
package main

import (
	"fmt"
	"bufio"
	"os"
	"strconv"
	"math"
)

func move(pos []int, move rune) {
	switch move {
	case 'U':
		pos[1]++
	case 'D':
		pos[1]--
	case 'L':
		pos[0]--
	case 'R':
		pos[0]++
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	numCommands, _ := strconv.ParseInt(scanner.Text(), 10, 32)
	pos := []int{0, 0}
	scanner.Scan()
	cmds := scanner.Text()
	for i, cmd := range cmds {
		move(pos, cmd)
		// fmt.Printf("%d - current position - %d, %d\n", i+1, pos[0], pos[1])
	}
	fmt.Printf("%d", numCommands - int64(math.Abs(float64(pos[0]- 0))) - int64(math.Abs(float64(pos[1]-0))))
}


package main

import (
	"os"
	"bufio"
	"strconv"
	"fmt"
	"math"
)

var scanner *bufio.Scanner

func getI64() int64 {
	scanner.Scan()
	x, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return x
}
func getI() int {
	return int(getI64())
}
func getF() float64 {
	scanner.Scan()
	x, _ := strconv.ParseFloat(scanner.Text(), 64)
	return x
}
func getS() string {
	scanner.Scan()
	return scanner.Text()
}

func max(a,b int) int { if a > b { return a } else { return b } }

func min(a,b int) int { if a < b { return a } else { return b } }

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	writer.WriteString(fmt.Sprintf("%d", Problem888B()))
}

func Problem888B() int {
	n := getI()
	x := 0
	y := 0
	for i:= 0; i < n ; i++ {
	    s := getS()
	    switch(s){
	        case "U":
	            y+=1
	            break
	        case "D":
	            y-=1
	            break
	        case "L":
	            x-=1
	            break
	        case "R":
	            x+=1
	            break
	        default:
	            break
	    }
	}
	return n - (x-y)
}


package main

import (
	"fmt"
	"os"
)

func main(){
	var c string
	var ct [5] string
	fmt.Scan(&c)
	for i:=0; i<5; i++{
		fmt.Scan(&ct[i])
			if(c[0] == ct[i][0] || c[1] == ct[i][1]){
				fmt.Println("YES")
				os.Exit(0)
			}
		}
	}
	fmt.Println("NO")

}


package main

import "fmt"

func solve(x,y,z,a,b,c) {
  if a >= x
    return 0
  if a+b >= x+y
    return 0
  if a+b+c >= x+y+z
    return 0
  return 1
}

func main() {
	var x, y, z, a, b, c int
	fmt.Scan(&x, &y, &z, &a, &b, &c)
	if solve(x,y,z,a,b,c) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

func solve(x,y,z,a,b,c) {
  if a >= x {
    return 0
  }
  if a+b >= x+y {
    return 0
  }
  if a+b+c >= x+y+z }
    return 0
  }
  return 1
}

func main() {
	var x, y, z, a, b, c int
	fmt.Scan(&x, &y, &z, &a, &b, &c)
	if solve(x,y,z,a,b,c) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

func solve(x int, y int, z int, a int, b int, c int) int {
  if a >= x {
    return 0
  }
  if a+b >= x+y {
    return 0
  }
  if a+b+c >= x+y+z {
    return 0
  }
  return 1
}

func main() {
	var x, y, z, a, b, c int
	fmt.Scan(&x, &y, &z, &a, &b, &c)
	if solve(x,y,z,a,b,c) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import (
	"fmt"
)

func main() {
	var n, m int
	fmt.Scanf("%d %d\n", &n, &m)
	var s int
	var scores []int
	for j := 0; j < n; j++ {
		fmt.Scanf("%d\n", &s)
		scores = append(scores, s)
	}
	num := 0
	m--
	t := scores[m]
	for j =0; j<len(scores); j++ {
		if v >= t {
			num++
		}

	}
	fmt.Println(num)
}


package main

import "fmt"

func main() {
	var n, k, s, result int
	fmt.Scanf("%d %d", &n, &k)
	scores := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scanf("%d",&scores[i])
	}
	for _, v := range scores {
		if v < scores[k-1] || v < 0 {
			break
		}
		result++
	}
	fmt.Println(result)
}


package main

import (
  "fmt"
)

func main(){
  var n, m int
  fmt.Scanf("%d\n", &n)
  var s int
  var scores []int
  for j := 0; j<n; j++ {
    fmt.Scanf("%d\n", &s)
    append(scores, s)
  }
  num := 0
  for _, v := range scores{
    if(v>m){num++}

  }
  fmt.Println(num)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func main() {
	in := bufio.NewScanner(os.Stdin)
	in.Split(bufio.ScanWords)
	in.Scan()
	n, _ := strconv.Atoi(in.Text())
	in.Scan()
	k, _ := strconv.Atoi(in.Text())
	scores := []int{}
	passCount := 0
	for i := 0; i < n; i++ {
		in.Scan()
		scr, _ := strconv.Atoi(in.Text())
		scores = append(scores, scr)
	}
	pass := scores[n-k]

	sort.Ints(scores)
	for _, val := range scores {
		if val > 0 && val >= pass {
			passCount++
		}
	}
	fmt.Println(passCount)


package main

import (
  "fmt"
)

func main(){
  var n, m int
  fmt.Scanf("%d\n", &n)
  var s int
  var scores []int
  for j := 0; j<n; j++ {
    fmt.Scanf("%d\n", &s)
    append(scores, s)
  }
  var num int
  for i, v := range scores{
    if(v>m)
      num++
  }
  fmt.Println(num)
}


package main

import (
    "fmt"
)

func main() {
  var n, k, border int

  fmt.Scanf("%d %d", &n, &k)

  ints := make([]interface{}, 50)
  vals := make([]int, len(ints))

  for i, _ := range ints {
      ints[i] = interface{}(&vals[i])
  }
  fmt.Scan(ints...)

  border := vals[k]
  num := 0

  if border == 0 {
    fmt.Println(0)
  } else {
    for i, _ := range vals {
      if vals[i] < border {
        num++
      }
    }
    fmt.Println(num)
  }

  //fmt.Println(vals)
  //fmt.Println(n, k)
}


package main

import (
    "fmt"
)

const (
    maxn = 55
)

var arr = [maxn]int{}

func main() {
    var n, k int
    fmt.Scan(&n, &k)
    for i := 0; i < n; i++ {
        fmt.Scan(&a[i])
    }
    var ans int
    for i := 0; i < n; i++ {
        if a[i] > 0 && a[i] >= a[k-1] {
            ans++
        }
    }
    fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func main() {
	in := bufio.NewSc           anner(os.Stdin)
	in.Split(bufio.ScanWords)
	in.Scan()
	n, _ := strconv.Atoi(in.Text())
	in.Scan()
	k, _ := strconv.Atoi(in.Text())
	scores := []int{}
	passCount := 0
	for i := 0; i < n; i++ {
		in.Scan()
		scr, _ := strconv.Atoi(in.Text())
		scores = append(scores, scr)
	}
	pass := scores[n-k]

	sort.Ints(scores)
	for _, val := range scores {
		if val > 0 && val >= pass {
			passCount++
		}
	}
	fmt.Println(passCount)
}


package main

import (
    "fmt"
)

const (
    maxn = 55
)

var a [maxn]int

func main() {
    var n, k int
    fmt.Scan(&n, &k)
    for i := 0; i < n; i++ {
        fmt.Scan(&a[i])
    }
    var ans int
    for i := 0; i < n; i++ {
        if a[i] > 0 && a[i] >= a[k-1] {
            ans++
        }
    }
    var sc = fmt.Println(ans)
}


package main

import (
    "fmt"
)

const (
    maxn = 55
)

var arr = [maxn]int

func main() {
    var n, k int
    fmt.Scan(&n, &k)
    for i := 0; i < n; i++ {
        fmt.Scan(&a[i])
    }
    var ans int
    for i := 0; i < n; i++ {
        if a[i] > 0 && a[i] >= a[k-1] {
            ans++
        }
    }
    fmt.Println(ans)
}


package main

import (
  "fmt"
)

func main(){
  var n, m int
  fmt.Scanf("%d\n", &n)
  var s int
  var scores []int
  for j := 0; j<n; j++ {
    fmt.Scanf("%d\n", &s)
    append(scores, s)
  }
  num := 0
  for -, v := range scores{
    if(v>m){num++}

  }
  fmt.Println(num)
}


package main

import (
  "fmt"
)

func main(){
  var n, m int
  fmt.Scanf("%d\n", &n)
  var s int
  var scores []int
  for j := 0; j<n; j++ {
    fmt.Scanf("%d\n", &s)
    append(scores, s)
  }
  num := 0
  for i, v := range scores{
    if(v>m)
      num++
  }
  fmt.Println(num)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func I(i interface{}, delim string) error {
	_, err := fmt.Fscanf(r, "%v"+delim, i)
	return err
}

func O(o interface{}, delim string) {
	fmt.Fprintf(w, "%v"+delim, o)
}

var (
	r *bufio.Reader
	w *bufio.Writer
)

func init() {
	if f, err := os.Open("in.txt"); err == nil {
		r = bufio.NewReader(f)
	} else {
		r = bufio.NewReader(os.Stdin)
	}
	w = bufio.NewWriter(os.Stdout)
}

func main() {
	defer w.Flush()
	var s string
	for I(&s, "\n") == nil {
		solve(s)
	}
}

func solve(s string) {
	a := "AEIOUY"
	p, m := 0, 0
	for i, c := range s {
		p++
		if strings.ContainsRune(a, rune(c)) || i == len(s)-1 {
			if m < p {
				m = p
			}


package main

import "fmt"

func main() {
    var s string
    fmt.Scan(&s)
    min, cur := 0, 0
    for _, c := range s {
        if c == "A" || c == "E" || c == "I" || c == "O" || c == "U" || c == "Y" {
            if min < cur+1 {
                min = cur+1
            }
            cur = 0
        } else {
            cur++
        }
    }
    if min < cur+1 {
        min = cur+1
    }
    fmt.Print(min)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	sp := []int{a, b}
	sort.Ints(mas)
	k := sp[0]
	k2 := (sp[1] - sp[0]) / 2
	fmt.Println(k, k2)
}


package main
import (
	"fmt"
)

func shot(dragons []bool, d int) {
	for i := d; i <= len(dragons); i += d {
		dragons[i-1] = true
	}
}

func main() {
	var k, l, m, n, d int
	fmt.Scan(&k, &l, &m, &n, &d)
	dragons := make([]bool, d)
	for _, v := range []int{k,l,m,n} {
		shot(dragons, v)
	}
	count := 0
	for _, el := range dragons {
		if el {
			count++
		}
	}
	//fmt.Println(dragons)
	fmt.Println(count)
}


package main

import (
	"fmt"
)

func solve(t, s, x int) bool {
	if x <= t {
		return t == x
	}

	delta := x - t
	return delta%s == 0 || (delta/s >= 1 && delta%s == 1)
}

func main() {
	var t, s, x int
	fmt.Scan(&t, &s, &x)
	if solve(t, s, x) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import (
	"fmt"
)

func solve(t, s, x int) bool {
	if x <= t {
		return t == x
	}

	delta := x - t
	return (delta%s) == 0 || (delta/s >= 1 && delta%s == 1)
}

func main() {
	var t, s, x int
	fmt.Scan(&t, &s, &x)
	if solve(t, s, x) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


// You can edit this code!
// Click here and start typing.
package main

import "fmt"
import "strconv"
import "os"
import "bufio"

func main() {
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)

	s.Scan()
	start := strconv.Atoi(s.Text())
	s.Scan()
	every := strconv.Atoi(s.Text())
	s.Scan()
	eat := strconv.Atoi(s.Text())

	if eat == start {
		fmt.Println("YES")
	}

	for i := start + every; i <= eat; i += every {
		if eat == i || eat == i+1 {
			fmt.Println("YES")
			os.Exit(0)
		}
	}

	fmt.Println("NO")

}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func solve() {
	readInt()
	a := []rune(readString())
	d := map[rune]int{}
	best := 0
	for i := 0; i < len(a); i++ {
		if a[i] >= 'A' && a[i] <= 'Z' {
			if len(d) > 0 {
				d = map[rune]int{}
			}
		} else {
			d[a[i]]++
			best = max(best, len(d))
		}
	}
	fmt.Println(best)
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// IO

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}

func readIntArray(sz int) []int {
	a := make([]int, sz)
	for i := 0; i < sz; i++ {
		a[i] = readInt()
	}
	return a
}

func readInt64Array(n int) []int64 {
	res := make([]int64, n)
	for i := 0; i < n; i++ {
		res[i] = readInt64()
	}
	return res
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }

func getLine() string {
	s, _ := reader.ReadString('\n')
	if strings.HasSuffix(s, "\r\n") {
		s = s[:len(s)-2]
	} else if strings.HasSuffix(s, "\n") {
		s = s[:len(s)-1]
	}
	return s
}
func getLine2Int() (n int) {
	scanf("%d\n", &n)
	return
}
func getLine2Int2() (a, b int) {
	scanf("%d %d\n", &a, &b)
	return
}
func getLine2Ints(n int) []int {
	ans := make([]int, n)
	for i := 0; i < n; i++ {
		scanf("%d ", &ans[i])
	}
	scanf("%d\n", &ans[n-1])
	return ans
}

func pcheck(i bool) {
	if i {
		printf("YES\n")
	} else {
		printf("NO\n")
	}
}

var debug = true

func see(a interface{}) {
	if debug {
		printf("DEBUG:%v\n", a)
	}
}

func main() {
	defer writer.Flush()

	var h1, m1, h2, m2 int
	scanf("%d:%d\n%d:%d\n", &h1, &m1, &h2, &m2)
	m := ((h1+h2)*60 + m1 + m2) / 2
	printf("%02d:%02d\n", m/60, m%60)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type tStrct struct {
	days, index int
}

type tArray []tStrct

func (l tArray) Len() int {
	return len(l)
}
func (l tArray) Less(i, j int) bool {
	return l[i].days < l[j].days
}
func (l tArray) Swap(i, j int) {
	l[i], l[j] = l[j], l[i]
}

var readWriter = bufio.NewReadWriter(
	bufio.NewReader(os.Stdin),
	bufio.NewWriter(os.Stdout))

func main() {
	defer readWriter.Flush()
	var n, k, a int
	fmt.Fscan(readWriter, &n, &k)
	l := make(tArray, n+1)
	for i := 0; i < n; i++ {
		fmt.Fscan(readWriter, &a)
		l[i] = tStrct{a, i+1}
	}
	l[n].days = 1<<30
	sort.Sort(l)
	for i, cur := range l {
		k -= cur.days
		if k < 0 {
			a = i
			break
		}
	}
	fmt.Fprintln(readWriter, a)
	for _, cur := range l[:a] {
		fmt.Fprint(readWriter, cur.index, " ")
	}


package main

import "fmt"

func main() {
    var n, k int
    fmt.Scanf("%d %d\n", &n, %k)
    for i := 0; i < k; i++ {
        if n % 10 == 0 {
            n = n / 10
        } else {
            n--
        }
    }
    fmt.Println(n)
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

var (
	readString func() string
	readBytes  func() []byte
	stdout     *bufio.Writer
)

func init() {
	readString, readBytes = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) (func() string, func() []byte) {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)

	f1 := func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
	f2 := func() []byte {
		return []byte(f1())
	}
	return f1, f2
}

func readInt() int {
	return int(readInt64())
}

func readInt64() int64 {
	i, err := strconv.ParseInt(readString(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(readString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(stdout, f, args...)
}

func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(stdout, args...)
}

func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func abs64(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

func gcd64(a, b int64) int64 {
	if b == 0 {
		return a
	}
	return gcd64(b, a%b)
}

// readString() string
// readInt() int
// readInt64() int64
// readFloat64() float64

// -----------------------------------------------------------------------------

func main() {
	defer stdout.Flush()
	n:=readInt();
	k:=readInt();

	var ans int = n
	for i := 0; i < k; i++ {
		if ans%10 == 0 {
			ans/=10
		} else {
			ans--
		}
	}
	println(ans)
}

// -----------------------------------------------------------------------------


package main

import (
  "fmt"
)
func dec(n int) int {
    if n<=0{
        return 0
    }
    if n%10 == 0 {
        return n/10
    }
    return n--;
}
func main() {
    var n, k int
    fmt.Scanf("%d", &n)
    fmt.Scanf("%d", &k)
    for ;k-->0;{
        n = dec(n);
    }

    fmt.Printf("%d", n)
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

var (
	readString func() string
	readBytes  func() []byte
	stdout     *bufio.Writer
)

func init() {
	readString, readBytes = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) (func() string, func() []byte) {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)

	f1 := func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
	f2 := func() []byte {
		return []byte(f1())
	}
	return f1, f2
}

func readInt() int {
	return int(readInt64())
}

func readInt64() int64 {
	i, err := strconv.ParseInt(readString(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(readString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(stdout, f, args...)
}

func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(stdout, args...)
}

func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func abs64(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

func gcd64(a, b int64) int64 {
	if b == 0 {
		return a
	}
	return gcd64(b, a%b)
}

// readString() string
// readInt() int
// readInt64() int64
// readFloat64() float64

// -----------------------------------------------------------------------------

func main() {
	defer stdout.Flush()
	n := readInt64()
	k := readInt()

	var ans int64 = n
	for i := 0; i < k; i++ {
		if ans%10 == 0 {
			ans /= 10
		} else {
			ans--
		}
	}
	println(ans)
}

// -----------------------------------------------------------------------------


import "fmt"

func main() {

	var n, k int
	_, _ = fmt.Scan(&n, &k)

	for i := 0; i < k; i++ {
		if n%10 == 0 {
			n /= 10
		} else {
			n--
		}
	}

	fmt.Println(n)

}


import "fmt"

func main(){
    fmt.Println("hi")

}


//A. Wrong Subtraction

/*
Little girl Tanya is learning how to decrease a number by one, but she does it wrong with a number consisting of two or more digits. Tanya subtracts one from a number by the following algorithm:

    if the last digit of the number is non-zero, she decreases the number by one;
    if the last digit of the number is zero, she divides the number by 10 (i.e. removes the last digit).

You are given an integer number 𝑛
. Tanya will subtract one from it 𝑘 times. Your task is to print the result after all 𝑘

subtractions.

It is guaranteed that the result will be positive integer number.
Input

The first line of the input contains two integer numbers 𝑛
and 𝑘 (2≤𝑛≤109, 1≤𝑘≤50

) — the number from which Tanya will subtract and the number of subtractions correspondingly.
Output

Print one integer number — the result of the decreasing 𝑛
by one 𝑘

times.

It is guaranteed that the result will be positive integer number.

Examples
Input
512 4

Output
50

Input
1000000000 9

Output
1

Note: The first example corresponds to the following sequence: 512→511→510→51→50
*/
package main

import (
	assert "github.com/rnd"
)

func main() {
	assert.Assert(substract(512, 4), 50)
	assert.Assert(substract(1000000000, 9), 1)
}

func substract(n, k int) int {
	for i := 0; i < k; i++ {
		if n%10 == 0 {
			n /= 10
		} else {
			n--
		}
	}
	return n
}


import "fmt"

func main() {
    var n, k int
    fmt.Scanf("%d %d\n", &n, %k)
    for i := 0; i < k; i++ {
        if n % 10 == 0 {
            n = n / 10
        } else {
            n--
        }
    }
    fmt.Println(n)
}


package main

import "fmt"

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
	  runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
  }

func main(){
	var x, y string

	fmt.Scanf("%s\n%s", &x, &y)

	c := reverse(x)

	if c == y {
		fmt.Println("YES")
	}else{
		fmt.Println("NO")
	}


package main

import (
    "fmt"
    "unicode"
    "unicode/utf8"
)

// no encoding
func reverseBytes(s string) string {
    r := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        r[i] = s[len(s)-1-i]
    }
    return string(r)
}

// reverseCodePoints interprets its argument as UTF-8 and ignores bytes
// that do not form valid UTF-8.  return value is UTF-8.
func reverseCodePoints(s string) string {
    r := make([]rune, len(s))
    start := len(s)
    for _, c := range s {
        // quietly skip invalid UTF-8
        if c != utf8.RuneError {
            start--
            r[start] = c
        }
    }
    return string(r[start:])
}

// reversePreservingCombiningCharacters interprets its argument as UTF-8
// and ignores bytes that do not form valid UTF-8.  return value is UTF-8.
func reversePreservingCombiningCharacters(s string) string {
    if s == "" {
        return ""
    }
    p := []rune(s)
    r := make([]rune, len(p))
    start := len(r)
    for i := 0; i < len(p); {
        // quietly skip invalid UTF-8
        if p[i] == utf8.RuneError {
            i++
            continue
        }
        j := i + 1
        for j < len(p) && (unicode.Is(unicode.Mn, p[j]) ||
            unicode.Is(unicode.Me, p[j]) || unicode.Is(unicode.Mc, p[j])) {
            j++
        }
        for k := j - 1; k >= i; k-- {
            start--
            r[start] = p[k]
        }
        i = j
    }
    return (string(r[start:]))
}

func main() {
    fmt.Scanln(s)
    fmt.Scanln(r)
    if r = reverseCodePoints(s){
       fmt.Println("YES")
    }
    else {fmt.Println("NO")
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	arr := gsls(reader)
	rot := gsli(reader)[0]

	start := pos(arr[0])
	end := pos(arr[1])

	// fmt.Printf("arr: %#v \n rot: %#v \n start: %v \n end: %v", arr, rot, start, end)

	cwEnd := posMod(start+rot, 4)
	ccwEnd := posMod(start-rot, 4)

	diff := posMod(end-start, 4)

	if diff == 0 || diff == 2 {
		fmt.Print("undefined")
	} else if end == cwEnd {
		fmt.Print("cw")
	} else if end == ccwEnd {
		fmt.Print("ccw")
	} else {
		fmt.Printf("cwEnd = %v, ccwEnd = %v", cwEnd, ccwEnd)
	}
	return
}

func pos(x string) (pos int) {
	switch x {
	case "^":
		pos = 0
	case ">":
		pos = 1
	case "v":
		pos = 2
	case "<":
		pos = 3
	}

	return
}

// Input helpers

// If you don't pass in a reference to the reader, and just instantiate a new
// one every time, it will work locally, with IO typed at human-speed, but not
// on Codeforces.

// Get Space-separated Line as Strings
//
// Example input:
// 1 test 382.0
// Example output:
// ["1", "test", "382.0"]

func gsls() (arr []string) {
	// Get a full line
	reader := bufio.NewReader(os.Stdin)
	input, _ := reader.ReadString('\n')

	//Strip newline and return chars, if any
	input = strings.TrimSuffix(input, "\n")
	input = strings.TrimSuffix(input, "\r")

	// Split at the spaces into an array
	arr = strings.Split(input, " ")

	return
}

// Get Space-separated Line as Integers
// Any non-valid integers will be 0
//
// Example input:
// test 1 12.3 -117
// Example output:
// [0, 1, 0, -117]

func gsli(reader *bufio.Reader) (arr []int) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.Atoi(e)
		arr = append(arr, cur)
	}

	return
}

// Get Space-separated Line as 64-bit Floats
// Any non-valid floats will be 0
//
// Example input:
// test 128.328 12 -11.0
// Example output:
// [0, 128.328, 12, -11]

func gslf(reader *bufio.Reader) (arr []float64) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.ParseFloat(e, 64)
		arr = append(arr, cur)
	}

	return
}

// Math helpers

// Positve Modulo
// Returns x mod y, but always positive

func posMod(x, y int) int {
	return (x%y + y) % y
}


package main

import "fmt"

func main() {
    var n int64
    fmt.Scan(&n)

    p := 1
    if n % 2 == 1 {
        p = -1
    }

    fmt.Println(((n + 1) / 2) * p)
}


package main

import (
	"fmt"
	"os"
	"sort"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	rs := Problem486A()
	printf("%d", rs)
}

func Problem486A() int {
	var n int
	scanf("%d\n", &n)
	if n % 2 > 0 {
		return (( n + 1 ) / 2 ) - ( ( ( n + 1 ) / 2 ) * 2 )
	}else {
		return n / 2
	}
}

func printf(format string, x ...interface{}) {
	fmt.Fprintf(os.Stdout, format, x...)
}

func scanf(format string, x ...interface{}) {
	if _, err := fmt.Fscanf(os.Stdin, format, x...); err != nil {
		panic(err)
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	var n uint64
	var c int64
	fmt.Fscanf(in, "%d\n", &n)
	for i:=1; uint32(i) <= n; i++{
		if i % 2 != 0{
			c -= int32(i);
		}else{
			c += int32(i);
		}
	}
	fmt.Println(c)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scan(&s)
    var howmanya = strings.Count(s, "a")
	var long = len(s)
	if 2*howmanya > long {
		fmt.Print(long)
	}
    else {
		fmt.Print(howmanya * 2 - 1)
	}
}


// Codeforces helper functions
// 20 Jan 18
// samadhi

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
	"unicode"
)

const debug = true

func main() {
	reader := bufio.NewReader(os.Stdin)

}

// Input helpers

// If you don't pass in a reference to the reader, and just instantiate a new
// one every time, it will work locally, with IO typed at human-speed, but not
// on Codeforces.

// Get Space-separated Line as Strings
//
// Example input:
// 1 test 382.0
// Example output:
// ["1", "test", "382.0"]

func gsls(reader *bufio.Reader) (arr []string) {
	// Get a full line
	input, _ := reader.ReadString('\n')

	//Strip newline and return chars, if any
	input = strings.TrimSuffix(input, "\n")
	input = strings.TrimSuffix(input, "\r")

	// Split at the spaces into an array
	arr = strings.Split(input, " ")

	return
}

// Get Space-separated Line as Integers
// Any non-valid integers will be 0
//
// Example input:
// test 1 12.3 -117
// Example output:
// [0, 1, 0, -117]

func gsli(reader *bufio.Reader) (arr []int) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.Atoi(e)
		arr = append(arr, cur)
	}

	return
}

// Get Space-separated Line as 64-bit Floats
// Any non-valid floats will be 0
//
// Example input:
// test 128.328 12 -11.0
// Example output:
// [0, 128.328, 12, -11]

func gslf(reader *bufio.Reader) (arr []float64) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.ParseFloat(e, 64)
		arr = append(arr, cur)
	}

	return
}

// String helpers

// Is Lowercase
// Given some string[i], return whether it is lower case or not.

func isl(b byte) bool {
	var r rune
	r = rune(b)
	return unicode.IsLower(r)
}

// Math helpers

// Positve Modulo
// Returns x mod y, but always positive

func posMod(x, y int) int {
	return (x%y + y) % y
}

// Max Int
// Returns the max of two ints

func maxInt(x, y int) int {
	if x > y {
		return x
	}
	return y
}

// Distance formule
// Calculates the distance to the origin

func dist(x, y float64) float64 {
	return math.Sqrt(math.Pow(x, 2) + math.Pow(y, 2))
}

// Output helpers

func yes() {
	fmt.Println("Yes")
}

func no() {
	fmt.Println("No")
}

// Debug helpers

// From https://groups.google.com/forum/#!topic/golang-nuts/Qlxs3V77nss

func dbg(s string, a ...interface{}) {
	if debug {
		fmt.Printf(s, a...)
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
)

reader := bufio.NewReader(os.Stdin)
writer := bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(writer, f, a...) }

func main() {
	// FLUSH STDOUT
	defer writer.Flush()

	var a int
	scanf("%d\n", &a)

	if a%2 == 1 {
		printf("Ehab\n")
	} else {
		printf("Mahmoud\n")
	}

}


// Codeforces helper functions
// 20 Jan 18
// samadhi

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
	"unicode"
)

const debug = true

func main() {
	reader := bufio.NewReader(os.Stdin)

	n := gsli(reader)[0]

	if n%2 == 0 {
		fmt.Println("Mahmoud")
	} else {
		fmt.Println("Ehab")
	}

}

}

// Input helpers

// If you don't pass in a reference to the reader, and just instantiate a new
// one every time, it will work locally, with IO typed at human-speed, but not
// on Codeforces.

// Get Space-separated Line as Strings
//
// Example input:
// 1 test 382.0
// Example output:
// ["1", "test", "382.0"]

func gsls(reader *bufio.Reader) (arr []string) {
	// Get a full line
	input, _ := reader.ReadString('\n')

	//Strip newline and return chars, if any
	input = strings.TrimSuffix(input, "\n")
	input = strings.TrimSuffix(input, "\r")

	// Split at the spaces into an array
	arr = strings.Split(input, " ")

	return
}

// Get Space-separated Line as Integers
// Any non-valid integers will be 0
//
// Example input:
// test 1 12.3 -117
// Example output:
// [0, 1, 0, -117]

func gsli(reader *bufio.Reader) (arr []int) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.Atoi(e)
		arr = append(arr, cur)
	}

	return
}

// Get Space-separated Line as 64-bit Floats
// Any non-valid floats will be 0
//
// Example input:
// test 128.328 12 -11.0
// Example output:
// [0, 128.328, 12, -11]

func gslf(reader *bufio.Reader) (arr []float64) {
	stringArr := gsls(reader)

	for _, e := range stringArr {
		cur, _ := strconv.ParseFloat(e, 64)
		arr = append(arr, cur)
	}

	return
}

// String helpers

// Is Lowercase
// Given some string[i], return whether it is lower case or not.

func isl(b byte) bool {
	var r rune
	r = rune(b)
	return unicode.IsLower(r)
}

// Math helpers

// Positve Modulo
// Returns x mod y, but always positive

func posMod(x, y int) int {
	return (x%y + y) % y
}

// Max Int
// Returns the max of two ints

func maxInt(x, y int) int {
	if x > y {
		return x
	}
	return y
}

// Distance formule
// Calculates the distance to the origin

func dist(x, y float64) float64 {
	return math.Sqrt(math.Pow(x, 2) + math.Pow(y, 2))
}

// Output helpers

func yes() {
	fmt.Println("Yes")
}

func no() {
	fmt.Println("No")
}

// Debug helpers

// From https://groups.google.com/forum/#!topic/golang-nuts/Qlxs3V77nss

func dbg(s string, a ...interface{}) {
	if debug {
		fmt.Printf(s, a...)
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	year, _ := reader.ReadString('\n')
	isUnique := false
	for !isUnique {
		year++
		s := strconv.Itoa(year)
		for _, val := range s {
			if strings.Count(s, string(val)) < 2 {
				isUnique = true
			} else {
				isUnique = false
				break
			}
		}
		if isUnique {
			break
		}
	}
	if isUnique {
		fmt.Println(year)
	}

}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	year, _ := reader.ReadString('\n')
	year = strings.TrimSuffix(year, "\n")
	isUnique := false
	for !isUnique {
		fmt.Println(year)
		yearInt, err := strconv.ParseInt(year, 10)
		fmt.Println(yearInt, year, err)
		yearInt++
		year = strconv.Itoa(yearInt)
		for _, val := range year {
			if strings.Count(year, string(val)) < 2 {
				isUnique = true
			} else {
				isUnique = false
				break
			}
		}
		fmt.Println(year, isUnique)
		if isUnique {
			fmt.Print(yearInt)
			break
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	year, _ := reader.ReadString('\n')
	year = strings.TrimSuffix(year, '\n')
	isUnique := false
	for !isUnique {
		fmt.Println(year)
		yearInt, err := strconv.Atoi(year)
		fmt.Println(yearInt, year, err)
		yearInt++
		year = strconv.Itoa(yearInt)
		for _, val := range year {
			if strings.Count(year, string(val)) < 2 {
				isUnique = true
			} else {
				isUnique = false
				break
			}
		}
		fmt.Println(year, isUnique)
		if isUnique {
			fmt.Print(yearInt)
			break
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	year, _ := reader.ReadString('\n')
	isUnique := false
	for !isUnique {
		yearInt, _ := strconv.Atoi(year)
		yearInt++
		s := strconv.Itoa(yearInt)
		for _, val := range s {
			if strings.Count(s, string(val)) < 2 {
				isUnique = true
			} else {
				isUnique = false
				break
			}
		}
		if isUnique {
			break
		}
	}
	if isUnique {
		fmt.Print(yearInt)
	}

}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	year, _ := reader.ReadString('\n')
	isUnique := false
	for !isUnique {
		year++
		for _, val := range year {
			if strings.Count(year, string(val)) < 2 {
				isUnique = true
			} else {
				isUnique = false
				break
			}
		}
		if isUnique {
			break
		}
	}
	if isUnique {
		fmt.Println(year)
	}

}


package main

import (
	"bufio"
	"fmt"
	"os"

	"github.com/golang-collections/collections/set"
)

var s string

func main() {
	stdin := os.Stdin
	// stdin, _ = os.Open("1.in")
	reader := bufio.NewReaderSize(stdin, 1<<20)
	fmt.Fscanf(reader, "%s\n", &s)

	S := set.New()
	for i := 0; i < len(s); i++ {
		S.Insert(s[i])
	}

	if S.Len()%2 == 1 {
		fmt.Println("IGNORE HIM!")
	} else {
		fmt.Println("CHAT WITH HER!")
	}
}


package main

import (
	"fmt"

	"github.com/emirpasic/gods/sets/hashset"
)

func main() {
	var s string
	fmt.Scan(&s)
	st := hashset.New()
	for i := range s {
		st.Add(s[i])
	}
	if st.Size()%2 == 0 {
		fmt.Print("CHAT WITH HER!")
	} else {
		fmt.Print("IGNORE HIM!")
	}

}


/* https://codeforces.com/problemset/problem/236/A
A. Boy or Girl
time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Those days, many boys use beautiful girls' photos as avatars in forums. So it is pretty hard to tell the gender of a user at the first glance. Last year, our hero went to a forum and had a nice chat with a beauty (he thought so). After that they talked very often and eventually they became a couple in the network.

But yesterday, he came to see "her" in the real world and found out "she" is actually a very strong man! Our hero is very sad and he is too tired to love again now. So he came up with a way to recognize users' genders by their user names.

This is his method: if the number of distinct characters in one's user name is odd, then he is a male, otherwise she is a female. You are given the string that denotes the user name, please help our hero to determine the gender of this user by his method.

Input
The first line contains a non-empty string, that contains only lowercase English letters — the user name. This string contains at most 100 letters.

Output
If it is a female by our hero's method, print "CHAT WITH HER!" (without the quotes), otherwise, print "IGNORE HIM!" (without the quotes).

Examples
inputCopy
wjmzbmr
outputCopy
CHAT WITH HER!
inputCopy
xiaodao
outputCopy
IGNORE HIM!
inputCopy
sevenkplus
outputCopy
CHAT WITH HER!
Note
For the first example. There are 6 distinct characters in "wjmzbmr". These characters are: "w", "j", "m", "z", "b", "r". So wjmzbmr is a female and you should print "CHAT WITH HER!".
*/

package main

import (
	"fmt"
	"strings"

	"github.com/mpvl/unique"
)

func main() {
	// define input variable
	var name string

	// take input variable
	fmt.Scanln(&name)

	// convert input string to slice for unique.Strings
	split_name := strings.Split(name, "")

	// reduce slice to distinct characters
	unique.Strings(&split_name)

	// check if the length of the distinct characters in the slice is even or odd and print output
	if len(split_name)%2 == 0 {
		fmt.Println("CHAT WITH HER!")
	} else {
		fmt.Println("IGNORE HIM!")
	}
}


package main

import (
	"os"
	"bufio"
	"strconv"
	"fmt"
	"math"
)

var scanner *bufio.Scanner

func getI64() int64 {
	scanner.Scan()
	x, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return x
}
func getI() int {
	return int(getI64())
}
func getF() float64 {
	scanner.Scan()
	x, _ := strconv.ParseFloat(scanner.Text(), 64)
	return x
}
func getS() string {
	scanner.Scan()
	return scanner.Text()
}

func max(a,b int) int { if a > b { return a } else { return b } }

func min(a,b int) int { if a < b { return a } else { return b } }

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	writer.WriteString(fmt.Sprintf("%s", Problem705A()))
}

func Problem705A() string {
	n := getI64()
	x := getI64()
	y := getI64()

	if (x-1 + y-1) <= (n-x + n-y) {
		return "White"
	} else {
		return "Black"
	}
}


package main

import (
	"fmt"
	"math"
)

func main() {
	n,m:=0,0
	fmt.Scanln(&n,&m)
	// fmt.Println(n,m)
	ans:=math.MaxInt64
	for i := 0; i <= n; i++ {
		for j := 0; j <= n; j++{
			for k := 0; k <= n; k++ {
				for l := 0; l <= n; l++ {
					if i+j+k+l==n && 2*i+3*j+4*k+5*l==m{
						if i<ans{
							ans=i
						}
					}
				}
			}
		}
	}
	fmt.Println(ans)

}


package main

import(
	"fmt"
)

func chk(a int) (bool){
	sum :=0 ;
	for; a!=0 ; a/=10{24
		sum+=a%10
	}
	if(sum%4==0){
		return true;
	}
	return false;
}

func main(){
	var a int
	fmt.Scanf("%d",&a)
	for ;!chk(a); a++{}
	fmt.Printf("%d",a)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s\n", &s)
	strings.ToLower(s)
	for i:=0; i<len(s); i++{
	      if(s[i]=='a' || s[i]=='o' || s[i]=='u' || s[i]=='i' || s[i]=='y' || s[i]=='e' ){
	            s[i] = '.'
	      }
	}
	fmt.Println(".%s", s)
}


package main

import (
        "fmt"
        "strings"
)

func main() {
    var i int
    var s string
    fmt.Scan(&s)
    s=strings.ToLower(s)
    for(i=0;i<len(s);i++) {
        if(s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u') {
            continue
        } else {
            fmt.Printf("%c%c",'.',s[i])
        }
    }
    fmt.Println()
}


package main

import (
        "fmt"
        "strings"
)

func main() {
    var s string
    fmt.Scan(&s)
    s=strings.ToLower(s)
    for(i=0;i<len(s);i++) {
        if(s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u') {
            continue
        } else {
            fmt.Printf("%c%c",'.',s[i])
        }
    }
    fmt.Println()
}


package main

import (
	"fmt"
	"unicode"
)

func isVowel(letter rune) bool {
	if letter == 'a' || letter == 'e' || letter == 'i' || letter == 'o' || letter == 'u' || letter == "y" {
		return true
	}
	return false
}

func getManuplatedString(someString string) string {
	var constructedString string

	for _, letter := range someString {
		lowerLetter := unicode.ToLower(letter)
		if isVowel(lowerLetter) {
			continue
		}
		constructedString = constructedString + "." + string(lowerLetter)
	}

	return constructedString
}

func main() {
	var someString string
	fmt.Scan(&someString)

	fmt.Println(getManuplatedString(someString))

}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s\n", &s)
	strings.ToLower(s)
	for i:=0; i<len(s): i++{
	      if(s[i]=="a" || s[i]=="o" || s[i]=="u" || s[i]=="i" || s[i]=="y" || s[i]=="e" )
	      {
	            s[i] = "."
	      }
	}
}


package main

import "fmt"
import "strings"

func main() {
    for {
        s, t := "", ""
        n, _ := fmt.Scanf("%s\n", &s)

        if n == 0 {
            break
        }

        for i := 0; i < len(s); i++ {
            switch s[i] {
                case 'a', 'e', 'i', 'o', 'u', 'y'
                     'A', 'E', 'I', 'O', 'U', 'Y':
                default:
                    t = t + "." + string(s[i])
            }
        }

        t = strings.ToLower(t)
        fmt.Println(t)
    }
}


package main
import (
    “bufio”
    “fmt”
    “os”
    “strings”
)
func main() {
    reader := bufio.NewReader(os.Stdin)
    text, _ := reader.ReadString(‘\n’)
    text = strings.ToLower(text)
    vocales := []string{“a”, “e”, “i”, “o”, “u”, “y”}
    for _, v := range vocales {
        if strings.Contains(text, v) == true {
            text = strings.Replace(text, v, “”, -1)
        }
    }
    text = strings.TrimSpace(text)
    textSlice := strings.Split(text, “”)
    newtextslice := []string{}
    for _, ts := range textSlice {
        ts = “.” + ts
        newtextslice = append(newtextslice, ts)
    }
    finalText := strings.Join(newtextslice, “”)
    fmt.Println(finalText)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s\n", &s)
	strings.ToLower(s)
	for i:=0; i<len(s): i++{
	      if(s[i]=="a" || s[i]=="o" || s[i]=="u" || s[i]=="i" || s[i]=="y" || s[i]=="e" )
	      {
	            s[i] = "."
	      }
	}
	fmt.Pringtln(s)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s\n", &s)
	strings.ToLower(s)
	for i:=0; i<len(s): i++{
	      if(s[i]=="a" || s[i]=="o" || s[i]=="u" || s[i]=="i" || s[i]=="y" || s[i]=="e" ){
	            s[i] = "."
	      }
	}
	fmt.Println(".%s", s)
}


 package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s\n", &s)
	strings.ToLower(s)
	for i:=0; i<len(s); i++{
	      if(s[i]=="a" || s[i]=="o" || s[i]=="u" || s[i]=="i" || s[i]=="y" || s[i]=="e" ){
	            s[i] = "."
	      }
	}
	fmt.Println(".%s", s)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var in string
	fmt.Scanf("%s\n", &in)
	in = strings.ToLower(in)
	var flag bool
	if(in[0]=="a"||in[0]=="o"||in[0]=="u"||in[0]=="i"||in[0]=="y"||in[0]=="e"){
	      flag =true
	}
	in = strings.Replace(in, "a", ".", -1)
	in = strings.Replace(in, "o", ".", -1)
	in = strings.Replace(in, "u", ".", -1)
	in = strings.Replace(in, "i", ".", -1)
	in = strings.Replace(in, "y", ".", -1)
	in = strings.Replace(in, "e", ".", -1)
	in = strings.Replace(in, "..", ".", -1)

	if(strings.Contains(s, "..")){
	      fmt.Println(string('.')+ in)
	}

}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s, r string
	fmt.Scan(&s)
	if strings.ContainsAny(s, "HQ9") {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


package main

import "fmt"

func main() {
    var n int
    fmt.Scan(&n)
    groups := make([]int, n)
    var s string
    fmt.Scan(&s)
    s += 'W'
    var lastRune rune = 'W'
    var groupCnt int
    var curGroup int
    for _, r := range s {
        if r == 'B' {
            curGroup++
            if lastRune == 'W' {
                groupCnt++
            }
            lastRune = 'B'
        } else if r == 'W' {
            if lastRune == 'B' {
                groups[groupCnt-1] = curGroup
            }
            lastRune = 'W'
            curGroup = 0
        }
    }
    fmt.Print(groupCnt, "\n")
    for i:=0; i < groupCnt; i++ {
        fmt.Print(groups[i], " ")
    }
}


package main

import (
	//"bytes"
	"fmt"
	//"strconv"
)

func Max(n int, g int) int {
	if n > g {
		return n
	} else {
		return g
	}
}

func Min(n int, g int) int {
	if n > g {
		return g
	} else {
		return n
	}
}

func main() {
	var f string

	var str, goal string
	//var buffer bytes.Buffer

	fmt.Scan(&goal)
	fmt.Scan(&str)

	pos, neg, q, g := 0, 0, 0, 0

	for i := 0; i < len(str); i++ {
		if str[i] == '+' {
			pos++
		} else if str[i] == '-' {
			neg++
		} else {
			q++
		}

		if goal[i] == '+' {
			g++
		} else if goal[i] == '-' {
			g--
		}
	}

	init := pos - neg

	if (g == init) && (q == 0) {
		println(1)
		return
	}

	ans := 0
	amount := 1 << uint(q)

	for i := 0; i < 1<<uint(q); i++ {
		val := 0

		for j := 0; j < q; j++ {
			if (i>>uint(j))&1 > 0 {
				val++
			} else {
				val--
			}
		}

		val += init

		if val == g {
			ans++
		}
	}

	answ := float32(ans)
	answ /= float32(amount)

	fmt.Printf("%.9f", answ)
}


package main

import (
	//"bytes"
	"fmt"
	//"strconv"
)

func Max(n int, g int) int {
	if n > g {
		return n
	} else {
		return g
	}
}

func Min(n int, g int) int {
	if n > g {
		return g
	} else {
		return n
	}
}

func main() {
	//var f string

	var str, goal string
	//var buffer bytes.Buffer

	fmt.Scan(&goal)
	fmt.Scan(&str)

	pos, neg, g := 0, 0, 0

	var q uint

	for i := 0; i < len(str); i++ {
		if str[i] == '+' {
			pos++
		} else if str[i] == '-' {
			neg++
		} else {
			q++
		}

		if goal[i] == '+' {
			g++
		} else if goal[i] == '-' {
			g--
		}
	}

	total := 1 << q
	delta := pos - neg
	ans := 0

	for i := 0; i < total; i++ {
		val := 0

		for j := 0; j < q; j++ {
			if ((i >> uint(j)) & 1) > 0 {
				val++
			} else {
				val--
			}
		}

		if val+delta == g {
			ans++
		}
	}

	answ := float32(ans)
	answ /= float32(total)

	fmt.Printf("%.9f", answ)
}