package main

import "fmt"

func main() {
    var n, k int
    fmt.Scan(&n, &k)
    ballonByColor := make([]int, 256)
    var str string
    fmt.Scan(&str)
    for _, r := range str {
        ballonByColor[int(r)]++
    }
    for i:=0; i<256; i++ {
        if ballonByColor[i] > k {
            fmt.Print("NO")
            return
        }
    }
    fmt.Print("YES")
}

package main

import (
	"fmt"
)

func main() {
	var balls string
	var n,k int

	fmt.Scan(&n, &k, &balls)

	colors := make(map[rune]int,0)

	for _,clr := range balls {
		colors[clr]++
	}

	for _,num := range colors {
		if num > k {
			fmt.Println("NO")
			return
		}
	}

	fmt.Println("YES")
}

package main

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

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

	readInt(reader)
	k := readInt(reader)
	skipLine(reader)

	a := make(map[byte]int, 26)
	s := readLine(reader)

	//fmt.Printf("*s:%v\n", *s)

	for i := 0; i<len((*s)); i++ {
		c, ok := a[(*s)[i]];
		if !ok {
			a[(*s)[i]] = 1
		} else {
			a[(*s)[i]] = c + 1
		}
	}

	//fmt.Printf("a:%v\n", a)

	ok := true
	for _, v := range a {
		if v>k {
			ok = false
			break
		}
	}

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

}

func readLine(nr *bufio.Reader) *string {
	line, _, err := nr.ReadLine()
	if err!=nil {
		panic(err)
	}
	s := string(line)
	return &s
}

func skipLine(nr *bufio.Reader) {
	_, _, err := nr.ReadLine()
	if err!=nil {
		panic(err)
	}
}

func readInt(nr *bufio.Reader) int {
	var a int
	fmt.Fscan(nr, &a)
	return a
}

func readA(n int) *[]int {
	a := make([]int, n)

	reader := bufio.NewReader(os.Stdin)

	for i := 0; i<n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	return &a
}

package main

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

func main() {
    var n, k int
    var baloons string
    var m = make(map[string]int)

    stdin := bufio.NewReader(os.Stdin)
    fmt.Fscanf(stdin, "%d %d\n", &n, &k)
    fmt.Fscanf(stdin, "%s\n", &baloons)

    // count number of baloon based on color
    for i := 0; i < n; i++ {
        m[string(baloons[i])]++
    }

    isPossible := true
    for _, v := range m {
        if v > k {
            isPossible = false
            break
        }
    }

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

package main

/*
    The idea to solve this problem is by noticing that we need to make sure
    that each friends given baloon by Kefa doesn't get same color more than once.
    Which means the number of baloon of for each color must be the same number
    of Kefa friends or less (because his friends won't be angry if they do not get
    baloon)
*/

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

func main() {
    var n, k int
    var baloons string
    var m = make(map[string]int)

    stdin := bufio.NewReader(os.Stdin)
    fmt.Fscanf(stdin, "%d %d\n", &n, &k)
    fmt.Fscanf(stdin, "%s\n", &baloons)

    // count number of baloon based on color
    for i := 0; i < n; i++ {
        m[string(baloons[i])]++
    }

    isPossible := true
    for _, v := range m {
        if v > k {
            isPossible = false
            break
        }
    }

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

package main

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

const maxInputSize = 512 * 1024 //bytes

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, maxInputSize), maxInputSize)

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

	scanner.Scan()
	k, _ := strconv.Atoi(scanner.Text())
	scanner.Scan()
	s := scanner.Text()

	yes := true
	l := make([]int, 26)

	for i := 0; i < n; i++ {
		l[s[i]-97]++
		if l[s[i]-97] > k {
			yes = false
		}
	}

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

package main

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

func solve() {
	_ = readInt()
	k := readInt()
	cnt := map[rune]int{}
	for _, v := range readString() {
		cnt[v]++
	}
	for _, v := range cnt {
		if v > k {
			fmt.Println("NO")
			return
		}

	}
	fmt.Println("YES")
}

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 abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

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

func main() {
	sc := NewScanner()
	N, A := sc.NextInt(), sc.NextInt()

	S := sc.NextLine()

	mp := map[byte]int{}

	for i := 0; i < N; i++ {
		mp[S[i]]++
	}

	for _, v := range mp {
		if v > A {
			fmt.Println("NO")
			return
		}
	}
	fmt.Println("YES")

}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *Scanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 0)
			result = append(result, int(v))
			start = s.p + 1
		}
	}

	return result
}
func (s *Scanner) NextInt64Array() []int64 {
	s.pre()
	start := s.p
	result := []int64{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 64)
			result = append(result, v)
			start = s.p + 1
		}
	}
	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}

package main

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

func main() {
	sc := NewScanner()
	N, A := sc.NextInt(), sc.NextInt()

	S := sc.NextLine()

	mp := map[byte]int{}

	for i := 0; i < N; i++ {
		mp[S[i]]++
	}

	for _, v := range mp {
		if v<A{
			fmt.Println("NO")
			return
		}
	}
	fmt.Println("YES")

}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *Scanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 0)
			result = append(result, int(v))
			start = s.p + 1
		}
	}

	return result
}
func (s *Scanner) NextInt64Array() []int64 {
	s.pre()
	start := s.p
	result := []int64{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 64)
			result = append(result, v)
			start = s.p + 1
		}
	}
	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}


package main

import "fmt"

func solve(s, x int64) int64 {
	if (s-x)%2 == 1 {
		return 0
	}
	if ((s-x)/2)&x != 0 {
		return 0
	}
	if s < x {
		return 0
	}
	res := int64(1)
	for y := x; y > 0; y &= (y - 1) {
		res *= 2
	}
	if s-x == 0 {
		res -= 2
	}
	return res
}

func main() {
	var s, x int64
	fmt.Scan(&s, &x)
	fmt.Println(solve(s, x))
}

package main

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

var (
	in  = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
)

const BITS = 50

var s, x int64

func main() {
	defer out.Flush()
	fmt.Fscan(in, &s, &x)
	ans := solve(0, 0)
	if s == x {
		ans -= 2
	}
	fmt.Fprintln(out, ans)
}

func solve(i, carry int) int64 {
	if i == BITS {
		if carry == 0 {
			return 1
		}
		return 0
	}
	key := Key{i, carry}
	if result, ok := cache[key]; ok {
		return result
	}
	result := int64(0)
	for a := 0; a <= 1; a++ {
		b := a ^ get(i, x)
		sum := a + b + carry
		if sum&1 == get(i, s) {
			result += solve(i+1, sum>>1)
		}
	}
	cache[key] = result
	return result
}

var cache = map[Key]int64{}

type Key struct {
	i, carry int
}

func get(i int, x int64) int {
	return int((x >> uint(i)) & 1)
}

package main

import (
	. "fmt"
	"io"
	"math/bits"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func CF627A(in io.Reader, out io.Writer) {
	var s, x, ans int64
	Fscan(in, &s, &x)
	if d := s - x; d >= 0 && d&1 == 0 && d/2|x == d/2+x {
		ans = int64(1) << bits.OnesCount64(uint64(x))
		if d == 0 {
			ans -= 2
		}
	}
	Fprint(out, ans)
}

func main() { CF627A(os.Stdin, os.Stdout) }

package main

import (
	. "fmt"
	"math/bits"
)

// github.com/EndlessCheng/codeforces-go
func main() {
	var s, x, ans int64
	Scan(&s, &x)
	if d := s - x; d >= 0 && d&1 == 0 && d/2|x == d/2+x {
		ans = int64(1) << bits.OnesCount64(uint64(x))
		if d == 0 {
			ans -= 2
		}
	}
	Print(ans)
}

package main

import (
	"fmt"
)

func needs(sum, xor, carry, digit int64) int64 {
	if digit <= 0 {
		if carry == 0 {
			return 1
		}
		return 0
	}

	if (xor & digit) != 0 {
		if (sum & digit) != 0 {
			if carry != 0 {
				return 0
			}
			return 2 * needs(sum, xor, 0, digit>>1)
		}
		if carry != 0 {
			return 2 * needs(sum, xor, 1, digit>>1)
		}
		return 0
	}

	if (sum & digit) != 0 {
		return needs(sum, xor, 1, digit>>1)
	}
	return needs(sum, xor, 0, digit>>1)
}

func main() {
	var sum, xor int64
	fmt.Scan(&sum, &xor)

	if sum != xor {
		fmt.Println(needs(sum, xor, 0, 1<<62))
	} else {
		fmt.Println(needs(sum, xor, 0, 1<<62) - 2)
	}
}

package main

import (
	"fmt"
)

func needs(sum, xor, carry, digit int64) int64 {
	if digit < 1 {
		return 1 - carry
	}

	if (xor & digit) != 0 {
		if (sum & digit) != 0 {
			return (1 - carry) * 2 * needs(sum, xor, 0, digit>>1)
		}
		return carry * 2 * needs(sum, xor, 1, digit>>1)
	}

	if (sum & digit) != 0 {
		return needs(sum, xor, 1, digit>>1)
	}
	return needs(sum, xor, 0, digit>>1)
}

func main() {
	var sum, xor int64
	fmt.Scan(&sum, &xor)

	if sum != xor {
		fmt.Println(needs(sum, xor, 0, 1<<62))
	} else {
		fmt.Println(needs(sum, xor, 0, 1<<62) - 2)
	}
}

package main

import (
	"fmt"
)

func main() {
	var sum, xor, count, total int
	fmt.Scan(&sum, &xor)
	var bits []int
	count = 0

	for xor > 0 {
		count = (count << 1) | 1
		bits = append(bits, xor-xor&(xor-1))
		xor = xor & (xor - 1)
	}

	for ; count >= 0; count-- {
		left := 0
		right := 0

		for i, val := range bits {
			if (count & (1 << uint(i))) > 0 {
				left += val
			} else {
				right += val
			}
		}

		if left >= sum || right >= sum {
			continue
		}
		if left == right {
			total++
			if (sum-(left+right))%2 != 0 {
				total++
			}
		} else {
			if (sum-(left+right))%2 == 0 {
				total++
			}
		}
		// fmt.Println(count, bits, left, right, "=", total)
	}
	fmt.Println(total)
}

package main

import (
	"fmt"
)

func main() {
	var sum, xor int
	fmt.Scan(&sum, &xor)

	if ((sum - xor) % 2) != 0 {
		fmt.Println(0)
		return
	}
	xorbits := 0
	sumbits := 0
	mask := 1

	for mask <= xor && mask <= sum {
		if xor&mask > 0 {
			xorbits++
		}
		if sum&mask > 0 {
			sumbits++
		}
		mask <<= 1
	}
	xorbits *= 2

	if sum&xor == sum {
		xorbits -= sumbits
	}
	fmt.Println(xorbits)
}

package main

import (
	"fmt"
)

func main() {
	var sum, xor, count, total int
	fmt.Scan(&sum, &xor)
	var bits []int
	count = 0

	for xor > 0 {
		count = (count << 1) | 1
		bits = append(bits, xor-xor&(xor-1))
		xor = xor & (xor - 1)
	}

	for ; count >= 0; count-- {
		left := 0
		right := 0

		for i, val := range bits {
			if (count & (1 << uint(i))) > 0 {
				left += val
			} else {
				right += val
			}
		}

		if left >= sum || right >= sum {
			continue
		}
		if left == right {
			total++
			if sum-(left+right)%2 != 0 {
				total++
			}
		} else {
			if (sum-(left+right))%2 == 0 {
				total++
			}
		}
		// fmt.Println(count, bits, left, right, "=", total)
	}
	fmt.Println(total)
}

package main

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

var (
	in  = bufio.NewReader(os.Stdin)
	out = bufio.NewWriter(os.Stdout)
)

const BITS = 15

var s, x int

func main() {
	defer out.Flush()
	fmt.Fscan(in, &s, &x)

	//for i := 0; i < BITS; i++ {
	//	fmt.Fprint(out, get(i, s))
	//}
	//fmt.Fprintln(out)
	//for i := 0; i < BITS; i++ {
	//	fmt.Fprint(out, get(i, x))
	//}
	//fmt.Fprintln(out)

	ans := solve(0, 0)
	if s == x {
		ans -= 2
	}
	fmt.Fprintln(out, ans)
}

func solve(i, carry int) int64 {
	if i == BITS {
		if carry == 0 {
			return 1
		}
		return 0
	}
	key := Key{i, carry}
	if result, ok := cache[key]; ok {
		return result
	}
	result := int64(0)
	for a := 0; a <= 1; a++ {
		b := a ^ get(i, x)
		sum := a + b + carry
		if sum&1 == get(i, s) {
			//fmt.Fprintln(out, i, a, b, carry, "works", sum>>1)
			result += solve(i+1, sum>>1)
		}
	}
	//fmt.Fprintln(out, i, carry, ">", result)
	cache[key] = result
	return result
}

var cache = map[Key]int64{}

type Key struct {
	i, carry int
}

func get(i, x int) int {
	return (x >> uint(i)) & 1
}

package main

import (
	. "fmt"
	"io"
	"math/bits"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func CF627A(in io.Reader, out io.Writer) {
	var s, x, ans int64
	Fscan(in, &s, &x)
	if d := s - x; d >= 0 && d&1 == 0 && d/2|x == d/2+x {
		if d == 0 {
			x--
		}
		ans = int64(1) << bits.OnesCount64(uint64(x))
	}
	Fprint(out, ans)
}

func main() { CF627A(os.Stdin, os.Stdout) }


package main

import (
	"fmt"
)

func pow(a, b int64) int64 {
	if b <= 0 {
		return 1
	}
	if b <= 1 {
		return a
	}
	return pow((a*a)%100, b/2)
}

func main() {
	var b int64
	fmt.Scan(&b)
	fmt.Println(pow(5, b))
}

package main

import (
	"fmt"
)

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

	switch n {
	case 0:
		fmt.Println("1")
	case 1:
		fmt.Println("5")
	default:
		fmt.Println("25")
	}
}

package main

import "fmt"

func main() {
	fmt.Println(25)
}

package main

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

// Buffered IO for fast I/O.
var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

// Helper function to wrap around the buffered IO.
func printf(f string, a ...interface{}) {
	fmt.Fprintf(writer, f, a...)
}

// Helper function to take an input from the user.
func scanf(f string, a ...interface{}) {
	fmt.Fscanf(reader, f, a...)
}

// Solve
func solve() {
	// Solve the problem!
	var numberOfFactors int
	scanf("%d", &numberOfFactors)

	// Any 5 powered by anything will always have '25' as its last two digits.
	printf("25\n")
	return
}

func main() {
	defer writer.Flush()
	solve()
}

package main

import "fmt"

func main(){
	fmt.Println(25)
}

package main

import "fmt"

func main() {
	fmt.Println("25")
}

package main

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

func main() {
	var n uint64
	in := bufio.NewReader(os.Stdin)
    fmt.Fscanf(in, "%d \n", &n)
    fmt.Println(25)
    // result := int(math.Pow(5, float64(n)))
    // stringresult := strconv.Itoa(result)
    // fmt.Println(stringresult[len(stringresult)-2:len(stringresult)])
}

package main

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

const INF  = 1000000001

type Pair struct {
	first, second int
}

func sort(arr []Pair) []Pair {
	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].first > arr[right].first {
			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 sort2(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]

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

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

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

func solution(reader io.Reader, writer io.Writer) {
	fmt.Println(25)
}

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

func main() {

	var n int64
	fmt.Scan(&n)
	fmt.Println(25)
}

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Fprintln(os.Stdout, 25)
}

package main

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

func main() {
	var n uint64
	in := bufio.NewReader(os.Stdin)
	fmt.Fscanf(in, "%d \n", &n)
    result := int(math.Pow(5, float64(n)))
    stringresult := strconv.Itoa(result)
    fmt.Println(stringresult[len(stringresult)-2:len(stringresult)])
}

package main
import "fmt"
func main() {
    fmt.Println("hello world")
}

package main

import (
	"fmt"
)

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

	switch n {
	case 0:
		fmt.Println("1")
	case 1:
		fmt.Println("5")
	default:
		fmt.Println("25")
	}
}


