One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed w kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.

The first (and the only) input line contains integer number w (1 ≤ w ≤ 100) — the weight of the watermelon bought by the boys.

Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.

NoteFor example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

package main

import "fmt"

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

package main

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

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 && w%2 == 0 {
        fmt.Println("YES")
    }  else {
        fmt.Println("NO")
    }
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var w uint8
	fmt.Fscanf(in, "%d\n", &w)
	if w == 2 {
		fmt.Println("NO")
	}else if w % 2 == 0{
		fmt.Println("YES")
	}else{
		fmt.Println("NO")
	}
}

package main

import (
	"fmt"
)

func main() {
	var input int64
	fmt.Scanln(&input)
    if input < 3 {
        fmt.Println("NO")
        return
    }
    input -= 2
    if input % 2 == 0 {
        fmt.Println("YES")
    } else {
        fmt.Println("NO")
    }
}

package main
import (
		"fmt"
		)

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

package main;import"fmt";func main(){var a int8;fmt.Scan(&a);if(a&1==1||a==2){fmt.Print("NO")}else{fmt.Print("YES")}}

package main

import (
	"fmt"
)

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

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		w, _ := strconv.Atoi(scanner.Text())
		yes := false
		for i := 2; i < w; i += 2 {
			if (w-i)%2 == 0 {
				yes = true
				break
			}
		}
		if yes {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import "fmt"

func main() {
	var weight,modulo int
	var flag  bool
	fmt.Scanf("%d", &weight)
	if weight > 0 && weight < 101 {
		for loop := 2; loop < 101 ; loop=loop+2 {
			modulo = weight  - loop
			if modulo < 2 { break }
			if modulo % 2 == 0 {
				flag = true
			}else{
				flag = false
			}
		}
	}
	if flag {
		fmt.Println("YES")
	}else{
		fmt.Println("NO")
	}
}

package main

import "fmt"

func main() {
	w := 0
	fmt.Scanf("%d", &w)
	if w != 2 && w%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

func main() {
var i int
 fmt.Scanf("%d", &i);
 if i > 2 && i% 2 == 0{
 fmt.Print("YES");
 }else{
fmt.Print("NO");
 }
}

package main

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

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

package main

import (
	"fmt"
)

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

package main

import "fmt"

func main() {
	var weight int

	fmt.Scanf("%d\n", &weight)

	if weight == 2 {
		fmt.Printf("NO\n")
	} else if weight%2 == 0 {
		fmt.Printf("YES\n")
	} else {
		fmt.Printf("NO\n")
	}
}

package main

import (
    "fmt"
)

func main() {

    var w int
    fmt.Scan(&w)

    if w % 2 == 0 && w > 2{
        fmt.Print("YES")
        return
    }
    fmt.Print("NO")

}

package main

import "fmt"

func task_solution(n int) string {
	if n > 3 && n%2 == 0 {
		return "YES"
	}
	return "NO"
}

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

	fmt.Println(task_solution(n))
}

package main

import "fmt"

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

package main

import "fmt"

func main() {
var i int
var two = 2;
 fmt.Scanf("%d", &i);
 if i > two {
 if i% two == 0{
 fmt.Print("YES");
 }else{
fmt.Print("NO");
 }
 }else{
fmt.Print("NO");
 }
}

package main
import (
	"fmt"
	)
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 (
	"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()  {
	var a int
	scanf("%d\n", &a)

	if !(a % 2 == 0) || a == 2 {
		printf("%s", "NO")
		writer.Flush()
		return
	}

	printf("%s", "YES")

	writer.Flush()
}

package main

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

func main() {

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

	number, err := strconv.ParseInt(text, 10, 0)

	if err != nil {
		fmt.Println("NO")
		return
	}

	if number > 100 || number < 1 {
		fmt.Println("NO")
	}

	if number >= 4 && number%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

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

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

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

package main

import (
	"fmt"
)

func main() {
	kilos := 0
	fmt.Scanf("%d", &kilos)

	if kilos%2 != 0 || kilos == 2 {
		fmt.Println("NO")
		return
	}

	fmt.Println("YES")
}

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	w, _ := strconv.Atoi(scanner.Text())
	for i := 2; i < w; i += 2 {
		if (w-i)%2 == 0 {
			fmt.Println("YES")
			return
		}
	}
	fmt.Println("NO")
}

package main

import "fmt"

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

/* Problemset:
A. Watermelon
time limit per test1 second
memory limit per test64 megabytes
inputstandard input
outputstandard output
One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed w kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.

Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.

Input
The first (and the only) input line contains integer number w (1 ≤ w ≤ 100) — the weight of the watermelon bought by the boys.

Output
Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.

Examples
inputCopy
8
outputCopy
YES
Note
For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

---

What we learned:
CodeForces takes input with fmt.Scanf and not os.Args. 1 is an odd number of slices. Each submission shows the full results of tests, including input, in the submission number link.
*/

package main

import "fmt"

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

package main

import "fmt"

func main() {
	var n int
	fmt.Scanln(&n)

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

package main

import "fmt"

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

package main

import (
	"fmt"
	"math"
)

func main() {
	var i float64
	fmt.Scan(&i)
	if math.Mod(i, 2) == 0 && i > 2 {
		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 && n > 2 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import (
	"fmt"
)

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

	if w % 2 == 1 || w <= 2 {
		fmt.Println("No")
	} else {
		fmt.Println("YES")
	}
}

package main

import "fmt"

func main() {

	var x int
	fmt.Scanf("%d", &x)
	if x % 2 == 1 || x == 2 {
		if x > 2 && (x - 2) % 2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	} else if x > 2 {
		fmt.Println("YES")
	}

}

package main

import "fmt"

func main() {
	var number uint8
	_, _ = fmt.Scanln(&number)
	if number == 2 {
		fmt.Println("NO")
	} else if number%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main
import (
    "bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner = bufio.NewScanner(os.Stdin)

func readInt() int {
    scanner.Scan()
    ret, _ := strconv.Atoi(scanner.Text())
    return ret
}

func main(){
    scanner.Split(bufio.ScanWords)
    n := readInt();
    if n % 2 == 0 {
        if (n > 2){
            fmt.Println("YES")
        }else{
            fmt.Println("NO")
        }
    }else{
        fmt.Println("NO")
    }
}

package main

import (
	"fmt"
)

func main() {
	var k uint8
	fmt.Scanln(&k)
	if k == 2 {
		fmt.Println("NO")
	} else {
		if k%2 != 0 {
			fmt.Println("NO")
		} else {
			fmt.Println("yes")
		}
	}

}

package main

import (
    "fmt"
)

func main() {

    var w int
    fmt.Scan(&w)

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

        if (w-i) % 2 == 0 && w % 2 == 0 {
            fmt.Print("YES")
            return
        }
    }
    fmt.Print("NO")

}

package main

import (
	"fmt"
)

// THIS WAS JUST TO TEST IF CODEFORCES UNDERSTAND GOLANG

/*
One hot summer day Pete and his friend Billy decided to buy a watermelon.
hey chose the biggest and the ripest one, in their opinion.
After that the watermelon was weighed, and the scales showed w kilos.
They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.

Pete and Billy are great fans of even numbers,
that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos,
at the same time it is not obligatory that the parts are equal.
The boys are extremely tired and want to start their meal as soon as possible
that's why you should help them and find out, if they can divide the watermelon in the way they want.
For sure, each of them should get a part of positive weight.

Input
The first (and the only) input line contains integer number w (1 ≤ w ≤ 100) — the weight of the watermelon bought by the boys.
Output
Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.
*/

func main() {
	var number int

	_, err := fmt.Scanf("%d", &number)

	if err != nil {
		panic(err)
	}

	canDevide(number)

}

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

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 {
		b = false
	} else if w%2 == 0 {
		b = true
	} else {
		b = false
	}

	// Display result
	if b {
		printf("YES\n")
	} else {
		printf("NO\n")
	}

	writer.Flush()
}

package main

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

func main() {

	s := bufio.NewScanner(os.Stdin)
	s.Scan()
	w, _ := strconv.Atoi(s.Text())

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

	}
}

package main

import "fmt"

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

	if w&1 == 1 || w == 2 {
		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}
}

//rextester.com:1.6.2--codeforces.com:1.8
package main;import"fmt"
func main(){var a int8;fmt.Scan(&a);if(a&1==1||a==2){fmt.Print("NO")}else{fmt.Print("YES")}}

package main

import (
    "fmt"
)

func main() {

    var w int
    fmt.Scan(&w)

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

}

package main

import "fmt"

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

	if w == 1 {
		fmt.Println("NO")
		return
	}
	for i := 2; i <= w/2; i++ {
		if w%i == 0 && w%2 == 0 {
			fmt.Println("YES")
			return
		}
	}
	fmt.Println("NO")
}

package main

import (
	"fmt"
)

func main() {
	var w int
	fmt.Scanf("%d\n", &w)
	// even
	if w%2 == 0 && w != 2 {
		fmt.Printf("YES")
	} else {
		fmt.Printf("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")
    }
}

package main

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

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==0 || w==2) && w%2 == 0 {
        fmt.Println("YES")
    }  else {
        fmt.Println("NO")
    }
}

package main

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

func main() {
	var weight int
	reader := bufio.NewReader(os.Stdin)
	// Carriage return
	if w, err := reader.ReadString('\n'); err == nil {
		s := w[:len(w)-2]
		if r, err := strconv.Atoi(s); err == nil {
			weight = r
		} else {
			panic(err)
		}
	} else {
		panic(err)
	}
	if weight == 2 {
		fmt.Println("NO")
	} else {
		if weight % 2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	var input int64
	fmt.Scanln(&input)
    if input < 3 {
        fmt.Println("NO")
        return
    }
    input -= 2
    if input % 2 == 0 {
        fmt.Println("YES")
    } else {
        fmt.Println("NO")
    }
}

package main

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

type contestIn struct {
	reader io.Reader
}

type contestOut struct {
	writer io.Writer
}

type Contest struct {
	In contestIn
	Out contestOut
}

func NewSubmitContest() Contest {
	return Contest{contestIn{os.Stdin}, contestOut{os.Stdout}}
}

func NewTestContest(testIn string, testOut *bytes.Buffer) Contest  {
	return Contest{contestIn{strings.NewReader(testIn)}, contestOut{testOut}}
}

func (in contestIn) Var(a interface{}) {
	fmt.Fscan(in.reader, a)
}

func (in contestIn) Vars(a interface{}) {
	fmt.Fscanln(in.reader, a)
}

func (in contestIn) Ints(len int) []int {
	arr := make([]int, 0, len)
	for ; len > 0; len-- {
		var i int
		in.Var(&i)
		arr = append(arr, i)
	}

	return arr
}

func (out contestOut) Str(s string)  {
	fmt.Fprintf(out.writer, "%s", s)
}

func (out contestOut) Nl()  {
	fmt.Fprintln(out.writer)
}

// http://codeforces.com/problemset/problem/4/A
func problem(c Contest)  {
	var w int
	c.In.Var(&w)

	if (w > 2) && (w % 2 == 0) {
		c.Out.Str("YES")
	} else {
		c.Out.Str("NO")
	}

	c.Out.Nl()
}

func main() {
	c := NewSubmitContest()
	problem(c)
}

package main

import "fmt"

func main() {
	var number int
	_, err := fmt.Scanf("%d", &number)
	if err != nil {
		fmt.Println("NO")
		return
	}

	if number < 1 || number > 100 {
		fmt.Println("NO")
		return
	}
	if number == 2 {
		fmt.Println("NO")
		return
	}
	if number%2 == 0 {
		fmt.Println("YES")
		return
	} else {
		fmt.Println("NO")
		return
	}

}

// test
package main

import (
	"fmt"
)

func main() {

	var a int
	fmt.Scanln(&a)
	//for a = 1; a <= 100; a++ {
	//	fmt.Printf("%d: ", a)
	if a%2 == 1 {
		fmt.Println("NO")
	} else if a/2 < 2 {

		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}
	//}
}

package main

import (
	"fmt"
)

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

package main

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

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

	str := string(text)

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

}

package main

import "fmt"

func main() {
	var weight int

	fmt.Scanf("%d\n", &weight)

	if weight == 2 {
		fmt.Printf("NO\n")
	} else if weight%2 == 0 {
		fmt.Printf("YES\n")
	} else {
		fmt.Printf("NO\n")
	}
}

package main

import "fmt"

func main() {
	number := -1
	_, err := fmt.Scanln(&number)
	if err != nil {
		panic(err)
	}
	if number > 3 && (number%2) == 0 {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}

package main

import (
        "fmt"
    )

func main() {
    var kilos int = 0
    fmt.Scan(&kilos)
    if kilos > 2 && kilos%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")
	}
}

package main

import "fmt"

func main() {
    var i int
    _, err := fmt.Scanf("%d", &i)
    if err != nil {fmt.Println(err)}
    if (i%2 == 0) && (i<=100) && (i>2) {
        fmt.Println("Yes")
    }else{
        fmt.Println("No")
    }
}

package main

import "fmt"

func main() {
	w := 0
	fmt.Scanf("%d", &w)
	if w != 2 && w%2 == 0 {
		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 scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }

func main() {
	defer writer.Flush()
	var number int
	scanf("%d", &number)
	if number == 2 {
		printf("NO")
	} else if number%2 == 0 {
		printf("YES")
	} else {
		printf("NO")
	}

}

package main

import "fmt"

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

package main

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

func readNumber() (int, error) {
	reader := bufio.NewReader(os.Stdin)
	str, err := reader.ReadString('\r')
	if err != nil {
		return 0, err
	}
	weight, err := strconv.Atoi(strings.Replace(str, "\r", "", -1))
	return weight, err
}

func main() {
	weight, err := readNumber()

	if err != nil {
		fmt.Println(err)
		panic(err)
	}
	var answer string

	if weight % 2 == 0 && weight != 2 {
		answer = "YES"
	} else {
		answer = "NO"
	}

	fmt.Println(answer)
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var n string
	_, _ = fmt.Scanln(&n)
	value, _ := strconv.Atoi(n)
	if value > 2 && value % 2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

func main() {
	var weight int
	fmt.Scanln(&weight)
	if weight%2 == 0 && weight != 2 {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}

package main

import "fmt"

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

package main

import (
	"fmt"
)

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

	if !(a%2 == 0) || a == 2 {
		fmt.Println("NO")
		return
	}
	fmt.Println("YES")
}

// test
package main

import (
	"fmt"
)

func main() {

	var a int
	fmt.Scanln(&a)
	//for a = 1; a <= 100; a++ {
	//	fmt.Printf("%d: ", a)
	if a%2 == 1 {
		fmt.Println("NO")
	} else if a/2 < 2 {

		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}
	//}
}

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()  {
	var a int
	scanf("%d\n", &a)

	if !(a % 2 == 0) || a == 2 {
		printf("%s", "NO")
	} else {
		printf("%s", "YES")
	}

	writer.Flush()
}

package main

import "fmt"

func main() {
    var w uint

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

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

package main

import (
    "fmt"
)

func main() {

    var w int
    fmt.Scan(&w)

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

        if (w-i) % 2 == 0 && w % 2 == 0 {
            fmt.Print("YES")
            return
        }
    }
    fmt.Print("NO")

}

package main

import "fmt"

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

	if w == 1 {
		fmt.Println("NO")
		return
	}
	for i := 2; i <= w/2; i++ {
		if w%i == 0 && w%2 == 0 {
			fmt.Println("YES")
			return
		}
	}
	fmt.Println("NO")
}

package main

import (
	"fmt"
)

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

package main

// https://codeforces.com/problemset/problem/4/A

import "fmt"

func task_solution(n int) string {
	if n > 3 && n%2 == 0 {
		return "YES"
	}
	return "NO"
}

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

	fmt.Println(task_solution(n))
}

package main

import (
	"fmt"
)

func main() {
	var kilo float64
	_, _ = fmt.Scan(&kilo)

	nimf := int8(kilo)
	nimi := int8(kilo/2) * 2

	if kilo > 2 && nimf == nimi {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}

package main

import (
  "fmt"
)

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

package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	var n string
	_, _ = fmt.Scanln(&n)
	i, _ := strconv.ParseInt(n, 10, 64)
	fl := float64(i)

	if math.Mod(fl, 2) == 0 && fl != 2 {
		fmt.Print("YES")
	} else {
		fmt.Print("NO")
	}
}

package main

import (
	"fmt"
)

func main() {
	var weight int32
	_, err := fmt.Scanf("%d", &weight)
	if err != nil {
		fmt.Println(err.Error())
	}

	if weight&1 == 1 || weight == 2 {
		fmt.Print("NO")
		return
	}
	fmt.Print("YES")
}

package main

import "fmt"

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

package main

import (
	"fmt"
)

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

package main;import"fmt";func main(){var a int8;fmt.Scan(&a);if(a&1==1||a==2){fmt.Print("NO")}else{fmt.Print("YES")}}

package main
import (
		"fmt"
		)

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

package main
import (
	"fmt"
)

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

package main

import (
	"fmt"
)

func main() {
	var input int64
	fmt.Scanln(&input)
    input -= 2
    if input % 2 == 0 {
        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()  {
	var a int
	scanf("%d\n", &a)

	if !(a % 2 == 0) {
		printf("%s\n", "NO")
	} else {
		printf("%s", "YES")
	}

	writer.Flush()
}

package main

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

func main(){
        reader := bufio.NewReader(os.Stdin)
        kg, _ := reader.ReadString('\n')

        //remove newline
        kg = strings.Replace(kg, "\n","",-1)

        //conver string variable to int variable

        kgnum, e := strconv.Atoi(kg)
        if e != nil {
                fmt.Println("conversion error:", kg)
        }

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

package main

import "fmt"

func main() {
	//fmt.Println("Enter weight of the watermelon: ")
	var wt int
	// Taking input from user
	fmt.Scanln(&wt)

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

}

package main

import "fmt"

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

package main

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

func main() {

var WKgVar uint
var OstatokDelVar uint = 0;
var Zero uint = 0;
// var Kolvo2KgVar int = 1;
// var ObshKgVar int = 1;

// Ввод числа Килограмм.
fmt.Scan(&WKgVar)
// Четность, нечетность.
OstatokDelVar = WKgVar%4;
if WKgVar < 100{
if OstatokDelVar == Zero{
	// fmt.Println("Остаток от деления равен ноль")
	if WKgVar >= 4{
		//fmt.Println("WkgVar >= 4")
		fmt.Println("YES");
		}

}
} else {fmt.Println("NO");
	}

}

package main

import (
	"fmt"
)

func main() {
	var weight int
	_, err := fmt.Scanf("%d", &weight)
	if err != nil {
		fmt.Println(err.Error())
	}
	for i := 1; i < weight; i++ {
		if i&11 == 0 {
			fmt.Print("YES")
			return
		}
	}
	fmt.Print("NO")
}

package main

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

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

	str := string(text)

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

}

package main

import (
    "fmt"
)

func main() {

    var w int
    fmt.Scan(&w)

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

}

package main

import "fmt"

func main() {

	var weight int

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

	if weight/2 * 2 == weight {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var w float64
	_, _ = fmt.Scanf("%f", &w)

	fmt.Println(Run(w))
}

func Run(w float64) string {
	a := w/2
	// Если у а есть точка, то NO
	if strings.Contains(fmt.Sprint(a), ".") {
		return "NO"
	}

	// Если у а нет точки, то а делим на два
	// Если a/2 есть точка, то NO
	if strings.Contains(fmt.Sprint(a/2), "."){
		return "NO"
	}

	// Если точки нет, то YES
	return "YES"
}

package main

import (
        "fmt"
)

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

package main

import (
	"fmt"
)

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

	if w % 2 == 0 && w != 2 && 1<=w && w<=100 {
		fmt.Println("YES")
	}
	if w % 2 == 1 && 1<=w && w<=100 {
		fmt.Println("NO")
	}
}

package main

import (
	"fmt"
)

func main() {
	var weight = 0
	_, err := fmt.Scanf("%d\n", &weight)
	if err != nil {
		panic(err)
	}

	if isEven(weight) && weight > 3 {
		if weight % 4 == 0 {
			println("YES\n")
			return
		}

		if (weight - 2) % 4 == 0 {
			println("YES\n")
			return
		}
	}

	println("NO\n")
	return
}

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

package main

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

func main() {
	stdin, err := os.OpenFile("input", os.O_RDONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Errorf("%s\n", err)
	}
	os.Stdin = stdin

	r := bufio.NewReader(os.Stdin)

	var w int32
	fmt.Fscan(r, &w)
	// even
	if w%2 == 0 {
		if (w/2)%2 == 0 {
			fmt.Printf("YES")
		} else {
			fmt.Printf("NO")
		}
	} else {
		fmt.Printf("NO")
	}
}

package main

import "fmt"

func main() {
	var n int
	var cont int
	fmt.Scanf("%d", &n)
	for i := 1; i < n; i++ {
		if i%2 == 0 {
			if n%i == 0 {
				cont++
			}
		}
	}
	if cont >= 2 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

func main() {
	var a int
	fmt.Scanln(&a)
		if a%2 == 0 {
			b:=a/2
			if  b%2==0 {
				fmt.Println("YES")
			} else if a==2{
				fmt.Println("NO")
				c:=b-1
				d:=b+1
				if c%2==0&&d%2==0 {
					fmt.Println("YES")
				} else {
					fmt.Println("NO")
				}
			}
		} else {
			fmt.Println("NO")
		}
}

package main

import "fmt"

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

package main

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

func main() {
  fmt.Println(os.Args)
    if len(os.Args) == 2 {
        args := os.Args[1]
        //fmt.Printf("%T\n", args)
        argi, _ := strconv.Atoi(args)
        //fmt.Printf("%T", argi)
        //fmt.Println(argi)
        if argi % 2 == 0 {
          fmt.Println("YES")
          } else {
           fmt.Println("NO") }

    }
}

package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)

	if a%2 == 0 {
		b := a / 2
		if b%2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	} 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')
	w, _ := strconv.ParseInt(text, 10, 8)
	if ((w-2)%2) == 0 {
		fmt.Printf("YES")
	} else {
		fmt.Printf("NO")
	}
}

package main
import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	)
func main() {
    reader := bufio.NewReader(os.Stdin)
    text, _ := reader.ReadString('\n')
    number, _ := strconv.Atoi(text)
    if number > 2 && number % 2 == 0 {
        fmt.Println("YES")
    }else{
        fmt.Println("NO")
    }

}