// 287A-mic
package main

import (
    "fmt"
)

func main() {
    arr := make([]string, 4)
    for i := 0; i < 4; i++ {
        fmt.Scan(&arr[i])
    }

    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if arr[i][j] == arr[i][j+1] && arr[i][j] == arr[i+1][j] && arr[i][j] == arr[i+1][j+1] {
                fmt.Println("YES")
                return
            } else if arr[i][j] == arr[i][j+1] && arr[i][j] == arr[i+1][j] {
                fmt.Println("YES")
                return
            } else if arr[i][j] == arr[i][j+1] && arr[i][j] == arr[i+1][j+1] {
                fmt.Println("YES")
                return
            } else if arr[i+1][j] == arr[i+1][j+1] && arr[i+1][j] == arr[i][j+1] {
                fmt.Println("YES")
                return
            } else if arr[i+1][j] == arr[i+1][j+1] && arr[i+1][j] == arr[i][j] {
                fmt.Println("YES")
                return
            }
        }
    }
    fmt.Println("NO")

}

package main

import "fmt"

func check(x [4]string, a int, b int) bool {
    cnt := 0
    for i := a; i < (a+2); i++ {
        for j := b; j < (b+2); j++ {
            if x[i][j] != x[a][b] { cnt++ }
        }
    }
    if cnt == 2 { return false } else { return true }
}

func main() {
    var x [4]string
    for i := 0; i < 4; i++ {
        fmt.Scan(&x[i])
    }
    ans := false
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if check(x,i,j) {
                ans = true
                break
            }
        }
    }
    if ans { fmt.Println("YES") } else { fmt.Println("NO") }
}

package main

import "fmt"

func check(x [4]string, a int, b int) bool { // mengecek return value fungsi array x elemen ke 4, variabel a dan b dengan jenis int
    cnt := 0                    // membuat variabel cnt kemudian diisi dengan 0
    for i := a; i < (a+2); i++ {                // looping
        for j := b; j < (b+2); j++ {                // looping ke 2
            if x[i][j] != x[a][b] { cnt++ }  // jika array x elemen i dan j tidak sama dengan array x elemen a dan b maka cnt ditambah
        }
    }
    if cnt == 2 { return false } else { return true } // jika cnt sama dengan 2 maka return false, lainnya return true
}

func main() {
    var x [4]string     // membuat variabel array x elemen ke 4 dengan jenis string
    for i := 0; i < 4; i++ { // looping ke 3
        fmt.Scan(&x[i])   // mengambil input
    }
    ans := false        // membuat variabel ans kemudian diisi dengan false
    for i := 0; i < 3; i++ {    //looping ke 4
        for j := 0; j < 3; j++ {  // looping ke 5
            if check(x,i,j) {   // jika check x,i dan j maka ans sama dengan true kemudian keluar dari fungsi
                ans = true
                break
            }
        }
    }
    if ans { fmt.Println("YES") } else { fmt.Println("NO") } // jika ans maka cetak Yes, lainnya cetak NO
}

package main

import "fmt"

func main() {
	s := make([]string, 4)
	for i := range s {
		fmt.Scanln(&s[i])
	}
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			cnt := 0
			if s[i][j] == '.' {
				cnt++
			}
			if s[i+1][j] == '.' {
				cnt++
			}
			if s[i][j+1] == '.' {
				cnt++
			}
			if s[i+1][j+1] == '.' {
				cnt++
			}
			if cnt != 2 {
				fmt.Println("YES")
				return
			}
		}
	}
	fmt.Println("NO")
}

package main

import "fmt"

func check(x [4]string, a int, b int) bool {
    cnt := 0
    for i := a; i < (a+2); i++ {
        for j := b; j < (b+2); j++ {
            if x[i][j] != x[a][b] { cnt++ }
        }
    }
    if cnt <= 1 { return true } else { return false }
}

func main() {
    var x [4]string
    for i := 0; i < 4; i++ {
        fmt.Scan(&x[i])
    }
    ans := false
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if check(x,i,j) {
                ans = true
                break
            }
        }
    }
    if ans { fmt.Println("YES") } else { fmt.Println("NO") }
}

package main

import "fmt"

func main() {
	s := make([]string, 4)
	for i := range s {
		fmt.Scanln(&s[i])
	}
	for i := 0; i < 2; i++ {
		for j := 0; j < 2; j++ {
			cnt := 0
			if s[i][j] == '.' {
				cnt++
			}
			if s[i+1][j] == '.' {
				cnt++
			}
			if s[i][j+1] == '.' {
				cnt++
			}
			if s[i+1][j+1] == '.' {
				cnt++
			}
			if cnt <= 1 || cnt >= 3 {
				fmt.Println("YES")
				return
			}
		}
	}
	fmt.Println("NO")
}


package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	ans := 0
	for i := range s {
		switch s[i] {
		case 'a', 'e', 'i', 'o', 'u', '1', '3', '5', '7', '9':
			ans++
		}
	}
	fmt.Println(ans)
}

package main

/*
	To verify whether or not the statement is valid, basically
	we just need to check cards with vowel or cards with odd number
*/

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

func main() {
	var str string
	stdin := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdin, "%s", &str)
	shouldCheck := 0
	for i := 0; i < len(str); i++ {
		ch := string(str[i])
		num, err := strconv.Atoi(ch)
		if err != nil {
			if ch == "a" || ch == "i" || ch == "u" || ch == "e" || ch == "o" {
				shouldCheck++
			}
		} else {
			if num%2 != 0 {
				shouldCheck++
			}
		}
	}
	fmt.Println(shouldCheck)
}

package main

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

func main() {
	var str string
	stdin := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdin, "%s", &str)
	shouldCheck := 0
	for i := 0; i < len(str); i++ {
		ch := string(str[i])
		num, err := strconv.Atoi(ch)
		if err != nil {
			if ch == "a" || ch == "i" || ch == "u" || ch == "e" || ch == "o" {
				shouldCheck++
			}
		} else {
			if num%2 != 0 {
				shouldCheck++
			}
		}
	}
	fmt.Println(shouldCheck)
}

package main

import "fmt"

func main() {
	var s string
	var ans int
	vowel := []int32{'a','e','i','o','u','1','3','5','7','9'}
	fmt.Scanf("%s",&s)
	for _, ch := range s {
		for _, v := range vowel {
			if ch == v {
				ans++
			}
		}
	}
	fmt.Print(ans)
}

package main

import "fmt"

func vowel_l(r rune) bool {
    if r == 'a' || r == 'e' || r == 'i' || r == 'o' || r == 'u' {
        return true
    }
    return false
}

func odd(r rune) bool {
    if r == '1' || r == '3' || r == '5' || r == '7' || r == '9' {
        return true
    }
    return false
}

func main() {
    var s string
    fmt.Scan(&s)
    var cnt int
    for _, r := range s {
        if vowel_l(r) || odd(r) {
            cnt++
        }
    }
    fmt.Print(cnt)
}

package main

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