package main

import "fmt"

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

package main

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

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

func main() {

	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	num, _ := strconv.Atoi(text)
	if Watermelon(num) {
		fmt.Println("YES")
	}else {
		fmt.Println("NO")
	}

}

package main

import (
	"fmt"
)

//https://codeforces.com/problemset/problem/4/A
func main() {
	var w int
	fmt.Scanf("%d", &w)
	if w >= 1 && w <= 100 {
		if (w-3)%2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	} else {
		fmt.Println("NO")
	}
}

package main

import(
"fmt"
)

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

package main

import "fmt"

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

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	str, _ := reader.ReadString('\r')
	str = str[:len(str)-1]
	n, _ := strconv.Atoi(str)
	for i := 2; i < n/2; i++ {
		if (n/i)%2 == 0 {
			fmt.Println("YES")
			return
		}
	}

	fmt.Println("NO")
}

package main

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

func even (w int) bool {
	if w % 2 == 0 {
		return true
	}
	return false
}

func main() {
	var weight int
	reader := bufio.NewReader(os.Stdin)
	// Carriage return
	if w, err := reader.ReadString('\n'); err == nil {
		// Depends.
		s := w[:len(w)-2]
		if r, err := strconv.Atoi(s); err == nil {
			weight = r
		} else {
			panic(err)
		}
	} else {
		panic(err)
	}
	if even(weight/2) && even(weight) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

func main() {
    var w uint

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

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

    fmt.Println("NO")
}

package main

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

func main() {
	fmt.Println("Enter the watermelon's weight:")
	reader := bufio.NewReader(os.Stdin)
	r, _ := reader.ReadString('\n')
	w, _ := strconv.Atoi(r)

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

	}
}

package main

import (
	"fmt"
	"os"
)

func main() {
	var a int
	//fmt.Print("Введите вес арбуза: ")
	fmt.Fscan(os.Stdin, &a)
	m := a%2
	if m == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

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

type contestIn struct {
	reader io.Reader
}

type contestOut struct {
	writer io.Writer
}

type Contest struct {
	In contestIn
	Out contestOut
}

func NewSubmitContest() Contest {
	return Contest{contestIn{bufio.NewReader(os.Stdin)}, contestOut{bufio.NewWriter(os.Stdout)}}
}

func NewTestContest(testIn string, testOut *bytes.Buffer) Contest  {
	return Contest{contestIn{strings.NewReader(testIn)}, contestOut{testOut}}
}

func (in contestIn) Var(a interface{}) {
	fmt.Fscan(in.reader, a)
}

func (in contestIn) Vars(a interface{}) {
	fmt.Fscanln(in.reader, a)
}

func (in contestIn) Ints(len int) []int {
	arr := make([]int, 0, len)
	for ; len > 0; len-- {
		var i int
		in.Var(&i)
		arr = append(arr, i)
	}

	return arr
}

func (out contestOut) Str(s string)  {
	fmt.Fprintf(out.writer, "%s", s)
}

func (out contestOut) Nl()  {
	fmt.Fprintln(out.writer)
}

// http://com/problemset/problem/4/A
func problem(c Contest)  {
	var w int
	c.In.Var(&w)

	if w % 2 == 0 {
		c.Out.Str("YES")
	} else {
		c.Out.Str("NO")
	}

	c.Out.Nl()
}

func main() {
	c := NewSubmitContest()
	problem(c)
}

package main

import (
	"fmt"
)

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

}

package main
import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	)
func main() {
    reader := bufio.NewReader(os.Stdin)
    text, _ := reader.ReadString('\n')
    number, _ := strconv.Atoi(text)
    if number > 2 && number % 2 == 0 {
        fmt.Print("YES")
    }else{
        fmt.Print("NO")
    }

}

package main

import "fmt"

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

package main

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

func main(){
	fmt.Print(getStatus())
}

func getInput() int{
	reader := bufio.NewReader(os.Stdin)
	s, err := reader.ReadString('\n')

	if err != nil && err != io.EOF{
		log.Fatal(err)
	}
	s = strings.TrimRight(s, "\r\n")

	w, err := strconv.Atoi(s)
	if err != nil && err != io.EOF{
		log.Fatal(err)
	}
	return w
}

func getStatus() string{
	w := getInput()

	if w%2 == 0 && w > 1{
		return "YES"
	}
	return "NO"
}

package main

import "fmt"

func main() {
	var weight int
	fmt.Print("Enter the weight of watermelon (integral value from 1 to 100) bought by the boys : ")
	fmt.Scanln(&weight)
	if weight <= 100 && weight >= 1 {
		if weight%4 == 0 {
			fmt.Print("YES")
		} else {
			fmt.Print("NO")
		}
	} else {
		fmt.Println("Weight of watermelon must be an integral value from 1 to 100")
	}
}

package main

import (
	"fmt"
)

func main() {
	var input int64
	fmt.Scanln(&input)
	if (input/2)*2 == input && (input/2)%2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)

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

package main

import (
	"fmt"
	"os"
)

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

package main

import "fmt"

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

	for i := 2; i < n; i += 2 {
		other := n - i
		if other%2 == 0 {
			print("YES")
			return
		}
	}
	print("NO")
}

package main

import (
	"fmt"
)

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

	if w % 2 == 0 && (w != 2) && 1<=w && w<=100 {
		fmt.Println("YES")
	}
	if w % 2 == 1 && 1<=w && w<=100 {
		fmt.Println("NO")
	}
}

package main

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.Printf("parse error, input text: %+v", text)
    return
  }

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

  fmt.Printf("YES")
}

package main

import "fmt"

func main() {
  var w int
  fmt.Scanln(&w)
  if w % 4 == 0 {
    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 scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }

func main() {
	defer writer.Flush()
	var number int
	scanf("%d", &number)
	if number == 2 {
		printf("YES")
	} else if number%2 == 0 {
		printf("NO")
	} else {
		printf("YES")
	}

}

package main

import (
	"fmt"
)

func main() {
	var weight int
	_, err := fmt.Scanf("%d", &weight)
	if err != nil {
		fmt.Println(err.Error())
	}
	for i := 1; i < weight; i++ {
		if i&11 == 0 {
			fmt.Print("YES")
			return
		}
	}
	fmt.Print("NO")
}

package main

import (
        "fmt"
)

func main(){
        kgnum := 8

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

package main

import "fmt"

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

package main

import "fmt"

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

package main

import (
	"fmt"
)

func main() {
	var w, x int
	fmt.Scan(&w)
	x = w/2
	if x > 0 && x % 2 == 0 && 1 <= w && w <= 100 {
		fmt.Println("YES")
	}
	if x > 0 && x % 2 == 1 && 1 <= w && w <= 100 {
		fmt.Println("NO")
	}
	if x == 0 && 1 <= w && w <= 100 {
		fmt.Println("NO")
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	str, _ := reader.ReadString('\n')
	str = str[:len(str)-1]
	fmt.Printf("str: %#v", str)
	return

	n, _ := strconv.Atoi(str)
	for i := 2; i < n/2; i++ {
		if (n/i)%2 == 0 {
			fmt.Println("YES")
			return
		}
	}

	fmt.Println("NO")
}

package main

import "fmt"

func main() {
  // for {
    var i int
    _, err := fmt.Scanf("%d", &i)
    if err != nil {fmt.Println(err)}
    if i%2 == 0 {
        fmt.Println("Yes")
    }else{
        fmt.Println("No")
    }
  // }
}

package main

import "fmt"

func main() {

	var weight int

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

	if weight/2 * 2 == weight {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import "fmt"

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

package main

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

func main() {

var WKgVar uint
var OstatokDelVar uint = 0;
var Zero uint = 0;
// var Kolvo2KgVar int = 1;
// var ObshKgVar int = 1;

// Ввод числа Килограмм.
fmt.Scan(&WKgVar)
// Четность, нечетность.
OstatokDelVar = WKgVar%4;
if WKgVar <= 100{
if OstatokDelVar == Zero{
	// fmt.Println("Остаток от деления равен ноль")
	if WKgVar >= 4{
		//fmt.Println("WkgVar >= 4")
		fmt.Println("YES");
		}

}
} else {fmt.Println("NO");
	}

}

package main

import "fmt"

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

package main

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"
)

func main() {
	var ves int
	fmt.Scan(&ves)
	if ves < 1 || ves > 100 {
		fmt.Println("Таких арбузов не бывает")
	} else {
		if (ves % 2 % 2) == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

// test
package main

import (
	"fmt"
)

func main() {

	var a int
	fmt.Scanln(&a)
	if a%2 == 1 {
		fmt.Println("NO")
	} else if a < 2 {

		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}

}

package main

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

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

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	value, _ := strconv.ParseInt(text, 0, 64)
	impl(value)
}

func impl(n int64) {
	if n % 2 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

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

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

    w, _ := strconv.Atoi(text)
    if math.Mod(float64(w), 2) == 0 {
        fmt.Println("YES")
    }  else {
        fmt.Println("NO")
    }
}

package main

import (
  "fmt"
)

func main() {
  var num int

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

  fmt.Printf("mod: %d\n", num%2)

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

  fmt.Printf("YES")
}

package main

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"

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

	for i := 2; i < n; i += 2 {
		other := n - i
		if other%2 == 0 {
			println("YES")
			return
		}
	}
	println("NO")
}

package main

import (
	"fmt"
)

func main() {
	var weight = 0
	_, err := fmt.Scanf("%d", &weight)
	if err != nil {
		panic(err)
	}

	if isEven(weight) && weight > 3 {
		if weight % 4 == 0 {
			println("YES")
			return
		}

		if (weight - 2) % 4 == 0 {
			println("YES")
			return
		}
	}

	println("NO")
	return
}

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

package main

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

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

    w, _ := strconv.Atoi(text)
    if math.Mod(float64(w), 2) == 0 {
        fmt.Println("YES")
    }  else {
        fmt.Println("NO")
    }
}

package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)

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

package main

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

func main() {

var WKgVar int
var OstatokDelVar int = 0;
var Zero int = 0;
// var Kolvo2KgVar int = 1;
// var ObshKgVar int = 1;

// Ввод числа Килограмм.
fmt.Scan(&WKgVar)
// Четность, нечетность.
OstatokDelVar = WKgVar%2;

if OstatokDelVar == Zero{
	// fmt.Println("Остаток от деления равен ноль")
	if WKgVar >= 4{
		//fmt.Println("WkgVar >= 4")
		fmt.Println("YES");
		}

} else {fmt.Println("NO");
	}

}

package main

import "fmt"

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

package main

import "fmt"
func main(){
    var w int
    fmt.Scanf("%d", &w)
     if w % 2 == 0 && w != 0 {fmt.Println("Yes")
    }else  {fmt.Println("No")}

}

package main

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

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 (
	"fmt"
)

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

package main

import "fmt"

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

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

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

package main

import (
	"fmt"
)

func isDivide(k int8) string {
	if k%4 == 0 {
		return "YES"
	} else {
		return "NO"
	}
}

func main() {
	var k int8
	fmt.Scanln(&k)
	fmt.Println(isDivide(k))

}

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		i, _ := strconv.Atoi(scanner.Text())
		if i%2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import "fmt"

func main() {

	var weight int

	_, _ = fmt.Scanf("%d", &weight)

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

}

package main

import "fmt"

func main() {
  // for {
    var i int
    _, err := fmt.Scanf("%d", &i)
    if err != nil {fmt.Println(err)}
    if (i%2 == 0) && (i<100) && (i>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) && 1<=w && w<=100 {
		fmt.Println("YES")
	}
	if w % 2 == 1 && 1<=w && w<=100 {
		fmt.Println("NO")
	}
}

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		i, _ := strconv.Atoi(scanner.Text())
		if i%2 == 0 && (i/2)%2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

package main

import "fmt"

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

package main

import "fmt"

func main() {
	fmt.Println("Enter weight of the watermelon: ")
	var wt int
	// Taking input from user
	fmt.Scanln(&wt)

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

}

package main

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

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

func main() {

	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	num, _ := strconv.Atoi(text)
	fmt.Println(Watermelon(num))
}

package main

import "fmt"

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

package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)

	if a%2 == 0 {
		b := a / 2
		if b%2 == 0 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	} else {
		fmt.Println("NO")
	}
}

package main

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

func main() {

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	w, _ := strconv.Atoi(scanner.Text())

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

	}
}

package main

import "fmt"

func main() {
	//fmt.Println("Enter weight of the watermelon: ")
	var wt int
	// Taking input from user
	fmt.Scanln(&wt)

	if wt%2 == 0 {
		fmt.Println("YES")
		return
	}
	fmt.Println("NO")

}

package main

import (
	"fmt"
)

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

package main

import (
	"fmt"
)

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

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	input_string, _ := reader.ReadString('\n')
	input, _ := strconv.Atoi(input_string[:len(input_string)-1])
	answer := 0
	if input%2==0 {
		answer = 1
	}
	if input == 2 {
		answer = 0
	}
	if answer == 0 {
		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}
}

package main

import "fmt"

func main() {
	var number int
	_, err := fmt.Scanf("%d", &number)
	if err != nil {
		fmt.Println("NO")
		return
	}

	if number <= 1 || number >= 100 {
		fmt.Println("NO")
		return
	}
	if number%2 == 0 {
		fmt.Println("YES")
		return
	}

}

package main

import "fmt"

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

package main

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

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

	w, err := strconv.Atoi(strings.Trim(text, "\n"))
	if err != nil {
		fmt.Println(err)
		return
	}
	if w%2 == 0 {
		fmt.Println("YES")
		return
	}
	fmt.Println("NO")
}


PolandBall is a young, clever Ball. He is interested in prime numbers. He has stated a following hypothesis: "There exists such a positive integer n that for each positive integer m number n·m + 1 is a prime number".Unfortunately, PolandBall is not experienced yet and doesn't know that his hypothesis is incorrect. Could you prove it wrong? Write a program that finds a counterexample for any n.

The only number in the input is n (1 ≤ n ≤ 1000) — number from the PolandBall's hypothesis.

Output such m that n·m + 1 is not a prime number. Your answer will be considered correct if you output any suitable m such that 1 ≤ m ≤ 103. It is guaranteed the the answer exists.

NoteA prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.For the first sample testcase, 3·1 + 1 = 4. We can output 1.In the second sample testcase, 4·1 + 1 = 5. We cannot output 1 because 5 is prime. However, m = 2 is okay since 4·2 + 1 = 9, which is not a prime number.

package main

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

func main() {
	isPrime := make([]bool, 2e6)
	for i := 2; i < len(isPrime); i++ {
		isPrime[i] = true
	}
	max := int(math.Sqrt(float64(len(isPrime))))
	for i := 2; i <= max; i++ {
		if isPrime[i] {
			for j := i * i; j < len(isPrime); j += i {
				isPrime[j] = false
			}
		}
	}
	n := readi()
	for m := 1; ; m++ {
		if !isPrime[n*m+1] {
			fmt.Println(m)
			break
		}
	}
	writer.Flush()
}

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 max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

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

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
}

var (
	reader = bufio.NewReaderSize(os.Stdin, 1<<13)
	writer = bufio.NewWriterSize(os.Stdout, 1<<13)
)

func readi() int {
	return int(readi64())
}

func read2i() (int, int) {
	return readi(), readi()
}

func readis(n int) []int {
	res := make([]int, n)
	for i := range res {
		res[i] = readi()
	}
	return res
}

func readi64() int64 {
	b, err := reader.ReadByte()
	for !isValid(b, err) {
		b, err = reader.ReadByte()
	}
	sign, res := int64(1), int64(0)
	if b == '-' {
		sign *= -1
		b, err = reader.ReadByte()
	}
	for isValid(b, err) {
		res = res*10 + int64(b-'0')
		b, err = reader.ReadByte()
	}
	return res * sign
}

func readline() string {
	res := new(bytes.Buffer)
	for {
		line, isPrefix, err := reader.ReadLine()
		if err != nil {
			panic(err)
		}
		res.Write(line)
		if !isPrefix {
			break
		}
	}
	return res.String()
}

func isValid(b byte, err error) bool {
	return err == nil && (('0' <= b && b <= '9') || b == '-')
}

package main

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

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 n int
	for I(&n, "\n") == nil {
		solve(n)
	}
}