func main() {
	sc := NewScanner()
	S := sc.NextLine()
	count := 0
	for _, v := range S {
		switch v {
		case 'a', 'i', 'u', 'e', 'o', '1', '3', '5', '7', '9':
			count++

		}
	}
	fmt.Println(count)

}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *Scanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 0)
			result = append(result, int(v))
			start = s.p + 1
		}
	}

	return result
}
func (s *Scanner) NextInt64Array() []int64 {
	s.pre()
	start := s.p
	result := []int64{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 64)
			result = append(result, v)
			start = s.p + 1
		}
	}
	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanln(&s)
	var ans int
	for i := 0; i < len(s); i++ {
		if s[i] >= '0' && s[i] <= '9' {
			if (s[i]-'0')%2 == 1 {
				ans++
			}
		} else {
			if strings.IndexByte("aeiou", s[i]) != -1 {
				ans++
			}
		}
	}
	fmt.Println(ans)
}

package main

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

func main() {
	var s string
	fmt.Scan(&s)
	g := "aeiou"
	k := 0
	for _,a := range s {
		if strings.Count(g,string(a)) >0  {
			k++
		}
		n,err := strconv.Atoi(string(a))
		if err==nil && n%2 !=0 {
			k++
		}
	}
	fmt.Println(k)
}

package main

import "fmt"

func vowel_l(r rune) bool {
    if r == 'a' || r == 'e' || r == 'i' || r == 'u' {
        return true
    }
    return false
}

func odd(r rune) bool {
    if r == '1' || r == '3' || r == '5' || r == '7' || r == '9' {
        return true
    }
    return false
}

func main() {
    var s string
    fmt.Scan(&s)
    var cnt int
    for _, r := range s {
        if vowel_l(r) || odd(r) {
            cnt++
        }
    }
    fmt.Print(cnt)
}

package main

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

func main() {
	sc := NewScanner()
	S := sc.NextLine()
	count := 0
	for _, v := range S {
		switch v {
		case 'a', 'i', 'u', 'e', 'o', '0', '2', '4', '6', '8':
			count++

		}
	}
	fmt.Println(count)

}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *Scanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 0)
			result = append(result, int(v))
			start = s.p + 1
		}
	}

	return result
}
func (s *Scanner) NextInt64Array() []int64 {
	s.pre()
	start := s.p
	result := []int64{}
	for ; s.p < len(s.buf)+1; s.p++ {
		if s.p == len(s.buf) || s.buf[s.p] == ' ' {
			v, _ := strconv.ParseInt(string(s.buf[start:s.p]), 10, 64)
			result = append(result, v)
			start = s.p + 1
		}
	}
	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanln(&s)
	var ans int
	for i := 0; i < len(s); i++ {
		if s[i] >= '0' && s[i] <= '9' {
			if (s[i]-'0')%2 == 0 {
				ans++
			}
		} else {
			if strings.IndexByte("aeiou", s[i]) != -1 {
				ans++
			}
		}
	}
	fmt.Println(ans)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanln(&s)
	var ans int
	for i := 0; i < len(s); i++ {
		if s[i] >= '0' && s[i] <= '9' {
			if (s[i]-'0')%2 == 0 {
				ans++
			}
		} else {
			if strings.IndexByte("aeios", s[i]) != -1 {
				ans++
			}
		}
	}
	fmt.Println(ans)
}


package main

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