func solve(n int) {
	for i := 2; i < 1001; i++ {
		a := i*n + 1
		for j := 2; j < 10000; j++ {
			if a%j == 0 && a != j {
				O(i, "\n")
				return
			}
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	var n int
	if _, err := fmt.Scanf("%d\n", &n); err != nil {
		return
	}

	if n > 1 && n%2 != 0 {
		fmt.Println(1)
	} else {
		for i := 2; i <= n*1000+1; i++ {
			for j := i; j <= n*1000+1; j++ {
				non_prime := i * j
				if (non_prime-1)%n == 0 {
					fmt.Println((non_prime - 1) / n)
					return
				}
			}
		}
	}
}

package main

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

func solve() {
	n := readInt()
	for m := 1; m <= 1000; m++ {
		if !isPrime(n*m + 1) {
			fmt.Println(m)
			return
		}
	}
}

func isPrime(num int) bool {
	if num < 2 {
		return false
	}
	if num == 2 {
		return true
	}
	if num%2 == 0 {
		return false
	}
	for i := 3; i*i <= num; i += 2 {
		if num%i == 0 {
			return false
		}
	}
	return true
}

func getStats(str string) map[byte]int {
	stat := map[byte]int{}
	for _, v := range str {
		stat[byte(v)]++
	}
	return stat
}

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 min(a int, 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 (
        "fmt"
)

var primeMap = make(map[int]bool)

func isPrime(number int) bool {
        isPrime := true
        for j := 2; j <= number/2; j++ {
                if number%j == 0 {
                        isPrime = false
                        break
                }
        }
        return isPrime

}

func main() {
        var input int
        fmt.Scanf("%d", &input)
        pynum := 1
        for {
                if !isPrime(input*pynum + 1) {
                        fmt.Println(pynum)
                        break

                } else {
                        pynum++

                }
        }
}

package main

import (
	"fmt"
)

func main() {
	var number int
	fmt.Scanf("%d\n", &number)
	for m:=1;m<1000;m++{
		if !isPrime(m*number + 1) {
			fmt.Println(m)
			return
		}
	}
}

func isPrime(number int) bool {
	for i:=2; i<number; i++ {
		if number % i == 0 {
			return false;
		}
	}
	return true;
}

package main

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

const INF  = 1000000001

type Pair struct {
	first, second int
}

func sort(arr []int) []int {
	if len(arr) < 2 {
		return arr
	}
	left := 0
	right := len(arr) - 1
	pivot := rand.Int() % len(arr)

	arr[pivot], arr[right] = arr[right], arr[pivot]

	for i := 0; i < len(arr); i++ {
		if arr[i] < arr[right] {
			arr[i], arr[left] = arr[left], arr[i]
			left++
		}
	}

	arr[left], arr[right] = arr[right], arr[left]

	sort(arr[:left])
	sort(arr[left+1:])
	return arr
}

func solution(reader io.Reader, writer io.Writer) {
	var n int
	fmt.Fscanf(reader, "%d\n", &n)

	for i := 1; i <= 1000; i++ {
		m := i * n + 1
		f := 0
		for j := 2; j < m; j++ {
			if m % j == 0 {
				f++
			}
		}
		if f > 0 {
			fmt.Println(i)
			return
		}
	}
}

func main() {

	//stdin, err := os.Open("file.in")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdin.Close()
	stdin := os.Stdin
	reader := bufio.NewReaderSize(stdin, 1024*1024)

	//stdout, err := os.Create("file.out")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdout.Close()
	stdout := os.Stdout
	writer := bufio.NewWriterSize(stdout, 1024*1024)
	defer writer.Flush()

	solution(reader, writer)
}

package main

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

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 n int
	for I(&n, "\n") == nil {
		solve(n)
	}
}

func solve(n int) {
	for i := 2; i < 1001; i++ {
		a := i*n + 1
		if a%2 == 0 || a%3 == 0 {
			O(i, "\n")
			return
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	var n int
	if _, err := fmt.Scanf("%d\n", &n); err != nil {
		return
	}

	if n%2 != 0 {
		fmt.Println(1)
	} else {
		for i := 2; i <= n*1000+1; i++ {
			for j := i; j <= n*1000+1; j++ {
				non_prime := i * j
				if (non_prime-1)%n == 0 {
					fmt.Println((non_prime - 1) / n)
					return
				}
			}
		}
	}
}

package main

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

const INF  = 1000000001

type Pair struct {
	first, second int
}

func sort(arr []int) []int {
	if len(arr) < 2 {
		return arr
	}
	left := 0
	right := len(arr) - 1
	pivot := rand.Int() % len(arr)

	arr[pivot], arr[right] = arr[right], arr[pivot]

	for i := 0; i < len(arr); i++ {
		if arr[i] < arr[right] {
			arr[i], arr[left] = arr[left], arr[i]
			left++
		}
	}

	arr[left], arr[right] = arr[right], arr[left]

	sort(arr[:left])
	sort(arr[left+1:])
	return arr
}

func solution(reader io.Reader, writer io.Writer) {
	var n int
	fmt.Fscanf(reader, "%d\n", &n)

	for i := 1; i < 1000; i++ {
		m := i * n + 1
		f := 0
		for j := 2; j * j < m; j++ {
			if m % j == 0 {
				f++
			}
		}
		if f > 0 {
			fmt.Println(m)
			return
		}
	}
}

func main() {

	//stdin, err := os.Open("file.in")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdin.Close()
	stdin := os.Stdin
	reader := bufio.NewReaderSize(stdin, 1024*1024)

	//stdout, err := os.Create("file.out")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdout.Close()
	stdout := os.Stdout
	writer := bufio.NewWriterSize(stdout, 1024*1024)
	defer writer.Flush()

	solution(reader, writer)
}


Kolya is developing an economy simulator game. His most favourite part of the development process is in-game testing. Once he was entertained by the testing so much, that he found out his game-coin score become equal to 0.Kolya remembers that at the beginning of the game his game-coin score was equal to n and that he have bought only some houses (for 1 234 567 game-coins each), cars (for 123 456 game-coins each) and computers (for 1 234 game-coins each).Kolya is now interested, whether he could have spent all of his initial n game-coins buying only houses, cars and computers or there is a bug in the game. Formally, is there a triple of non-negative integers a, b and c such that a × 1 234 567 + b × 123 456 + c × 1 234 = n?Please help Kolya answer this question.

The first line of the input contains a single integer n (1 ≤ n ≤ 109) — Kolya's initial game-coin score.

Print "YES" (without quotes) if it's possible that Kolya spent all of his initial n coins buying only houses, cars and computers. Otherwise print "NO" (without quotes).

NoteIn the first sample, one of the possible solutions is to buy one house, one car and one computer, spending 1 234 567 + 123 456 + 1234 = 1 359 257 game-coins in total.

package main

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

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 n uint64
	for I(&n, "\n") == nil {
		solve(n)
	}
}

func solve(n uint64) {
	a, b, c := uint64(1234567), uint64(123456), uint64(1234)
	for i := uint64(0); i <= n/a; i++ {
		aa := a * i
		for j := uint64(0); j <= (n-aa)/b; j++ {
			bb := aa + j*b
			if (n-bb)%c == 0 {
				O("YES", "\n")
				return
			}
		}
	}
	O("NO", "\n")
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d\n", &n)
	res := false
	var c string
	aa := 1234567
	bb := 123456
	cc := 1234
	for i := 0; ; i++ {
		if aa*i > n || res {
			break
		}
		for j := 0; ; j++ {
			if (aa*i+bb*j) > n || res {
				break
			}
			var k int
			k = n - aa*i - bb*j
			k /= cc
			res = aa*i+bb*j+cc*k == n
		}
	}
	if res {
		c = "YES"
	} else {
		c = "NO"
	}
	fmt.Println(c)
}

package main

import (
	"fmt"
)

func main() {
	const house int = 1234567
	const car int = 123456
	const computer int = 1234

	var n int
	if _, err := fmt.Scanf("%d\n", &n); err != nil {
		return
	}

	ok := false
	for i := 0; i <= n/house; i++ {
		for j := 0; j <= (n-house*i)/car; j++ {
			if (n-house*i-car*j)%computer == 0 {
				ok = true
				break
			}
		}
		if ok {
			break
		}
	}

	if ok {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

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

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	a, _ := in.ReadString('\n')
	a = strings.Trim(a, "\r\n")
	n, _ := strconv.ParseInt(string(a), 10, 64)
	for a := int64(0); a <= 1000; a++ {
		for b := int64(0); b <= 1000; b++ {
			if c := (n - a*1234567 - b*123456) / 1234; c >= 0 && a*1234567+b*123456+c*1234 == n {
				fmt.Println("YES")
				return
			}
		}
	}
	fmt.Println("NO")
}

package main

import (
	"fmt"
)

var coins = []int{1234567, 123456, 1234}

func canpay(amount int, coins []int) bool {
	if amount < 0 {
		return false
	}
	if amount == 0 {
		return true
	}
	if len(coins) == 0 {
		return false
	}
	c := coins[0]
	if len(coins) == 1 {
		return amount%c == 0
	}
	for i := 0; i <= (amount / c); i++ {
		if canpay(amount-c*i, coins[1:]) {
			return true
		}
	}
	return false
}

func main() {
	var amount int
	_, err := fmt.Scanln(&amount)
	if err != nil {
		panic(err)
	}
	if canpay(amount, coins) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

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

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	a, _ := in.ReadString('\n')
	a = strings.Trim(a, "\r\n")
	n, _ := strconv.ParseInt(string(a), 10, 64)
	for a := int64(0); a <= 1000; a++ {
		for b := int64(0); b <= 1000; b++ {
			if c := (n - a*1234567 + b*123456) / 1234; c >= 0 && a*1234567+b*123456+c*1234 == n {
				fmt.Println("YES")
				return
			}
		}
	}
	fmt.Println("NO")
}


You are a lover of bacteria. You want to raise some bacteria in a box. Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly x bacteria in the box at some moment. What is the minimum number of bacteria you need to put into the box across those days?

The only line containing one integer x (1 ≤ x ≤ 109).

The only line containing one integer: the answer.

NoteFor the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2.For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. So the answer is 1.

package main

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

var in *bufio.Scanner = bufio.NewScanner(os.Stdin)
var out *bufio.Writer = bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()

	n := nextInt()
	fmt.Println(strings.Count(strconv.FormatInt(int64(n), 2), "1"))
}

func nextInt() int {
	in.Scan()
	res, _ := strconv.Atoi(in.Text())
	return res
}

package main

import "fmt"

func main() {
	var x int
	fmt.Scan(&x)
	cnt := 0
	for x != 0{
		cnt += x&1
		x /= 2
	}
	fmt.Println(cnt)
}

package main

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

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

//Wrong
func main() {
	defer writer.Flush()
	scanner.Split(bufio.ScanWords)

	n := nextInt()
	cntBit := 0

	for n > 0 {
		if n&1 == 1 {
			cntBit++
		}
		n >>= 1
	}

	println(cntBit)
}

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func next() string {
	if !scanner.Scan() {
		panic(scanner.Err())
	}
	return scanner.Text()
}

func nextInt64() int64 {
	n, _ := strconv.ParseInt(next(), 0, 64)
	return n
}

func nextInt() int {
	n, _ := strconv.Atoi(next())
	return n
}

func nextFloat() float64 {
	n, _ := strconv.ParseFloat(next(), 64)
	return n
}

func println(a ...interface{})               { fmt.Fprintln(writer, a...) }
func print(a ...interface{})                 { fmt.Fprint(writer, a...) }
func printf(format string, a ...interface{}) { fmt.Fprintf(writer, format, a...) }

package main

import (
	"fmt"
	"math"
)

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

	for n > 1 {
		j := int(math.Floor(math.Log2(float64(n))))
		n = n - (1 << j)
		count += 1
	}
	if n == 1 {
		count += 1
	}
	fmt.Println(count)
}

package main

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

func main() {
	var n int64
	fmt.Scanf("%d \n", &n)
	fmt.Print(strings.Count(strconv.FormatInt(n, 2), "1"))
}

package main

import "fmt"

func binary(n int) int {
	count := 0
	for n != 0 {
		if n % 2 == 1 {
			count++
		}
		n /= 2
	}
	return count
}

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

	fmt.Println(binary(n))
}

package main

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

func main() {
	var n int64
	fmt.Scanf("%d", &n)
	s := strconv.FormatInt(n, 2)
	fmt.Println(strings.Count(s, "1"))
}

package main

import "fmt"

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

	count := 0
	for n > 0 {
		if n&1 == 1 {
			count += 1
		}
		n >>= 1
	}

	fmt.Println(count)
}

package main

import "fmt"

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

	count := 0
	for n > 0 {
		if n%2 == 1 {
			count += 1
		}
		n = n / 2
	}

	fmt.Println(count)
}

package main

import "fmt"

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

	count := 0
	for ; n > 0; count++ {
		n &= (n - 1)
	}

	fmt.Println(count)
}

package main

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

var reader *bufio.Reader

func init() {
	stdin := os.Stdin
	// stdin, _ = os.Open("1.in")
	reader = bufio.NewReaderSize(stdin, 1<<20)
}

var n int

// NumberOf1 计算二进制中1的个数
func NumberOf1(n int) (res int) {
	for n != 0 {
		n &= (n - 1)
		res++
	}
	return
}

func main() {
	fmt.Fscan(reader, &n)
	fmt.Println(NumberOf1(n))
}

package main

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

func main() {
	var n int
	fmt.Fscanf(os.Stdin, "%d\n", &n)

	reminder := n
	val := math.Log2(float64(reminder))
	reminder -= (1 << uint(val))
	counter := 1

	for reminder > 0 {
		val = math.Log2(float64(reminder))
		reminder -= (1 << uint(val))
		counter++
	}

	fmt.Println(counter)

}

package main

import "fmt"

var x, res int

func main() {
	fmt.Scanf("%d", &x)
	res = popCountInt32(x)
	fmt.Printf("%d\n", res)
}

func popCountInt32(x int) (n int) {
	for x > 0 {
		n += x % 2
		x = x >> 1
	}
	return
}

package main

import "fmt"

func main() {
	var n, res int
	fmt.Scan(&n)
	for n > 0 {
		if n%2 == 0 {
			n /= 2
		} else {
			res++
			n--
		}
	}
	fmt.Println(res)
}

package main

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

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

//========== Implement Algorithm =======================
func solution(x int64) int64 {
	var temp int64
	temp = x
	var count int64
	count = 0
	for temp != 0 {
		if temp%2 == 1 {
			count++
		}
		temp = temp / 2
	}

	return count
}

func main() {

	scanner := bufio.NewScanner(os.Stdin)

	//================== Variables used ====================
	var x, ret int64
	//======================================================

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

		file, err := os.Open(os.Args[1])
		if err != nil {
			log.Fatalf("failed opening file: %s", err)
		}
		scanner = bufio.NewScanner(file)
		defer file.Close()

	}
	scanner.Split(bufio.ScanWords)
	//======================= I/O ==========================
	scanner.Scan()
	x = fastGetInt(scanner.Bytes())

	//======================================================
	ret = solution(x)
	//==================== OUTPUT ==========================

	fmt.Print(ret)
}

package main

import (
	"fmt"
	"math"
)

func main() {
	var n int
	fmt.Scanf("%d \n", &n)
	fmt.Println(findMinBacteries(float64(n)))
}

func findMinBacteries(n float64) int {
	c := 0
	for p := 0; n > 0; p++ {
		s := math.Pow(2, float64(p))
		if s > n {
			n -= math.Pow(2, float64(p-1))
			p = 0
			c++
		} else if s == n {
			n = 0
			c++
		}
	}
	return c
}

package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scanln(&x)
	a := 0
	for x>0 {
		a += x%2
		x /= 2
	}
	fmt.Println(a)
}

package main

import "fmt"

func main() {
	var n int
	var tot int
	fmt.Scan(&n)
	for n > 0 {
		tot++
		n &= (n - 1)
	}
	fmt.Println(tot)
}

package main

import "fmt"

// https://codeforces.com/problemset/problem/579/A
// комментарии к решению
// Т.к. бактерии удваиваются ежедневно, то нам достаточно
// контролировать только нечетные изменения. На примере:
// 5 {нужно получить}
// -> 4{было}+1{положили}
// -> 2{было}*2{1ночь}+1положили
// -> 1{было}*2{1ночь}*2{2ночь}+1положили
// -> (0{старт}+1{положили})*2{1ночь}*2{2ночь}+1положили
func taskSolution(n int) (ans int) {
	for n > 0 {
		if n%2 == 1 {
			ans += 1
		}
		n /= 2
	}
	return ans
}

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

	fmt.Println(taskSolution(n))
}

package main

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

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

//========== Implement Algorithm =======================
func solution(x int64) int64 {
	var temp int64
	temp = 1
	var count int64
	count = 0
	for temp < x/2 {
		temp = temp * 2
		count++
	}
	if temp*2 == x || x == 1 {
		return 0
	}
	if temp%2 == 1 {
		count++
	}
	return count
}

func main() {

	scanner := bufio.NewScanner(os.Stdin)

	//================== Variables used ====================
	var x, ret int64
	//======================================================

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

		file, err := os.Open(os.Args[1])
		if err != nil {
			log.Fatalf("failed opening file: %s", err)
		}
		scanner = bufio.NewScanner(file)
		defer file.Close()

	}
	scanner.Split(bufio.ScanWords)
	//======================= I/O ==========================
	scanner.Scan()
	x = fastGetInt(scanner.Bytes())

	//======================================================
	ret = solution(x)
	//==================== OUTPUT ==========================

	fmt.Print(ret + 1)
}

package main

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

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

//========== Implement Algorithm =======================
func solution(x int64) int64 {
	var temp int64
	temp = 1
	var count int64
	count = 0
	for temp < x/2 {
		temp = temp * 2
		count++
	}
	if temp*2 == x {
		return 0
	}
	if temp%2 == 1 {
		count++
	}
	return count
}

func main() {

	scanner := bufio.NewScanner(os.Stdin)

	//================== Variables used ====================
	var x, ret int64
	//======================================================

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

		file, err := os.Open(os.Args[1])
		if err != nil {
			log.Fatalf("failed opening file: %s", err)
		}
		scanner = bufio.NewScanner(file)
		defer file.Close()

	}
	scanner.Split(bufio.ScanWords)
	//======================= I/O ==========================
	scanner.Scan()
	x = fastGetInt(scanner.Bytes())

	//======================================================
	ret = solution(x)
	//==================== OUTPUT ==========================

	fmt.Print(ret + 1)
}


Kyoya Ootori is selling photobooks of the Ouran High School Host Club. He has 26 photos, labeled "a" to "z", and he has compiled them into a photo booklet with some photos in some order (possibly with some photos being duplicated). A photo booklet can be described as a string of lowercase letters, consisting of the photos in the booklet in order. He now wants to sell some "special edition" photobooks, each with one extra photo inserted anywhere in the book. He wants to make as many distinct photobooks as possible, so he can make more money. He asks Haruhi, how many distinct photobooks can he make by inserting one extra photo into the photobook he already has?Please help Haruhi solve this problem.

The first line of input will be a single string s (1 ≤ |s| ≤ 20). String s consists only of lowercase English letters.

Output a single integer equal to the number of distinct photobooks Kyoya Ootori can make.

NoteIn the first case, we can make 'ab','ac',...,'az','ba','ca',...,'za', and 'aa', producing a total of 51 distinct photo booklets.

package main

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

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

//Wrong
func main() {
	defer writer.Flush()
	scanner.Split(bufio.ScanWords)

	s := next()
	m := map[string]bool{}
	cnt := 0

	for i := 0; i <= len(s); i++ {
		for c := 'a'; c <= 'z'; c++ {
			t := s[0:i] + string(c) + s[i:len(s)]

			if checked, haveValue := m[t]; !haveValue && !checked {
				m[t] = true
				cnt++
			}
		}
	}

	println(cnt)
}

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func next() string {
	if !scanner.Scan() {
		panic(scanner.Err())
	}
	return scanner.Text()
}

func nextInt64() int64 {
	n, _ := strconv.ParseInt(next(), 0, 64)
	return n
}

func nextInt() int {
	n, _ := strconv.Atoi(next())
	return n
}

func nextFloat() float64 {
	n, _ := strconv.ParseFloat(next(), 64)
	return n
}

func println(a ...interface{})               { fmt.Fprintln(writer, a...) }
func print(a ...interface{})                 { fmt.Fprint(writer, a...) }
func printf(format string, a ...interface{}) { fmt.Fprintf(writer, format, a...) }

package main
import "fmt"

func main(){
    var s string
    fmt.Scan(&s)
    fmt.Println(len(s)*25+26)
}

package main

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