func main() {
	var x, y float64
	stdin := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdin, "%f %f\n", &x, &y)
	x, y = y*math.Log(x), x*math.Log(y)
	if x == y {
		fmt.Println("=")
	} else if x < y {
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

package main

import (
	"fmt"
)

func main() {
	var x, y int
	fmt.Scanf("%d %d\n", &x, &y)
	if x == y {
		fmt.Println("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Println("<")
			return
		}
		if y == 2 {
			if x == 4 {
				fmt.Println("=")
				return
			}
			if x == 3 {
				fmt.Println(">")
				return
			}
			if x > 4 {
				fmt.Println("<")
				return
			}
		}
		if y == 1 {
			fmt.Println(">")
		}
	}
	if x < y {
		if x >= 3 {
			fmt.Println(">")
			return
		}
		if x == 2 {
			if y == 4 {
				fmt.Println("=")
				return
			}
			if y == 3 {
				fmt.Println("<")
				return
			}
			if y > 4 {
				fmt.Println(">")
				return
			}
		}
		if x == 1 {
			fmt.Println("<")
		}
	}
}

package main

import (
	"math"
	"fmt"
)

func main () {
	var a float64
	var b float64

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

	c := b * math.Log(a)
	d := a * math.Log(b)

	if c < d {
		fmt.Println("<")
	} else if c > d {
		fmt.Println(">")
	} else {
		fmt.Println("=")
	}

}

package main

/*
	The idea to solve this problem is by using logarithm to solve
	the equation. We apply logarithm to both sides of equation then
	compare them. For details take a look at this reference:
	http://www.montereyinstitute.org/courses/DevelopmentalMath/COURSE_TEXT2_RESOURCE/U18_L4_T1_text_final.html
*/

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

func main() {
	var x, y float64
	stdin := bufio.NewReader(os.Stdin)
	fmt.Fscanf(stdin, "%f %f\n", &x, &y)
	x, y = y*math.Log(x), x*math.Log(y)
	if x == y {
		fmt.Println("=")
	} else if x < y {
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

package main

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

func solve() {
	x := float64(readInt())
	y := float64(readInt())
	t0 := y * math.Log(x)
	t1 := x * math.Log(y)
	if t0 == t1 {
		fmt.Println("=")
	} else if t1 < t0 {
		fmt.Println(">")
	} else {
		fmt.Println("<")
	}
}

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

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

var scanner *bufio.Scanner

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

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

func main() {
	var a, b float64
	fmt.Scan(&a, &b)

	var t float64 = math.Log2(a) / math.Log2(b) * b
	if a == b {
		fmt.Println("=")
	} else if t == a {
		fmt.Println("=")
	} else if t > a {
		fmt.Println(">")
	} else {
		fmt.Println("<")
	}
}

package main
import (
	"fmt"
	"math"
	"os"
)

func main(){
	var a, b float64
	fmt.Scan(&a)
	fmt.Scan(&b)
	if a == b {
		fmt.Println("=")
		os.Exit(0)
	}
	if a > b {
		var x, y float64
		x = b
		y = a
		x = (x * math.Log(a)) / math.Log(b)
		if x == y {
			fmt.Println("=")
		} else if x > y {
			fmt.Println(">")
		} else{
			fmt.Println("<")
		}
	} else {
		var x, y float64
		x = b
		y = a
		y = (y * math.Log(b)) / math.Log(a)
		if x == y {
			fmt.Println("=")
		} else if x > y {
			fmt.Println(">")
		} else{
			fmt.Println("<")
		}
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var x, y float64
	fmt.Fscan(reader, &x, &y)
	x, y = y*math.Log(x), x*math.Log(y)
	// fmt.Println(x, y)
	if x == y {
		fmt.Println("=")
		return
	} else if x > y {
		fmt.Println(">")
	} else if x < y {
		fmt.Println("<")
	}
}

package main

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

func main() {
	var x1,y1 float64
	fmt.Scanf("%f %f\n", &x1, &y1)
	x := (math.Log(x1)*y1)
	y := (math.Log(y1)*x1)
	if x == y {
		fmt.Println("=")
	} else if x > y {
		fmt.Println(">")
	} else {
		fmt.Println("<")
	}
}

func readOneInt64(r *bufio.Reader) (n int64) {
	bytes, _ := r.ReadBytes('\n')
	n, _ = strconv.ParseInt(string(bytes[:len(bytes)-2]), 10, 64)
	return
}

func readInt64Slice(r *bufio.Reader, n int) (slice []int64) {
	var bytes []byte
	slice = make([]int64, n)
	n--
	for i := 0; i < n; i++ {
		bytes, _ = r.ReadBytes(' ')
		slice[i], _ = strconv.ParseInt(string(bytes[:len(bytes)-1]), 10, 64)
	}
	slice[n] = readOneInt64(r)
	return
}

func readOneString(r *bufio.Reader) string {
	bytes, _ := r.ReadBytes('\n')
	return string(bytes[:len(bytes)-2])
}

func abs(i int) int {
	if i < 0 {
		return i * -1
	}
	return i
}

package main

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

var sc = bufio.NewScanner(os.Stdin)
const EPS = 0.00000001

func nextLine() string{
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func main(){
	sc.Split(bufio.ScanWords)

	x := float64(nextInt())
	y := float64(nextInt())

	res_xy := y * math.Log2(x)
	res_yx := x * math.Log2(y)

	//fmt.Printf("%v, %v, %v", res_xy, res_yx, res_xy-res_yx)

	if math.Abs(res_xy - res_yx) < EPS{
		fmt.Println("=")
	}else if res_xy < res_yx {
		fmt.Println("<")
	}else {
		fmt.Println(">")
	}
}

package main
import (
	"fmt"
	"math"
	"os"
)

func main(){
	var a, b float64
	fmt.Scan(&a)
	fmt.Scan(&b)
	if a == b {
		fmt.Println("=")
		os.Exit(0)
	}
	if a > b {
		var x, y float64
		x = b
		y = a
		x = (x * math.Log(a)) / math.Log(b)
		if x > y {
			fmt.Println(">")
		} else{
			fmt.Println("<")
		}
	} else {
		var x, y float64
		x = b
		y = a
		y = (y * math.Log(b)) / math.Log(a)
		if x > y {
			fmt.Println(">")
		} else{
			fmt.Println("<")
		}
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var x, y int
	fmt.Fscan(reader, &x, &y)
	xLog, yLog := int(math.Log(float64(x))), int(math.Log(float64(x)))
	if y*xLog == yLog*x {
		fmt.Println("=")
		return
	} else if y*xLog > yLog*x {
		fmt.Println(">")
	} else if y*xLog < yLog*x {
		fmt.Println("<")
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var x, y int
	fmt.Fscan(reader, &x, &y)

	if x == y {
		fmt.Println("=")
		return
	} else if x > y {
		fmt.Println("<")
	} else if x < y {
		fmt.Println(">")
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var x, y int
	fmt.Fscan(reader, &x, &y)
	xLog, yLog := int(math.Log(float64(x))), int(math.Log(float64(y)))
	// fmt.Println(xLog, yLog)
	if y*xLog == yLog*x {
		fmt.Println("=")
		return
	} else if y*xLog > yLog*x {
		fmt.Println(">")
	} else if y*xLog < yLog*x {
		fmt.Println("<")
	}
}

package main

import (
	"fmt"
)

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

	if x == y {
		fmt.Print("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Print("<")
			return
		}
		fmt.Print(">")
		return
	}
	if x < y {
		if x >= 3 {
			fmt.Print(">")
			return
		}
		fmt.Print("<")
		return
	}
}

package main

import (
	"fmt"
)

func main() {
	var x, y int
	fmt.Scanf("%d %d\n", &x, &y)
	if x == y {
		fmt.Println("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Println("<")
			return
		}
		fmt.Println(">")
		return
	}
	if x < y {
		if x >= 3 {
			fmt.Println(">")
			return
		}
		fmt.Println("<")
		return
	}
}

package main

import (
	"fmt"
)

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

	if x == y {
		fmt.Print("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Print("<")
			return
		}
		fmt.Print(">")
		return
	}
	if x < y {
		if x >= 3 {
			fmt.Print(">")
			return
		}
		fmt.Print("<")
		return
	}
}

package main

import (
	"fmt"
)

func main() {
	var x, y int
	fmt.Scanf("%d %d\n", &x, &y)
	if x == y {
		fmt.Println("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Println("<")
			return
		}
		if y == 2 {
			if x == 4 {
				fmt.Println("=")
				return
			}
			if x == 3 {
				fmt.Println(">")
				return
			}
			if x > 4 {
				fmt.Println("<")
				return
			}
		}
	}
	if x < y {
		if x >= 3 {
			fmt.Println(">")
			return
		}
		if x == 2 {
			if y == 4 {
				fmt.Println("=")
				return
			}
			if y == 3 {
				fmt.Println("<")
				return
			}
			if y > 4 {
				fmt.Println(">")
				return
			}
		}
	}
}

package main

import (
	"fmt"
)

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

	if x == y {
		fmt.Println("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Println("<")
			return
		}
		fmt.Println(">")
	}
	if x < y {
		if x >= 3 {
			fmt.Println(">")
			return
		}
		fmt.Println("<")
	}
}

package main

import (
	"fmt"
)

func main() {
	var x, y int
	fmt.Scanf("%d %d\n", &x, &y)
	if x == y {
		fmt.Println("=")
		return
	}
	if x > y {
		if y >= 3 {
			fmt.Println("<")
			return
		}
		if y == 2 {
			if x == 4 {
				fmt.Println("=")
				return
			}
			if x == 3 {
				fmt.Println(">")
				return
			}
			if x > 4 {
				fmt.Println("<")
				return
			}
		}
		if y == 1 {
			fmt.Println(">")
		}
	}
	if x < y {
		if x >= 3 {
			fmt.Println(">")
			return
		}
		if x == 2 {
			if y == 4 {
				fmt.Println("=")
				return
			}
			if y == 3 {
				fmt.Println("<")
				return
			}
			if y > 4 {
				fmt.Println(">")
				return
			}
		}
		if y == 1 {
			fmt.Println("<")
		}
	}
}

package main

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

func solve() {
	x := readInt()
	y := readInt()
	if y == x {
		fmt.Println("=")
	} else if x == 1 {
		fmt.Println("<")
	} else if y == 1 {
		fmt.Println(">")
	} else if x == 2 {
		fmt.Println("<")
	} else if y == 2 {
		fmt.Println(">")
	} else if x > y {
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

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

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

var scanner *bufio.Scanner

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

// IO

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

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

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

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

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

package main

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

func solve() {
	x := readInt()
	y := readInt()
	if y == x {
		fmt.Println("=")
	} else if x == 1 {
		fmt.Println("<")
	} else if y == 1 {
		fmt.Println(">")
	} else if x == 2 {
		fmt.Println("<")
	} else if y == 2 {
		fmt.Println(">")
	} else if int64(x)*int64(x) > int64(y)*int64(y) {
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

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

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

var scanner *bufio.Scanner

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

// IO

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

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

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

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

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

package main

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

func solve() {
	x := readInt()
	y := readInt()
	if y == x {
		fmt.Println("=")
		return
	}
	if y%x == 0 && y/x == x {
		fmt.Println("=")
		return
	}
	if x%y == 0 && x/y == y {
		fmt.Println("=")
		return
	}
	if x == 1 {
		fmt.Println("<")
	} else if y == 1 {
		fmt.Println(">")
	} else if x == 2 {
		fmt.Println("<")
	} else if y == 2 {
		fmt.Println(">")
	} else if int64(x)*int64(x) > int64(y)*int64(y) {
		//		2 * 2 * 2 * 2
		//
		//		4 * 4
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

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

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

var scanner *bufio.Scanner

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

// IO

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

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

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

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

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

package main

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

func solve() {
	x := readInt()
	y := readInt()
	if y == x {
		fmt.Println("=")
	} else if y < x {
		fmt.Println("<")
	} else {
		fmt.Println(">")
	}
}

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

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

var scanner *bufio.Scanner

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

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

func main() {
	var a, b, x int
	fmt.Scan(&a, &b, &x)
	x++
	if a > b {
		for ; x > 2; {
				fmt.Printf("01")
				x -= 2
				a--
				b--
				continue
		}
		if x == 2 {
			for ; a > 0 || b > 0 ; {
				if a != 0 {
					fmt.Printf("0")
					a--
					continue
				}
				if b != 0 {
					fmt.Printf("1")
					b--
					continue
				}
			}
		} else {
			for ; a > 0 || b > 0 ; {
				if b != 0 {
					fmt.Printf("1")
					b--
					continue
				}
				if a != 0 {
					fmt.Printf("0")
					a--
					continue
				}
			}
		}
	} else {
		for ; x > 2; {
			fmt.Printf("10")
			x -= 2
			a--
			b--
			continue
		}
		if x == 2 {
			for ; a > 0 || b > 0; {
				if b != 0 {
					fmt.Printf("1")
					b--
					continue
				}
				if a != 0 {
					fmt.Printf("0")
					a--
					continue
				}
			}
		} else {
			for ; a > 0 || b > 0; {
				if a != 0 {
					fmt.Printf("0")
					a--
					continue
				}
				if b != 0 {
					fmt.Printf("1")
					b--
					continue
				}
			}
		}
	}
}

package main

import (
	. "fmt"
	. "strings"
)

// github.com/EndlessCheng/codeforces-go
func main() {
	var a, b, x int
	Scan(&a, &b, &x)
	k := (x + 1) / 2
	a -= k
	b -= k
	R := Repeat
	s := R("01", k)
	if x&1 > 0 {
		s = R("0", a) + s + R("1", b)
	} else if a > 0 {
		s += R("1", b) + R("0", a)
	} else {
		s = R("1", b) + s
	}
	Print(s)
}

package main

import (
    "fmt"
)

func main() {
    // initialize
    var a, b, x int
    var a_byte, b_byte byte = '0', '1'

    // read input
    fmt.Scan(&a, &b, &x)

    if a < b {
        a, b = b, a
        a_byte, b_byte = b_byte, a_byte
    }

    // print answer
    fmt.Printf("%c", a_byte)
    a -= 1

    for x > 1 {
        fmt.Printf("%c", b_byte)
        b -= 1

        a, b = b, a
        a_byte, b_byte = b_byte, a_byte

        x -= 1
    }

    // finish it
    for a > 0 {
        fmt.Printf("%c", a_byte)
        a -= 1
    }
    for (b > 0) {
        fmt.Printf("%c", b_byte)
        b -= 1
    }

    fmt.Println()
}

package main

import (
	. "fmt"
	. "strings"
)

// github.com/EndlessCheng/codeforces-go
func main() {
	var a, b, x int
	Scan(&a, &b, &x)
	k := (x + 1) / 2
	a -= k
	b -= k
	R := Repeat
	s := R("01", k)
	if x&1 > 0 {
		s = R("0", a) + s + R("1", b)
	} else {
		s += R("1", b) + R("0", a)
	}
	Print(s)
}

package main

import "fmt"

func main() {
	var a, b, x int
	fmt.Scan(&a, &b, &x)
	if a > b {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("10")
				x -= 2
				a--
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("1")
				a--
				continue
			}
			if b != 0 {
				fmt.Printf("0")
				b--
				continue
			}
		}
	} else {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("01")
				x -= 2
				a--
				b--
				continue
			}
			if b != 0 {
				fmt.Printf("0")
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("1")
				a--
				continue
			}

		}
	}
}

package main

import "fmt"

func main() {
	var a, b, x int
	fmt.Scan(&a, &b, &x)
	if a > b {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("01")
				x -= 2
				a--
				b--
				continue
			}
			if b != 0 {
				fmt.Printf("1")
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("0")
				a--
				continue
			}
		}
	} else {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("10")
				x -= 2
				a--
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("0")
				a--
				continue
			}
			if b != 0 {
				fmt.Printf("1")
				b--
				continue
			}
		}
	}
}

package main

import "fmt"

func main() {
	var a, b, x int
	fmt.Scan(&a, &b, &x)
	if a > b {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("01")
				x -= 2
				a--
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("0")
				a--
				continue
			}
			if b != 0 {
				fmt.Printf("1")
				b--
				continue
			}
		}
	} else {
		for ; a > 0 || b > 0; {
			if x > 1 {
				fmt.Printf("10")
				x -= 2
				a--
				b--
				continue
			}
			if b != 0 {
				fmt.Printf("1")
				b--
				continue
			}
			if a != 0 {
				fmt.Printf("0")
				a--
				continue
			}

		}
	}
}


package main

import (
	. "fmt"
)

// github.com/EndlessCheng/codeforces-go
func main() {
	var s []byte
	Scan(&s)
	n, ans := len(s), 99
	if n < 2 {
		Print(-1)
		return
	}
	for i := range s {
		for j := range s {
			if i == j {
				continue
			}
			t := make([]byte, n)
			copy(t, s)
			c := 0
			for k := i; k < n-1; k++ {
				t[k], t[k+1] = t[k+1], t[k]
				c++
			}
			k := j
			if j > i {
				k--
			}
			for ; k < n-2; k++ {
				t[k], t[k+1] = t[k+1], t[k]
				c++
			}
			for k = 0; t[k] == '0'; k++ {
			}
			for ; k > 0; k-- {
				t[k], t[k-1] = t[k-1], t[k]
				c++
			}
			if c < ans && (t[n-2]&15*10+t[n-1]&15)%25 == 0 {
				ans = c
			}
		}
	}
	if ans == 99 {
		ans = -1
	}
	Print(ans)
}

package main

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

// github.com/EndlessCheng/codeforces-go
func CF988E(in io.Reader, out io.Writer) {
	var s []byte
	Fscan(in, &s)
	n, ans := len(s), 99
	if n < 2 {
		Fprint(out, -1)
		return
	}
	for i := range s {
		for j := range s {
			if i == j {
				continue
			}
			t := make([]byte, n)
			copy(t, s)
			c := 0
			for k := i; k < n-1; k++ {
				t[k], t[k+1] = t[k+1], t[k]
				c++
			}
			k := j
			if j > i {
				k--
			}
			for ; k < n-2; k++ {
				t[k], t[k+1] = t[k+1], t[k]
				c++
			}
			for k = 0; t[k] == '0'; k++ {
			}
			for ; k > 0; k-- {
				t[k], t[k-1] = t[k-1], t[k]
				c++
			}
			if v, _ := strconv.Atoi(string(t[n-2:])); c < ans && v%25 == 0 {
				ans = c
			}
		}
	}
	if ans == 99 {
		ans = -1
	}
	Fprint(out, ans)
}

func main() { CF988E(os.Stdin, os.Stdout) }

package main

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

const (
	INF = 12345
)

func Init() {
}

func Solve(io *FastIO) {
	S := io.NextLine()

	A := []rune(S)
	N := len(A)

	best := INF
	for i := 0; i < N; i++ {
		for j := i + 1; j < N; j++ {
			if (A[i] == '0' && A[j] == '0') || (A[i] == '2' && A[j] == '5') || (A[i] == '5' && A[j] == '0') || (A[i] == '7' && A[j] == '5') {
				best = Min(best, simulate(A, i, j))
			}
			if (A[i] == '5' && A[j] == '2') || (A[i] == '0' && A[j] == '5') || (A[i] == '5' && A[j] == '7') {
				best = Min(best, simulate(A, j, i))
			}
		}
	}
	if best < INF {
		io.Println(best)
	} else {
		io.Println(-1)
	}
}

func simulate(A []rune, front, back int) int {
	N := len(A)

	X := make([]rune, N)
	copy(X, A)

	if back < front {
		front--
	}

	a := swapTo(X, back, N - 1)
	b := swapTo(X, front, N - 2)
	c := fix(X)

	// fmt.Printf("A = %v, front = %d, back = %d, a = %d, b = %d, c = %d\n", A, front, back, a, b, c)

	return a + b + c
}

func swapTo(A []rune, i, j int) int {
	cnt := 0
	for i + 1 <= j {
		A[i], A[i + 1] = A[i + 1], A[i]
		cnt++
		i++
	}
	return cnt
}

func fix(A []rune) int {
	if A[0] != '0' {
		return 0
	}
	for i := 1; i < len(A) - 2; i++ {
		if A[i] != '0' {
			return i
		}
	}
	return INF
}

func Min(args ...int) int {
	min := args[0]
	for i := 1; i < len(args); i++ {
		if args[i] < min {
			min = args[i]
		}
	}
	return min
}

type FastIO struct {
	reader *bufio.Reader
	writer *bufio.Writer
}

func (io *FastIO) NextChar() byte {
	c, _ := io.reader.ReadByte()
	return c
}

func (io *FastIO) NextInt() int {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := 1
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := 0
	for !IsSpaceChar(c) {
		res = (res * 10) + int(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextLong() int64 {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := int64(1)
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := int64(0)
	for !IsSpaceChar(c) {
		res = (res * 10) + int64(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextIntArray(size int) []int {
	return io.NextIntArrayOffset(size, 0)
}

func (io *FastIO) NextIntArrayOffset(size, offset int) []int {
	arr := make([]int, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextInt()
	}
	return arr
}

func (io *FastIO) NextLongArray(size int) []int64 {
	return io.NextLongArrayOffset(size, 0)
}

func (io *FastIO) NextLongArrayOffset(size, offset int) []int64 {
	arr := make([]int64, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextLong()
	}
	return arr
}

func (io *FastIO) NextString() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsSpaceChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) NextLine() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsLineBreakChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) Println(args ...interface{}) {
	io.writer.WriteString(fmt.Sprintln(args...))
}

func (io *FastIO) Printf(format string, args ...interface{}) {
	io.writer.WriteString(fmt.Sprintf(format, args...))
}

func (io *FastIO) FlushOutput() {
	io.writer.Flush()
}

func IsSpaceChar(c byte) bool {
	switch c {
	case 0, '\t', '\n', '\r', ' ':
		return true
	default:
		return false
	}
}

func IsLineBreakChar(c byte) bool {
	switch c {
		case 0, '\n', '\r':
			return true
		default:
			return false
	}
}

func main() {
	io := FastIO{reader: bufio.NewReader(os.Stdin), writer: bufio.NewWriter(os.Stdout)}
	Init()
	Solve(&io)
	io.FlushOutput()
}

package main

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

const (
	INF = 12345
)

func Init() {
}

func Solve(io *FastIO) {
	S := io.NextLine()

	A := []rune(S)
	N := len(A)

	best := INF
	for i := 0; i < N; i++ {
		for j := i + 1; j < N; j++ {
			if (A[i] == '0' && A[j] == '0') || (A[i] == '2' && A[j] == '5') || (A[i] == '5' && A[j] == '0') || (A[i] == '7' && A[j] == '5') {
				best = Min(best, simulate(A, i, j))
			}
			if (A[i] == '5' && A[j] == '2') || (A[i] == '0' && A[j] == '5') || (A[i] == '5' && A[j] == '7') {
				best = Min(best, simulate(A, j, i))
			}
		}
	}
	if best < INF {
		io.Println(best)
	} else {
		io.Println(-1)
	}
}

func simulate(A []rune, front, back int) int {
	N := len(A)

	X := make([]rune, N)
	copy(X, A)

	if back < front {
		front--
	}

	a := swapTo(X, back, N - 1)
	b := swapTo(X, front, N - 2)
	c := fix(X)

	return a + b + c
}

func swapTo(A []rune, i, j int) int {
	cnt := 0
	for i + 1 <= j {
		A[i], A[i + 1] = A[i + 1], A[i]
		cnt++
		i++
	}
	return cnt
}

func fix(A []rune) int {
	if A[0] != '0' {
		return 0
	}
	for i := 1; i < len(A) - 2; i++ {
		if A[i] != '0' {
			return i
		}
	}
	return INF
}

func Min(args ...int) int {
	min := args[0]
	for i := 1; i < len(args); i++ {
		if args[i] < min {
			min = args[i]
		}
	}
	return min
}

type FastIO struct {
	reader *bufio.Reader
	writer *bufio.Writer
}

func (io *FastIO) NextChar() byte {
	c, _ := io.reader.ReadByte()
	return c
}

func (io *FastIO) NextInt() int {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := 1
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := 0
	for !IsSpaceChar(c) {
		res = (res * 10) + int(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextLong() int64 {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := int64(1)
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := int64(0)
	for !IsSpaceChar(c) {
		res = (res * 10) + int64(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextIntArray(size int) []int {
	return io.NextIntArrayOffset(size, 0)
}

func (io *FastIO) NextIntArrayOffset(size, offset int) []int {
	arr := make([]int, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextInt()
	}
	return arr
}

func (io *FastIO) NextLongArray(size int) []int64 {
	return io.NextLongArrayOffset(size, 0)
}

func (io *FastIO) NextLongArrayOffset(size, offset int) []int64 {
	arr := make([]int64, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextLong()
	}
	return arr
}

func (io *FastIO) NextString() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsSpaceChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) NextLine() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsLineBreakChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) Println(args ...interface{}) {
	io.writer.WriteString(fmt.Sprintln(args...))
}

func (io *FastIO) Printf(format string, args ...interface{}) {
	io.writer.WriteString(fmt.Sprintf(format, args...))
}

func (io *FastIO) FlushOutput() {
	io.writer.Flush()
}

func IsSpaceChar(c byte) bool {
	switch c {
	case 0, '\t', '\n', '\r', ' ':
		return true
	default:
		return false
	}
}

func IsLineBreakChar(c byte) bool {
	switch c {
		case 0, '\n', '\r':
			return true
		default:
			return false
	}
}

func main() {
	io := FastIO{reader: bufio.NewReader(os.Stdin), writer: bufio.NewWriter(os.Stdout)}
	Init()
	Solve(&io)
	io.FlushOutput()
}

package main

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

const (
	INF = 12345
)

func Init() {
}

func Solve(io *FastIO) {
	S := io.NextLine()

	A := []rune(S)
	N := len(A)

	best := INF
	for i := 0; i < N; i++ {
		for j := i + 1; j < N; j++ {
			if (A[i] == '0' && A[j] == '0') || (A[i] == '2' && A[j] == '5') || (A[i] == '5' && A[j] == '0') || (A[i] == '7' && A[j] == '5') {
				best = Min(best, simulate(A, i, j))
			}
			if (A[i] == '5' && A[j] == '2') || (A[i] == '0' && A[j] == '5') || (A[i] == '5' && A[j] == '7') {
				best = Min(best, simulate(A, i, j))
			}
		}
	}
	if best < INF {
		io.Println(best)
	} else {
		io.Println(-1)
	}
}

func simulate(A []rune, front, back int) int {
	N := len(A)

	X := make([]rune, N)
	copy(A, X)

	if back < front {
		front--
	}

	a := swapTo(X, back, N - 1)
	b := swapTo(X, front, N - 2)
	c := fix(X)

	return a + b + c
}

func swapTo(A []rune, i, j int) int {
	cnt := 0
	for i + 1 <= j {
		A[i], A[i + 1] = A[i + 1], A[i]
		cnt++
		i++
	}
	return cnt
}

func fix(A []rune) int {
	if A[0] != '0' {
		return 0
	}
	for i := 1; i < len(A) - 2; i++ {
		if A[i] != '0' {
			return i
		}
	}
	return INF
}

func Min(args ...int) int {
	min := args[0]
	for i := 1; i < len(args); i++ {
		if args[i] < min {
			min = args[i]
		}
	}
	return min
}

type FastIO struct {
	reader *bufio.Reader
	writer *bufio.Writer
}

func (io *FastIO) NextChar() byte {
	c, _ := io.reader.ReadByte()
	return c
}

func (io *FastIO) NextInt() int {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := 1
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := 0
	for !IsSpaceChar(c) {
		res = (res * 10) + int(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextLong() int64 {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := int64(1)
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := int64(0)
	for !IsSpaceChar(c) {
		res = (res * 10) + int64(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextIntArray(size int) []int {
	return io.NextIntArrayOffset(size, 0)
}

func (io *FastIO) NextIntArrayOffset(size, offset int) []int {
	arr := make([]int, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextInt()
	}
	return arr
}

func (io *FastIO) NextLongArray(size int) []int64 {
	return io.NextLongArrayOffset(size, 0)
}

func (io *FastIO) NextLongArrayOffset(size, offset int) []int64 {
	arr := make([]int64, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextLong()
	}
	return arr
}

func (io *FastIO) NextString() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsSpaceChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) NextLine() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsLineBreakChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) Println(args ...interface{}) {
	io.writer.WriteString(fmt.Sprintln(args...))
}

func (io *FastIO) Printf(format string, args ...interface{}) {
	io.writer.WriteString(fmt.Sprintf(format, args...))
}

func (io *FastIO) FlushOutput() {
	io.writer.Flush()
}

func IsSpaceChar(c byte) bool {
	switch c {
	case 0, '\t', '\n', '\r', ' ':
		return true
	default:
		return false
	}
}

func IsLineBreakChar(c byte) bool {
	switch c {
		case 0, '\n', '\r':
			return true
		default:
			return false
	}
}

func main() {
	io := FastIO{reader: bufio.NewReader(os.Stdin), writer: bufio.NewWriter(os.Stdout)}
	Init()
	Solve(&io)
	io.FlushOutput()
}

package main

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

const (
	INF = 12345
)

func Init() {
}

func Solve(io *FastIO) {
	S := io.NextLine()

	A := []rune(S)
	N := len(A)

	best := INF
	for i := 0; i < N; i++ {
		for j := i + 1; j < N; j++ {
			if (A[i] == '0' && A[j] == '0') || (A[i] == '2' && A[j] == '5') || (A[i] == '5' && A[j] == '0') || (A[i] == '7' && A[j] == '5') {
				best = Min(best, simulate(A, i, j))
			}
			if (A[i] == '5' && A[j] == '2') || (A[i] == '0' && A[j] == '5') || (A[i] == '5' && A[j] == '7') {
				best = Min(best, simulate(A, i, j))
			}
		}
	}
	if best < INF {
		io.Println(best)
	} else {
		io.Println(-1)
	}
}

func simulate(A []rune, front, back int) int {
	N := len(A)

	X := make([]rune, N)
	copy(X, A)

	if back < front {
		front--
	}

	a := swapTo(X, back, N - 1)
	b := swapTo(X, front, N - 2)
	c := fix(X)

	return a + b + c
}

func swapTo(A []rune, i, j int) int {
	cnt := 0
	for i + 1 <= j {
		A[i], A[i + 1] = A[i + 1], A[i]
		cnt++
		i++
	}
	return cnt
}

func fix(A []rune) int {
	if A[0] != '0' {
		return 0
	}
	for i := 1; i < len(A) - 2; i++ {
		if A[i] != '0' {
			return i
		}
	}
	return INF
}

func Min(args ...int) int {
	min := args[0]
	for i := 1; i < len(args); i++ {
		if args[i] < min {
			min = args[i]
		}
	}
	return min
}

type FastIO struct {
	reader *bufio.Reader
	writer *bufio.Writer
}

func (io *FastIO) NextChar() byte {
	c, _ := io.reader.ReadByte()
	return c
}

func (io *FastIO) NextInt() int {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := 1
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := 0
	for !IsSpaceChar(c) {
		res = (res * 10) + int(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextLong() int64 {
	c := io.NextChar()
	for IsSpaceChar(c) {
		c = io.NextChar()
	}
	sgn := int64(1)
	if c == '-' {
		sgn = -1
		c = io.NextChar()
	}
	res := int64(0)
	for !IsSpaceChar(c) {
		res = (res * 10) + int64(c - '0')
		c = io.NextChar()
	}
	return sgn * res
}

func (io *FastIO) NextIntArray(size int) []int {
	return io.NextIntArrayOffset(size, 0)
}

func (io *FastIO) NextIntArrayOffset(size, offset int) []int {
	arr := make([]int, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextInt()
	}
	return arr
}

func (io *FastIO) NextLongArray(size int) []int64 {
	return io.NextLongArrayOffset(size, 0)
}

func (io *FastIO) NextLongArrayOffset(size, offset int) []int64 {
	arr := make([]int64, size + offset)
	for i := 0; i < size; i++ {
		arr[i + offset] = io.NextLong()
	}
	return arr
}

func (io *FastIO) NextString() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsSpaceChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) NextLine() string {
	c := io.NextChar()
	for (IsSpaceChar(c)) {
		c = io.NextChar()
	}
	var sb bytes.Buffer
	for !IsLineBreakChar(c) {
		sb.WriteByte(c)
		c = io.NextChar()
	}
	return sb.String()
}

func (io *FastIO) Println(args ...interface{}) {
	io.writer.WriteString(fmt.Sprintln(args...))
}

func (io *FastIO) Printf(format string, args ...interface{}) {
	io.writer.WriteString(fmt.Sprintf(format, args...))
}

func (io *FastIO) FlushOutput() {
	io.writer.Flush()
}

func IsSpaceChar(c byte) bool {
	switch c {
	case 0, '\t', '\n', '\r', ' ':
		return true
	default:
		return false
	}
}

func IsLineBreakChar(c byte) bool {
	switch c {
		case 0, '\n', '\r':
			return true
		default:
			return false
	}
}

func main() {
	io := FastIO{reader: bufio.NewReader(os.Stdin), writer: bufio.NewWriter(os.Stdout)}
	Init()
	Solve(&io)
	io.FlushOutput()
}


package main

import 	"fmt"

func main() {
	var n int
	fmt.Scan(&n)
	a := 0
	if n%2 == 0 {
		a = int((n - 1) / 4)
	}
	fmt.Println(a)
}

// stick.go
package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	c := 0
	if n%2 == 0 {
		c = int((n - 1) / 4)
	}
	fmt.Println(c)
}

package main

import "fmt"
import "math"

var n float64

func main() {
        fmt.Scanln(&n)
        if int(n)%2 != 0 {
                fmt.Println(0)
                return
        }
        ans := int(math.Ceil(((n / 2) / 2)))
        ans -= 1
        fmt.Println(ans)
}

package main

import (
	"fmt"
)

func main() {
	var n, o int
	fmt.Scanln(&n)
	if n%2 != 0 {
		o = 0
	} else {
		if n%4 == 0 {
			o = n/4 - 1
		} else {
			o = n / 4
		}
	}
	fmt.Println(o)
}

package main

import "fmt"

func solve(n int64) int64 {
    if n%2 != 0 {
        return 0
    }
    if n < 6 {
        return 0
    }
    if n == 6 {
        return 1
    }
    if n%4 == 0 {
        return n/4 - 1
    }
    return n/4
}

func main() {
    var n int64
    fmt.Scanf("%d", &n)
    fmt.Println(solve(n))
}

package main

import "fmt"

func solve(n int64) int64 {
    if n < 6 {
        return 0
    }
    if n == 6 {
        return 1
    }
    if n%4 == 0 {
        return n/4 - 1
    }
    return n/4
}

func main() {
    var n int64
    fmt.Scanf("%d", &n)
    fmt.Println(solve(n))
}

package main

import "fmt"

func solve(n int64) int64 {
    if n < 6 {
        return 0
    }
    if n == 6 {
        return 1
    }
    if n%4 == 0 {
        return n/4 - 1
    }
    return n/4 - 1
}

func main() {
    var n int64
    fmt.Scanf("%d", &n)
    fmt.Println(solve(n))
}

package main

import "fmt"
import "math"

var n float64

func main() {
        fmt.Scanln(&n)
        if int(n)%2 == 0 {
                fmt.Println(0)
                return
        }
        ans := int(math.Ceil(((n / 2) / 2)))
        ans -= 1
        fmt.Println(ans)
}

package main

import (
	"fmt"
)

func main() {
	var n, o int
	fmt.Scanln(&n)
	if n%4 == 0 {
		o = n/4 - 1
	} else {
		o = n / 4
	}
	fmt.Println(o)
}


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 := nextInt64()
	var cnt, num, minus, length, base int64

	num = n
	base = 1
	length = 1

	for num >= 10 {
		minus += 9 * base
		cnt += 9 * base * length
		num /= 10
		base *= 10
		length++
	}

	cnt += (n - minus) * length

	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"
    "bufio"
    "os"
    "strconv"
)

func main() {
    //io
    scanner := bufio.NewReader(os.Stdin)
    writer := bufio.NewWriter(os.Stdout)
    //---
    var n, d, c, ans int64

    fmt.Fscan(scanner, &n)
    for c = 1; c <= n; c *= 10 {
        d++
    }
    //writer.WriteString(strconv.Itoa(c))
    c /= 10
    ans = (n - c + 1) * d;
    for d > 0 {
        ans += (c - c / 10) * (d-1);
        d--
        c /= 10
    }

    writer.WriteString(strconv.FormatInt(ans, 10))
    writer.Flush()
}

package main

import (
	"fmt"
)

func main() {
	var input uint64
	fmt.Scanf("%d", &input)
	digits := countDigits(input)
	rem := (input - pow10(digits-1) + 1) * digits
	res := uint64(0)
	for i := uint64(1); i < digits; i++ {
		res += (pow10(i) - pow10(i-1)) * i
	}
	fmt.Println(res + rem)
}

func pow10(n uint64) uint64 {
	if n == 0 {
		return 1
	} else {
		res := uint64(1)
		for ; n > 0; n-- {
			res *= 10
		}
		return res
	}
}

func countDigits(ub uint64) uint64 {
	count := uint64(0)
	for ; ub > 0; ub /= 10 {
		count++
	}
	return count
}

package main

import "fmt"

func main() {

    var n int64
    fmt.Scanf("%v\n", &n)
    var count int64 = 0;

    var i,x int64 = 9,1;

    for n > 0 {
        if n < i {
            count += n*x;
        } else {
            count += i*x;
        }
        n -= i
        i *= 10
        x++
    }
    fmt.Printf("%v\n",count)
}

package main

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

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

func count(n int64) int64 {
	if n < 10 {
		return int64(n)
	}
	var l, p int64 = 1, 1
	for p * 10 <= n {
		l++
		p *= 10
	}

	return l * ((n / p - 1) * p + (n % p + 1)) + count(p - 1)
}

func main() {

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

	fmt.Fprintln(out, count(NextInt64()))
}

func Next() string{
	if !in.Scan() {
		panic("Scan error")
	}
	return in.Text()
}

func NextInt() int{
	ret, _ := strconv.Atoi(Next())
	return ret
}

func NextInt64() int64 {
	ret, _ := strconv.ParseInt(Next(), 10, 64)
	return ret
}

package main

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

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

func count(n int64) int64 {
	if n < 10 {
		return int64(n)
	}
	var l, p int64 = 1, 1
	for p * 10 <= n {
		l++
		p *= 10
	}

	return l * (n / p) * (n % p + 1) + count(p - 1)
}

func main() {

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

	fmt.Fprintln(out, count(NextInt64()))
}

func Next() string{
	if !in.Scan() {
		panic("Scan error")
	}
	return in.Text()
}

func NextInt() int{
	ret, _ := strconv.Atoi(Next())
	return ret
}

func NextInt64() int64 {
	ret, _ := strconv.ParseInt(Next(), 10, 64)
	return ret
}

package main

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

func main() {
    //io
    scanner := bufio.NewReader(os.Stdin)
    writer := bufio.NewWriter(os.Stdout)
    //---
    var n, d, c, ans int

    fmt.Fscan(scanner, &n)
    for c = 1; c <= n; c *= 10 {
        d++
    }
    //writer.WriteString(strconv.Itoa(c))
    c /= 10
    ans = (n - c + 1) * d;
    for d > 0 {
        ans += (c - c / 10) * (d-1);
        d--
        c /= 10
    }

    writer.WriteString(strconv.Itoa(ans))
    writer.Flush()
}

package main

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

func main() {
    //io
    scanner := bufio.NewReader(os.Stdin)
    writer := bufio.NewWriter(os.Stdout)
    //---
    var n, d, c, ans int

    fmt.Fscan(scanner, &n)
    for c = 1; c <= n; c *= 10 {
        d++
    }
    //writer.WriteString(strconv.Itoa(c))
    c /= 10
    b := d
    ans = (n - c) * d;
    for d > 0 {
        ans += (c - c / 10) * (b-d+1);
        d--
        c /= 10
    }

    writer.WriteString(strconv.Itoa(ans))
    writer.Flush()
}

package main

import (
	"fmt"
)

func main() {
	var input int
	fmt.Scanf("%d", &input)
	digits := countDigits(input)
	rem := (input - pow10(digits-1) + 1) * digits
	res := 0
	for i := 1; i < digits; i++ {
		res += (pow10(i) - pow10(i-1)) * i
	}
	fmt.Println(res + rem)
}

func pow10(n int) int {
	if n == 0 {
		return 1
	} else {
		res := 1
		for ; n > 0; n-- {
			res *= 10
		}
		return res
	}
}

func countDigits(ub int) int {
	count := 0
	for ; ub > 0; ub /= 10 {
		count++
	}
	return count
}

package main

import (
	"fmt"
)

func main() {
	var input int
	fmt.Scanf("%d", &input)
	digits := countDigits(input)
	rem := (input - pow10(digits-1) + 1) * digits
	res := 0
	for i := 1; i < digits; i++ {
		res += pow10(i) - 1
	}
	fmt.Println(res + rem)
}

func pow10(n int) int {
	if n == 0 {
		return 1
	} else {
		res := 1
		for ; n > 0; n-- {
			res *= 10
		}
		return res
	}
}

func countDigits(ub int) int {
	count := 0
	for ; ub > 0; ub /= 10 {
		count++
	}
	return count
}


//http://codeforces.com/problemset/problem/391/A
//A. Genetic Engineering
// az osszes futamot figyelni kell

package main

import (
	"fmt"
)

func main() {
	var (
		nd, i, run, ans int32
		d               string
		prev, akt       byte
	)

	fmt.Scan(&d)
	nd = int32(len(d))

	//	fmt.Println(d, nd)

	prev, run = d[0], 1

	for i = 1; i < nd; i++ {
		akt = d[i]
		if prev == akt {
			run++
		} else {
			if 0 == (run % 2) {
				ans++
			}
			prev = akt
			run = 1
		}
	}
	if 0 == (run % 2) {
		ans++
	}

	fmt.Println(ans)

}

package main

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

func main() {
	bs, _ := ioutil.ReadAll(os.Stdin)
	reader := bytes.NewBuffer(bs)
	var s string
	fmt.Fscanf(reader, "%s", &s)
	count, ans := 1, 0
	for i := 1; i < len(s); i++ {
		if s[i] == s[i-1] {
			count++
		} else {
			count, ans = 1, ans+1-(count%2)
		}
	}
	ans = ans + 1 - (count % 2)
	fmt.Printf("%d", ans)

}

package main

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

func main() {
	// defer func(start time.Time) {
	// 	fmt.Println(time.Since(start))
	// }(time.Now())

	reader := bufio.NewReader(os.Stdin)

	var s string
	fmt.Fscan(reader, &s)
	var c uint8
	var index, count int

	// fmt.Println(s)
	for i:=0; i<len(s); i++ {
		c = s[i]
		index = 0
		for i++; i<len(s) && c==s[i]; i++ {
			index++
			// fmt.Printf("%c %d\n", s[i], i)
		}
		if index%2==1 {
			// fmt.Printf("count++ %c %d\n", c, index)
			count++
		}
		i--
	}

	fmt.Println(count)
}


package main
import(
    "fmt"
    "bufio"
    "os"
)
func main() {
	in:= bufio.NewReader(os.Stdin)
	out:= bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var t int
	fmt.Fscan(in,&t)
	for i:=0;i<t;i++{
		var x float64
		fmt.Fscan(in,&x)
		if isIntegral(1/(x*0.01)) == true {
			fmt.Fprintln(out, int(1/(x*0.01)))
		} else {
			fmt.Fprintln(out,100/gcd(100,int(x)))
		}
	}
}
func isIntegral(val float64) bool {
	return val == float64(int(val))
}
func gcd(a,b int) int {
	if a<=b { // a smallest
		if b%a == 0 {
			return a
		} else {
			for i:=a/2;i>0;i--{
				if a%i == 0 {
					if b%i == 0 {
						return i
					}
				}
			}
		}
	} else {
		if a%b == 0 {
			return b
		} else {
			for i:=b/2;i>0;i--{
				if b%i == 0 {
					if a%i == 0 {
						return i
					}
				}
			}
		}
	}
	return 1
}

package main

import (
	"fmt"
)

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

	for ; t > 0; t-- {
		var k int
		fmt.Scanf("%d\n", &k)

		if k == 100 {
			fmt.Println(1)
		} else {
			curr := lcm(k, 100-k)
			fmt.Println(curr/k + curr/(100-k))
		}
	}
}

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

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

package main

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

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var T int
	fmt.Fscan(in, &T)
	for t := 0; t < T; t++ {
		var k int
		fmt.Fscan(in, &k)

		fmt.Fprintln(out, 100/(gcd(k, 100)))
	}
}

package main

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

// var m []int
// err = json.Unmarshal([]byte(r.FormValue("example")), &m)

// for i := 0; i < len(m); i++ {
// 	fmt.Println(m[i])
// }

// sort.Slice(arr, func(i, j int) bool {
// 	return arr[i] > arr[j]
// })

func MIN(x, y int64) int64 {
	if x > y {
		return y
	} else {
		return x
	}
}

func MKO(x, y int64) int64 {
	if x < y {
		return 0
	} else {
		return x - y + 1
	}
}

func MAX(x, y int64) int64 {
	if x > y {
		return x
	} else {
		return y
	}
}

func LCM(x, y int) int {
	if x >= y {
		initial := x
		for i := 1; i < y+2; i++ {
			if initial%y == 0 {
				break
			} else {
				initial = initial + x
			}

		}
		return initial
	} else {
		initial := y
		for i := 1; i < x+2; i++ {
			if initial%x == 0 {
				break
			} else {
				initial = initial + y
			}

		}
		return initial
	}
}

func GCD(x, y int64) int64 {
	var l, q int64
	l = MAX(x, y)
	q = MIN(x, y)
	var m int64
	for l*q > 0 {
		a := l % q
		b := l - a
		cc := int64(b / q)
		remain := l - cc*q
		l = MAX(remain, q)
		q = MIN(remain, q)
		if l*q == 0 {
			m = l + q
			break
		}

	}
	return m

}

func IsItPrime(x int) bool {
	if x < 10 {
		if x == 2 || x == 3 || x == 5 || x == 7 {
			return true
		} else {
			return false
		}
	} else {
		j := 0
		k := math.Sqrt(float64(x))
		for m := 3; m <= int(k); {
			if x%m == 0 {
				j = 1
				break
			}
			m = m + 2
		}
		if j == 1 {
			return false
		} else {
			return true
		}
	}

}

var t int

func main() {
	var input io.Reader = bufio.NewReader(os.Stdin)
	fmt.Fscan(input, &t)
	for o := 0; o < t; o++ {
		var k int
		fmt.Fscan(input, &k)
		m := 1
		if k%2 == 0 {
			m = m * 2
			k = int(k / 2)
		}
		if k%2 == 0 {
			m = m * 2
			k = int(k / 2)
		}
		if k%5 == 0 {
			m = m * 5
			k = int(k / 5)
		}
		if k%5 == 0 {
			m = m * 5
			k = int(k / 5)
		}
		fmt.Println(100 / m)

	}
}

package main

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

// var m []int
// err = json.Unmarshal([]byte(r.FormValue("example")), &m)

// for i := 0; i < len(m); i++ {
// 	fmt.Println(m[i])
// }

// sort.Slice(arr, func(i, j int) bool {
// 	return arr[i] > arr[j]
// })

func MIN(x, y int64) int64 {
	if x > y {
		return y
	} else {
		return x
	}
}

func MKO(x, y int64) int64 {
	if x < y {
		return 0
	} else {
		return x - y + 1
	}
}

func MAX(x, y int64) int64 {
	if x > y {
		return x
	} else {
		return y
	}
}

func LCM(x, y int) int {
	if x >= y {
		initial := x
		for i := 1; i < y+2; i++ {
			if initial%y == 0 {
				break
			} else {
				initial = initial + x
			}

		}
		return initial
	} else {
		initial := y
		for i := 1; i < x+2; i++ {
			if initial%x == 0 {
				break
			} else {
				initial = initial + y
			}

		}
		return initial
	}
}

func GCD(x, y int64) int64 {
	var l, q int64
	l = MAX(x, y)
	q = MIN(x, y)
	var m int64
	for l*q > 0 {
		a := l % q
		b := l - a
		cc := int64(b / q)
		remain := l - cc*q
		l = MAX(remain, q)
		q = MIN(remain, q)
		if l*q == 0 {
			m = l + q
			break
		}

	}
	return m

}

func IsItPrime(x int) bool {
	if x < 10 {
		if x == 2 || x == 3 || x == 5 || x == 7 {
			return true
		} else {
			return false
		}
	} else {
		j := 0
		k := math.Sqrt(float64(x))
		for m := 3; m <= int(k); {
			if x%m == 0 {
				j = 1
				break
			}
			m = m + 2
		}
		if j == 1 {
			return false
		} else {
			return true
		}
	}

}

var t int

func main() {
	var input io.Reader = bufio.NewReader(os.Stdin)
	fmt.Fscan(input, &t)
	for o := 0; o < t; o++ {
		var k int64
		fmt.Fscan(input, &k)

		if k == 100 {
			fmt.Println(1)
		} else {
			m := GCD(k, 100-k)
			sum := int(k/m) + int((100-k)/m)
			fmt.Println(sum)
		}

	}
}

package main

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

func main() {
	input := bufio.NewReader(os.Stdin)
	var T int
	_, err := fmt.Fscanln(input, &T)
	if err != nil {
		panic(err)
	}
	for k := 0; k < T; k++ {
		var x int
		_, err := fmt.Fscanln(input, &x)
		if err != nil {
			panic(err)
		}
		ans := 100
		for _, y := range ps {
			if x%y == 0 {
				x /= y
				ans /= y
			}
		}
		fmt.Println(ans)
	}
}

var (
	ps = []int{2, 2, 5, 5}
)

package main

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

type CF1525A struct {
	sc        *bufio.Reader
	split     []string
	index     int
	separator string
}

func (in *CF1525A) GetLine() string {
	line, err := in.sc.ReadString('\n')
	if err != nil {
		fmt.Println("error line:", line, " err: ", err)
	}
	in.split = []string{}
	in.index = 0
	return line
}
func (in *CF1525A) load() {
	if len(in.split) <= in.index {
		in.split = strings.Split(in.GetLine(), in.separator)
		in.index = 0
	}
}

func (in *CF1525A) NextInt() int {
	in.load()
	val, _ := strconv.Atoi(strings.TrimSpace(in.split[in.index]))
	in.index++
	return val
}

func (in *CF1525A) NextInt64() int64 {
	in.load()
	val, _ := strconv.ParseInt(strings.TrimSpace(in.split[in.index]), 10, 64)
	in.index++
	return val
}

func (in *CF1525A) NextString() string {
	in.load()
	val := strings.TrimSpace(in.split[in.index])
	in.index++
	return val
}

/**
Run solve the problem CF1525A
Date: 22/11/21
User: epradere
URL: https://codeforces.com/problemset/problem/1525/A
Problem: CF1525A
**/
func (in *CF1525A) Run() {
	for t := in.NextInt(); t > 0; t-- {
		magic := in.NextInt()
		water := 100 - magic
		div := Max(magic, water)
		ans := 0
		for {
			if magic%div == 0 && water%div == 0 {
				magic /= div
				water /= div
				div = Max(magic, water)
			} else {
				div--
			}
			if div == 1 {
				ans = magic + water
				break
			}
		}
		fmt.Println(ans)

	}
}

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

func NewCF1525A(r *bufio.Reader) *CF1525A {
	return &CF1525A{
		sc:        r,
		split:     []string{},
		index:     0,
		separator: " ",
	}
}

func main() {
	NewCF1525A(bufio.NewReader(os.Stdin)).Run()
}

package main

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

var (
	reader = bufio.NewReader(os.Stdin)
	t, k   int
)

func gcd(x, y int) int {
	if x < y {
		x, y = y, x
	}
	for y > 0 {
		x, y = y, x%y
	}
	return x
}

func solve(k int) int {
	g := gcd(k, 100-k)
	return 100 / g
}

func main() {
	fmt.Fscan(reader, &t)
	for ; t > 0; t-- {
		fmt.Fscan(reader, &k)
		fmt.Println(solve(k))
	}
}

package main

import "fmt"

//t = int(input())
//for _ in range(t):
//    k = int(input())
//    n = 100
//    while n != k:
//        if n > k:
//            n -= k
//        else:
//            k -= n
//    print(int(100 / k))

func main() {
	var t int
	fmt.Scanln(&t)
	for i := 0; i < t; i++ {
		var k int
		fmt.Scanln(&k)
		n := 100
		for n != k {
			if n > k {
				n -= k
			} else {
				k -= n
			}
		}
		fmt.Println(100 / k)
	}
}

// 要求essence达到特定百分比，但总量最少，本质上就是求essence与100的最大公约数，约掉。

package main

import (
	"fmt"
)

func main() {
	var t, k int
	fmt.Scan(&t)
	for i := 0; i < t; i++ {
		fmt.Scan(&k)
		fmt.Println(100 / gcd(100, k))
	}
}

// 求最大公约数
func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

package main

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

func min(a, b int) int {

	if a < b {
		return a
	}
	return b
}

func run(r io.Reader, w io.Writer) {

	in := bufio.NewReader(r)
	out := bufio.NewWriter(w)
	defer out.Flush()

	solve := func() {

		var n int

		fmt.Fscan(in, &n)

		fmt.Fprintln(out, 100 / gcd(n,100) )

	}

	T := 1
	fmt.Fscan(in, &T)
	for o := 0; o < T; o++ {
		solve()
	}

}

func main() {

	run(os.Stdin, os.Stdout)
}

func gcd(a, b int) int {
	for a != 0 {
		a, b = b%a, a
		//fmt.Println("a =>",a , "b =>",b)
	}
	return b
}

package main

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

func main() {

	r := bufio.NewReader(os.Stdin)

	var t int

	fmt.Fscan(r, &t)

	for i := 0; i < t; i++ {
		var k int

		fmt.Fscan(r, &k)

		ans := solve(k)

		fmt.Println(ans)

	}
}

func solve(k int) int {
	for j := 0; j <= 100; j++ {
		for p := 0; p <= 100; p++ {
			if j == 0 && p == 0 {
				continue
			}
			if 100 * j == k * (j + p) {
				return j + p
			}
		}
	}

	return -1
}

package main

import (
	"bufio"
	. "fmt"
	"io"
	"io/ioutil"
	"os"
	"strings"
)

// github.com/EndlessCheng/codeforces-go
func run(_r io.Reader, _w io.Writer) {
	in := bufio.NewReader(_r)
	out := bufio.NewWriter(_w)
	defer out.Flush()

	solve := func(Case int) {
		var n int
		Fscan(in, &n)
		g := gcd(n,100)
		Fprintln(out, 100/g)
	}

	T := 1
	Fscan(in, &T) //
	for Case := 1; Case <= T; Case++ {
		solve(Case)
	}

	_leftData, _ := ioutil.ReadAll(in)
	if _s := strings.TrimSpace(string(_leftData)); _s != "" {
		panic("有未读入的数据：\n" + _s)
	}
}

func main() { run(os.Stdin, os.Stdout) }
func gcd(a, b int) int {
	for a != 0 {
		a, b = b%a, a
	}
	return b
}

package main

import (
	"fmt"
)

func main() {
	var t int
	fmt.Scan("%d", &t)

	for ; t > 0; t-- {
		var k int
		fmt.Scan("%d", &k)

		if k == 100 {
			fmt.Println(1)
		} else {
			curr := lcm(k, 100-k)
			fmt.Println(curr/k + curr/(100-k))
		}
	}
}

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

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

package main
import(
    "fmt"
    "bufio"
    "os"
)
func main() {
	in:= bufio.NewReader(os.Stdin)
	out:= bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var t int
	fmt.Fscan(in,&t)
	for i:=0;i<t;i++{
		var x float64
		fmt.Fscan(in,&x)
		if isIntegral(1/(x*0.01)) == true {
			fmt.Fprintln(out, int(1/(x*0.01)))
		} else {
			fmt.Fprintln(out,100)
		}
	}
}
func isIntegral(val float64) bool {
	return val == float64(int(val))
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var T int
	fmt.Fscan(in, &T)
	for t := 0; t < T; t++ {
		var k int
		fmt.Fscan(in, &k)

		if 100%k == 0 {
			fmt.Fprintln(out, 100/k)
		} else {
			fmt.Fprintln(out, 100)
		}
	}
}

package main

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

func main() {
	input := bufio.NewReader(os.Stdin)
	var T int
	_, err := fmt.Fscanln(input, &T)
	if err != nil {
		panic(err)
	}
	for k := 0; k < T; k++ {
		var x int
		_, err := fmt.Fscanln(input, &x)
		if err != nil {
			panic(err)
		}
		ans := 100
		for _, y := range ps {
			if x%y == 0 {
				ans /= y
			}
		}
		fmt.Println(ans)
	}
}

var (
	ps = []int{2, 2, 5, 5}
)


package main

import ("fmt")

type set map[int]bool
type long int64

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

func nextSimple(n int)int{
	spl := n + 1
	for !isSimple(spl){spl++}
	return spl
}

func main(){
	var n, m int
	scan(&n, &m)
	if nextSimple(n) == m{
		sout("YES")
	}else{
		sout("NO")
	}
}

func scan(in ... interface{}){
	for _,k := range in{
		fmt.Scan(k)
	}
}

func sout(obj ... interface{}){
	for _, k := range obj{
		fmt.Print(k)
	}
	fmt.Println()
}

// 80A-mic
package main

import (
    "fmt"
)

func main() {
    var l, cou, n, m int
    a := make([]int, 60)
    for i := 2; i < 55; i++ {
        for k := 1; k <= i; k++ {
            if i%k == 0 {
                cou++
            }

        }
        if cou == 2 {
            a[l] = i
            l++
            cou = 0
        }
        cou = 0

    }
    fmt.Scan(&n, &m)
    for i := 0; i < 55; i++ {
        if a[i] == n && a[i+1] == m {
            fmt.Println("YES")
            return
        }
    }
    fmt.Println("NO")
}

package main

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

func main() {
	var n, m int
	fmt.Fscan(os.Stdin, &n, &m)
	i := n+1
	for i < m && !isPrime(i) { i++ }
	if i == m && isPrime(m) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}

func isPrime(n int) bool {
	nf := float64(n)
	for i := 2.0; i <= math.Sqrt(nf); i++ {
		if n % int(i) == 0 { return false }
	}
	return true
}

// cf80a project main.go
package main

import (
	"fmt"
)

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	if od(n, m) == m {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}
func od(n, m int) int {
	for i := n + 1; i <= m; i++ {
		d := 0
		for j := 1; j <= i; j++ {
			if i%j == 0 {
				d++
			}
		}
		if d == 2 {
			return i
		}
	}
	return 0
}

package main

import "fmt"

func main() {
    var n,m int
    fmt.Scan(&n,&m)
    ans := false
    for i := n+1; i <= m; i++ {
        prime := true
        for j := 2; j < i; j++ {
            if i%j == 0 { prime = false; break }
        }
        if prime {
            if i == m { ans = true }
            break
        }
    }
    if ans { fmt.Println("YES") } else { fmt.Println("NO") }
}

package main

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

func main() {
	n, m := read2i()
	if isNextPrime(n, m) {
		fmt.Fprintln(writer, "YES")
	} else {
		fmt.Fprintln(writer, "NO")
	}
	writer.Flush()
}

func isNextPrime(n, m int) bool {
	for i := n + 1; i < m; i++ {
		if isPrime(i) {
			return false
		}
	}
	return isPrime(m)
}

func isPrime(n int) bool {
	for x := 2; x*x <= n; x++ {
		if n%x == 0 {
			return false
		}
	}
	return n > 1
}

func withSameCase(word string) string {
	lowerCount := 0
	for _, letter := range word {
		if unicode.IsLower(letter) {
			lowerCount++
		}
	}
	if lowerCount*2 >= len(word) {
		return strings.ToLower(word)
	}
	return strings.ToUpper(word)
}

func solve(matrix [][]int) []string {
	n := 3
	state := make([][]byte, n)
	for i := range state {
		state[i] = make([]byte, n)
		for j := range matrix[i] {
			state[i][j] = byte(matrix[i][j])
			if i > 0 {
				state[i][j] += byte(matrix[i-1][j])
			}
			if i+1 < n {
				state[i][j] += byte(matrix[i+1][j])
			}
			if j > 0 {
				state[i][j] += byte(matrix[i][j-1])
			}
			if j+1 < n {
				state[i][j] += byte(matrix[i][j+1])
			}
			state[i][j] &= 1
			state[i][j] ^= 1
			state[i][j] += '0'
		}
	}
	res := make([]string, n)
	for i := range res {
		res[i] = string(state[i])
	}
	return res
}

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 read3i() (int, int, int) {
	return readi(), readi(), readi()
}

func read4i() (int, int, int, int) {
	return readi(), readi(), 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 readi64s(n int) []int64 {
	res := make([]int64, n)
	for i := range res {
		res[i] = readi64()
	}
	return res
}

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

var scanner *bufio.Scanner

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

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

  n, m := getI(), getI()
  for true {
    n++
    divisible := false
    for a := 2; a*a <= n; a++ {
      if n%a == 0 {
        divisible = true
        break
      }
    }
    if !divisible {
      break
    }
  }
  result := "NO"
  if n == m {
    result = "YES"
  }
  writer.WriteString(fmt.Sprintf("%s\n", result))
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	integerWord, _ := reader.ReadString('\n')
	integerSufx := strings.TrimSuffix(integerWord, "\r\n")
	integers := strings.Split(integerSufx, " ")
	currentNum, _ := strconv.Atoi(integers[0])
	candidate, _ := strconv.Atoi(integers[1])
	out := "NO"
	for currentNum < candidate {
		currentNum++
		if isPrime(currentNum) {
			if currentNum == candidate {
				out = "YES"
				break
			} else {
				out = "NO"
				break
			}
		}
	}
	fmt.Print(out)
}

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

package main

import (
	"fmt"
)

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

	numbers := make([]bool, m+1) // False for prime number
	numbers[1] = true
	numbers[2] = false
	numbers[3] = false
	for i := 2; i <= m; i++ {
		for j := 2; j <= m/i; j++ {
			numbers[i*j] = true
		}
	}

	if numbers[m] { // m is not prime
		fmt.Println("NO")
	} else {
		for i := n + 1; i < m; i++ {
			if !numbers[i] {
				fmt.Println("NO")
				return
			}
		}
		fmt.Println("YES")
	}
}

package main

import "fmt"

func main() {
    var n,m int                                 // membuat variabel n, m dengan tipe data int
    fmt.Scan(&n,&m)                             // menerima input nilai n dan m
    ans := false                                // membuat variabel ans dengan tipe bool dengan nilai awal false
    for i := n+1; i <= m; i++ {                 // looping sebanyak (m-n) kali (yaitu dari n+1 sampai m)
        prime := true                           // membuat variabel prime dengan tipe bool dengan nilai awal true
        for j := 2; j < i; j++ {                // looping dari j = 2 sampai j >= i (dari 2..(i-1))
            if i%j == 0 { prime = false; break }// jika i habis dibagi j, maka prime diubah menjadi false dan break
        }
        if prime {                              // jika nilai prime = true
            if i == m { ans = true }            // jika nilai i sama dengan nilai m, maka ans diubah menjadi true
            break                               // break dari looping
        }
    }
    if ans { fmt.Println("YES") } else { fmt.Println("NO") }  // jika nilai ans = true, maka cetak output "YES". Jika tidak, maka cetak output "NO"
}

package main

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

func main() {
	var n,m int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscanf(in, "%d %d\n", &n, &m)
	if check(n,m){
		fmt.Println("YES")
	}else{
		fmt.Println("NO")
	}
}
func check(n int, m int) bool{
	for i:= n + 1; i <= m; i++{
		if checkPrime(i) > 0{
			if i == m{
				return true
			}else{
				return false
			}
		}
	}
	return false
}
func checkPrime(a int) int{
	for k:= 2; k < a; k++{
		if a % k == 0{
			return -1
		}
	}
	return a
}

package main

import "fmt"

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

	is_prime := make([]int, 51, 51)
	for i := 0; i < 51; i++ {
		is_prime[i] = 1
	}
	is_prime[1] = 0
	for i := 2; i <= 8; i++ {
		if is_prime[i] == 1 {
			for x := i + i; x < 51; x += i {
				is_prime[x] = 0
			}
		}
	}

	ans := false
	for i := n + 1; i < 51; i++ {
		if is_prime[i] == 1 {
			if i == m {
				ans = true
			}
			break
		}
	}

	if ans == true {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

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

func main() {
	var n,m int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscanf(in, "%d %d\n", &n, &m)
	if check(n,m){
		fmt.Println("YES")
	}else{
		fmt.Println("NO")
	}
}
func check(n int, m int) bool{
	for i:= n + 1; i <= m; i++{
		if checkPrime(i) == m{
			return true
		}
	}
	return false
}
func checkPrime(a int) int{
	for k:= 2; k < a; k++{
		if a % k == 0{
			return -1
		}
	}
	return a
}

package main

import "fmt"

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

	is_prime := make([]int, 51, 51)
	for i := 0; i < 51; i++ {
		is_prime[i] = 1
	}
	is_prime[1] = 0
	for i := 2; i <= 8; i++ {
		if is_prime[i] == 1 {
			for x := i + i; x < 51; x += i {
				is_prime[x] = 0
			}
		}
	}

	ans := false
	for i := n + 1; i < 51; i++ {
		if is_prime[i] == 1 {
			if i == m {
				ans = true
			}
		}
	}

	if ans == true {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}