var inf int = 0x3f3f3f3f
var reader *bufio.Reader

func init() {
	stdin := os.Stdin
	// stdin, _ = os.Open("1.in")
	reader = bufio.NewReaderSize(stdin, 1<<20)
}

var s string

func main() {
	fmt.Fscan(reader, &s)
	m := make(map[string]int)
	for i := 0; i <= len(s); i++ {
		for j := 0; j < 26; j++ {
			t := s[0:i] + string(j+'a') + s[i:len(s)]
			m[t] = 1
		}
	}
	fmt.Println(len(m))
}


The preferred way to generate user login in Polygon is to concatenate a prefix of the user's first name and a prefix of their last name, in that order. Each prefix must be non-empty, and any of the prefixes can be the full name. Typically there are multiple possible logins for each person.You are given the first and the last name of a user. Return the alphabetically earliest login they can get (regardless of other potential Polygon users).As a reminder, a prefix of a string s is its substring which occurs at the beginning of s: "a", "ab", "abc" etc. are prefixes of string "{abcdef}" but "b" and 'bc" are not. A string a is alphabetically earlier than a string b, if a is a prefix of b, or a and b coincide up to some position, and then a has a letter that is alphabetically earlier than the corresponding letter in b: "a" and "ab" are alphabetically earlier than "ac" but "b" and "ba" are alphabetically later than "ac".

The input consists of a single line containing two space-separated strings: the first and the last names. Each character of each string is a lowercase English letter. The length of each string is between 1 and 10, inclusive.

Output a single string — alphabetically earliest possible login formed from these names. The output should be given in lowercase as well.

package main

/*
	To solve this problem basically we just need to generate login
	string which alphabetically earliest than any other string login string.

	The rules to generate login string are following:
	- must concatenate prefix of user's first name & last name
	- each prefix must not be empty
	- any prefix can be full name

	A string is said alphabetically earlier than other string if:
	- string is prefix of other string (ab >< abc, ab is earlier)
	- string is coincide up to some point with another
	  string then string has char which alphabetically earlier than
	  corresponding letter in another string (a >< ab >< ac => a < ab < ac)

	Notice that the minimum string we can generate is first[0] + last[0], yet
	with only this we already got decent enough early string. But can we make
	this string much earlier?

	Yes! If all char in first[1:] is alphabetically earlier than last[0]. So yeah,
	basically we just need to get all chars in first name which earlier than last[0],
	then combine them into a string.
*/

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

func main() {
	var first, second string
	stdio := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdio, "%s %s", &first, &second)
	idx := 1
	for i := 1; i < len(first); i++ {
		if first[i] < second[0] {
			idx++
		} else {
			break
		}
	}
	fmt.Println(first[:idx] + "" + second[:1])
}

package main

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

func main() {
	var first, second string
	stdio := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdio, "%s %s", &first, &second)
	idx := 1
	for i := 1; i < len(first); i++ {
		if first[i] < second[0] {
			idx++
		} else {
			break
		}
	}
	fmt.Println(first[:idx] + "" + second[:1])
}

package main

import (
	"fmt"
	"sort"
)

func main() {
	var a, b string
	fmt.Scanln(&a, &b)
	var str []string
	for i := 0; i < len(a); i++ {
		for j := 0; j < len(b); j++ {
			str = append(str, a[0:i+1]+b[0:j+1])
		}
	}
	sort.Strings(str)
	fmt.Println(str[0])
}

package main

import
(
	"fmt"

)

func main() {
	var a string
	var b string
	//var c string
	fmt.Scanln(&a, &b)
	//fmt.Scanf("%s", &b)
	fmt.Printf("%c", a[0])

	var i, j int
	i = 1
	j = 0
	for ; ;  {
		if i < len(a) && a[i] < b[j] {
			fmt.Printf("%c", a[i])
			i++
		} else {
			break
		}
	}
	fmt.Printf("%c", b[0])
	}


Mary has just graduated from one well-known University and is now attending celebration party. Students like to dream of a beautiful life, so they used champagne glasses to construct a small pyramid. The height of the pyramid is n. The top level consists of only 1 glass, that stands on 2 glasses on the second level (counting from the top), then 3 glasses on the third level and so on.The bottom level consists of n glasses.Vlad has seen in the movies many times how the champagne beautifully flows from top levels to bottom ones, filling all the glasses simultaneously. So he took a bottle and started to pour it in the glass located at the top of the pyramid.Each second, Vlad pours to the top glass the amount of champagne equal to the size of exactly one glass. If the glass is already full, but there is some champagne flowing in it, then it pours over the edge of the glass and is equally distributed over two glasses standing under. If the overflowed glass is at the bottom level, then the champagne pours on the table. For the purpose of this problem we consider that champagne is distributed among pyramid glasses immediately. Vlad is interested in the number of completely full glasses if he stops pouring champagne in t seconds.Pictures below illustrate the pyramid consisting of three levels.

The only line of the input contains two integers n and t (1 ≤ n ≤ 10, 0 ≤ t ≤ 10 000) — the height of the pyramid and the number of seconds Vlad will be pouring champagne from the bottle.

Print the single integer — the number of completely full glasses after t seconds.

NoteIn the first sample, the glasses full after 5 seconds are: the top glass, both glasses on the second level and the middle glass at the bottom level. Left and right glasses of the bottom level will be half-empty.

package main

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

var scanner *bufio.Scanner
var writer *bufio.Writer

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 main() {
  scanner = bufio.NewScanner(os.Stdin)
  scanner.Split(bufio.ScanWords)
  writer = bufio.NewWriter(os.Stdout)
  defer writer.Flush()

  zero := big.NewRat(0, 1)
  one := big.NewRat(1, 1)
  two := big.NewRat(2, 1)

  n, limit := getI(), getI()
  filled := make([][]*big.Rat, n)
  for r := range filled {
    filled[r] = make([]*big.Rat, r + 1)
    for c := range filled[r] {
      filled[r][c] = big.NewRat(0, 1)
    }
  }
  count := 0
  maxCount := (n + 1) * n / 2

  for t := 0; t < limit; t++ {
    pours := make([]*big.Rat, 1)
    pours[0] = big.NewRat(1, 1)
    for r := 0; r < n; r++ {
      allZero := true
      for _, pour := range pours {
        if pour.Cmp(zero) != 0 {
          allZero = false
          break
        }
      }
      if allZero {
        break
      }
      nextPours := make([]*big.Rat, r + 2)
      for i := range nextPours {
        nextPours[i] = big.NewRat(0, 1)
      }
      for c, pour := range pours {
        x := &big.Rat{}
        x.Add(filled[r][c], pour)
        if filled[r][c].Cmp(one) < 0 && x.Cmp(one) >= 0 {
          count++
          if count == maxCount {
            writer.WriteString(fmt.Sprintf("%d\n", count))
            return
          }
        }
        if x.Cmp(one) <= 0 {
          filled[r][c].Set(x)
          continue
        }
        pour.Sub(pour, one)
        pour.Add(pour, filled[r][c])
        filled[r][c].Set(one)
        pour.Quo(pour, two)
        nextPours[c].Add(nextPours[c], pour)
        nextPours[c + 1].Add(nextPours[c + 1], pour)
      }
      pours = nextPours
    }
  }

  writer.WriteString(fmt.Sprintf("%d\n", count))
}

// Codeforces 676 B
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"strconv"
)
var in *bufio.Reader

func readFive() (int,int,int,int,int) {
    var a [5]int
	s, err := in.ReadString('\n')
	if err != nil {
		fmt.Println("first read failure", err)
		panic(err)
	}
	ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for i:=0; i<len(ss); i++ {
        a[i], err = strconv.Atoi(ss[i])
        if err != nil {
            fmt.Println("n atoi failure", err)
            panic(err)
        }
    }
    return a[0],a[1],a[2],a[3],a[4]
}

func readLineNumbs(n int) []int {
    a := make([]int, n)
    s, err := in.ReadString('\n')
    if err != nil {
        fmt.Println("read failure", err)
        panic(err)
    }
    ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for j:=0; j<n; j++ {
        aa,err := strconv.Atoi(ss[j])
        if err != nil {
            fmt.Println("aa conv failed", err)
            panic(err)
        }
        a[j] = aa
    }
    return a
}

var n int
var t int
var res int

func readData() {
 	in = bufio.NewReader(os.Stdin)
	// reading n
    n,t,_,_,_ = readFive()
    //fmt.Printf("n,t = %d %d\n", n,t)
}

func solve() {
    var drob int64
    drob = 1<<24
    aa := make([]int64, n+2)
    an := make([]int64, n+2)
    aa[0] = int64(t)*drob
    countFull := 0
    for i:=0; i<n; i++ {
        // print a
        //fmt.Print(i)
        for j:=0; j<n+1; j++ {
            //fmt.Printf(" %12d ", aa[j])
        }
        //fmt.Println()
        // clear an
        for j:=0; j<=n; j++ {
            an[j] = 0.0;
        }
        for j:=0; j<=n; j++ {
            if aa[j] >= drob {
                countFull ++
                v := aa[j]
                v = (v-drob)/2
                //fmt.Printf("a,v= %f %f\n",aa[j], v)
                an[j] += v
                an[j+1] += v
            }
        }
        // copy an -> a
         for j:=0; j<n+1; j++ {
             aa[j] = an[j]
        }
    }
    res = countFull
}

func main() {
 	readData()

    solve()

    // print aqnswer
    fmt.Println(res)
}

package main

import (
	"fmt"
)

func pour(amount int, depth int, index int, pyrimid [][]int) {
	if depth >= len(pyrimid) {
		return
	}
	pyrimid[depth][index] += amount
	if pyrimid[depth][index] > 1024 {
		remain := pyrimid[depth][index] - 1024
		pyrimid[depth][index] = 1024
		pour(remain/2, depth+1, index, pyrimid)
		pour(remain/2, depth+1, index+1, pyrimid)
	}
}

func main() {
	var n, t int
	fmt.Scanf("%d%d", &n, &t)
	pyrimid := make([][]int, n, n)

	for i := 1; i <= n; i++ {
		pyrimid[i-1] = make([]int, i, i)
	}

	full_cnt := 0
	if t > 1024 {
		full_cnt = (1 + n)*n/2
		fmt.Println(full_cnt)
		return
	}

	for i := 0; i < t; i++ {
		pour(1024, 0, 0, pyrimid)
	}
	for i := 0; i < n; i++ {
		for j := 0; j <= i; j++ {
			if pyrimid[i][j] >= 1024 {
				full_cnt += 1
			}
		}
	}
//	fmt.Println(pyrimid)
	fmt.Println(full_cnt)
}

package main

import (
	"fmt"
	"os"
)

var one = int64(0x10000)

func progressRow(p [][]int64, row int) (spill bool) {
	spill = false
	for i := 0; i <= row; i++ {
		if p[row][i] > one {
			spill = true
			diff := p[row][i] - one
			diff >>= 1
			p[row+1][i] += diff
			p[row+1][i+1] += diff
			p[row][i] = one
		}
	}
	return spill
}

func progress(p [][]int64, n int) {
	p[0][0] += one
	for i := 0; i < n; i++ {
		spill := progressRow(p, i)
		if !spill {
			return
		}
	}
}

func solve(n, t int) int {
	p := make([][]int64, n+1)
	for i := 0; i <= n; i++ {
		p[i] = make([]int64, i+1)
	}
	for i := 0; i < t; i++ {
		progress(p, n)
	}
	count := 0
	for i := 0; i < n; i++ {
		for j := 0; j < i+1; j++ {
			if p[i][j] >= one {
				count++
			}
		}
	}
	return count
}

func main() {
	var n, t int
	nr, err := fmt.Fscanln(os.Stdin, &n, &t)
	if nr != 2 || err != nil {
		panic(err)
	}
	res := solve(n, t)
	fmt.Println(res)
}

package main

import (
	"fmt"
	//"math"
)

var glasses [][]float32
var n int
var t int
func fill(glassNum int, level int, volume float32) {
	glasses[level][glassNum] += volume
	if glasses[level][glassNum] > 1 {
		remainVolume := glasses[level][glassNum] - 1
		glasses[level][glassNum] = 1
		if level != n - 1 {
			fill(glassNum, level + 1, remainVolume / 2.0)
			fill(glassNum + 1, level + 1, remainVolume / 2.0)
		}
	}
}

func main() {

	//fmt.Print(math.Abs(2 - 1))

	fmt.Scan(&n, &t)

	glasses = make([][]float32, 10)

	for i := range glasses {
		glasses[i] = make([]float32, i + 1)
	}

	for i := 0 ; i < t; i++ {
		fill(0,0,1)
	}

	ans := 0
	for i := range glasses {
		for j := range glasses[i] {
			if glasses[i][j] == 1 {
				ans++
			}
		}
		glasses[i] = make([]float32, i + 1)
	}

	fmt.Print(ans)

}

// Codeforces 676 B
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"strconv"
)
var in *bufio.Reader

func readFive() (int,int,int,int,int) {
    var a [5]int
	s, err := in.ReadString('\n')
	if err != nil {
		fmt.Println("first read failure", err)
		panic(err)
	}
	ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for i:=0; i<len(ss); i++ {
        a[i], err = strconv.Atoi(ss[i])
        if err != nil {
            fmt.Println("n atoi failure", err)
            panic(err)
        }
    }
    return a[0],a[1],a[2],a[3],a[4]
}

func readLineNumbs(n int) []int {
    a := make([]int, n)
    s, err := in.ReadString('\n')
    if err != nil {
        fmt.Println("read failure", err)
        panic(err)
    }
    ss := strings.Split(strings.Trim(s, " \n\r"), " ")
    for j:=0; j<n; j++ {
        aa,err := strconv.Atoi(ss[j])
        if err != nil {
            fmt.Println("aa conv failed", err)
            panic(err)
        }
        a[j] = aa
    }
    return a
}

var n int
var t int
var res int

func readData() {
 	in = bufio.NewReader(os.Stdin)
	// reading n
    n,t,_,_,_ = readFive()
    //fmt.Printf("n,t = %d %d\n", n,t)
}

func solve() {
    aa := make([]float64, n+1)
    an := make([]float64, n+1)
    aa[0] = float64(t)
    countFull := 0
    for i:=0; i<n+1; i++ {
        // clear an
        for j:=0; j<n; j++ {
            an[j] = 0.0;
        }
        for j:=0; j<n; j++ {
            if aa[j] >= 0.999999999999 {
                countFull ++
                v := (aa[j] - 1.0)/2.0
                //fmt.Printf("a,v= %f %f\n",aa[j], v)
                an[j] += v
                an[j+1] += v
            }
        }
        // copy an -> a
        //fmt.Println(i)
        for j:=0; j<n; j++ {
            //fmt.Printf("%f ", an[j])
            aa[j] = an[j]
        }
    }
    res = countFull
}

func main() {
 	readData()

    solve()

    // print aqnswer
    fmt.Println(res)
}


There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string s. The i-th (1-based) character of s represents the color of the i-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times.Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, if Liss is standing on a stone whose colors is c, Liss will move one stone forward, else she will not move.You are given a string t. The number of instructions is equal to the length of t, and the i-th character of t represents the i-th instruction.Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence.

The input contains two lines. The first line contains the string s (1 ≤ |s| ≤ 50). The second line contains the string t (1 ≤ |t| ≤ 50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence.

Print the final 1-based position of Liss in a single line.

package main

import "fmt"

func main() {
	var s, t string
	fmt.Scan(&s, &t)
	i := 0
	for j := range t {
		if s[i] == t[j] {
			i += 1
		}
	}
	fmt.Println(i + 1)
}

package main

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

func main() {
    reader := bufio.NewReader(os.Stdin)
    s, _ := reader.ReadString('\n')
    t, _ := reader.ReadString('\n')
    ans := 0
    for i:= 0; i < len(t); i++ {
        if s[ans] == t[i] {
            ans++
        }
    }
   fmt.Print(ans+1)
}

package main

import (
	"fmt"
)

func main() {
	var a,b string
	var p int
	fmt.Scan(&a,&b)
	for i:=0;i<len(b);i++ {
		if a[p]==b[i] {
			p++
		}
	}
	p+=1
	fmt.Println(p)
}

package main

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

var scanner *bufio.Scanner
var writer *bufio.Writer

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 main() {
  scanner = bufio.NewScanner(os.Stdin)
  scanner.Split(bufio.ScanWords)
  writer = bufio.NewWriter(os.Stdout)
  defer writer.Flush()

  s, t := getS(), getS()
  sPos := 0
  for _, ch := range t {
    if rune(s[sPos]) == ch {
      sPos++
    }
  }
  writer.WriteString(fmt.Sprintf("%d\n", sPos+1))
}

package main

import "fmt"

func main() {
    var s,t string
    fmt.Scan(&s)
    fmt.Scan(&t)
    pos := 0
    for i := 0; i < len(t); i++ {
        if t[i] == s[pos] {
            pos++
        }
    }
    fmt.Println(pos+1)
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	re := regexp.MustCompile(`\r?\n`)

	var s, t string

	if in, err := reader.ReadString('\n'); err != nil {
		if err != io.EOF {
			return
		}
	} else {
		s = re.ReplaceAllString(in, "")
	}

	if in, err := reader.ReadString('\n'); err != nil {
		if err != io.EOF {
			return
		}
	} else {
		t = re.ReplaceAllString(in, "")
	}

	pos := 0
	for i := 0; i < len(t); i++ {
		if t[i] == s[pos] {
			pos++
		}
	}

	fmt.Println(pos + 1)
}

package main

import "fmt"

func main() {
	var standingStone string
	fmt.Scanf("%s\n", &standingStone)
	var instructions string
	fmt.Scanf("%s\n", &instructions)
	var positionOnStone int
	for i := 0; i < len(instructions); i++ {
		if instructions[i] == standingStone[positionOnStone] {
			positionOnStone += 1
		}
	}
	fmt.Println(positionOnStone + 1)
}

package main

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

func main() {
	var path, instro string
	var c, j int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscanf(in, "%s\n", &path)
	fmt.Fscanf(in, "%s\n", &instro)
	for i := 0; i < len(instro); i++ {
		if instro[i] == path[j] {
			c++
			j++
		}
	}
	fmt.Println(c + 1)
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var s, t string
	fmt.Fscan(reader, &s, &t)

	var count int
	for index := range t {
		if t[index] == s[count] {
			count++
		}
	}

	fmt.Println(count + 1)

}

package main

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

func main() {
	var stringPosition, stringInstructions string
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &stringPosition)
	fmt.Fscan(reader, &stringInstructions)
	initialPostion := 0
	for index := 0; index < len(stringInstructions); index++ {
		if stringInstructions[index] == stringPosition[initialPostion] {
			initialPostion++
		}
	}
	fmt.Println(initialPostion + 1)

}

// 265A-mic
package main

import (
	"fmt"
)

func main() {
	var s, inst string
	pos := 1
	r := 0
	fmt.Scan(&s)
	fmt.Scan(&inst)
	for i := 0; i < len(inst); i++ {
		if inst[i] == s[r] {
			if pos != len(s) {
				r++
				pos++
			}
		}
	}
	fmt.Println(pos)
}

package main

import "fmt"

func main()  {
	var stones string
	fmt.Scan(&stones)
	var instructions string
	fmt.Scan(&instructions)
	steps := 0

	for index :=0;index < len(instructions); index++ {
		if stones[steps] == instructions[index] {
			steps++
		}
	}
	fmt.Print(steps+1);
}

// 265A-mic
package main

import (
    "fmt"
)

func main() {
    var s, inst string
    pos := 1
    r := 0
    fmt.Scan(&s)
    fmt.Scan(&inst)
    for i := 0; i < len(inst); i++ {
        if inst[i] == s[r] {
            if pos != len(s)-1 {
                r++
                pos++
            }
        }
    }
    fmt.Println(pos)
}