// https://atcoder.jp/contests/abc110/tasks/abc110_a

package main

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

// d: debug IO. it can print debug in test.
func solve(io *Io, d *Io) {
	A := io.NextInt()
	B := io.NextInt()
	C := io.NextInt()

	ints := []int{A, B, C}
	sort.Ints(ints)

	res := ints[2]*10 + ints[1] + ints[0]
	io.Println(res)
}

func main() {
	io := NewIo()
	defer io.Flush()
	solve(io, nil)
}

/* IO Helpers */

// Io combines reader, writer, & tokens as the state when processing the input
type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

// NewIo creates Io with Stdin & Stdout
func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

// Flush calls the writer's Flush
func (io *Io) Flush() {
	io.writer.Flush()
}

// NextLine returns the string from reader.ReadLine()
func (io *Io) NextLine() string {
	if io.nextToken < len(io.tokens) {
		panic("io.nextToken < len(io.tokens)")
	}

	var buffer bytes.Buffer

	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buffer.Write(line)
		if !isPrefix {
			break
		}
	}

	return buffer.String()
}

// NextLines returns []string from next n lines
func (io *Io) NextLines(n int) []string {
	res := make([]string, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextLine()
	}
	return res
}

// Next returns the string token (partial string of the line divided by spaces)
func (io *Io) Next() string {
	if io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}

	res := io.tokens[io.nextToken]
	io.nextToken++
	return res
}

// NextStrings returns the []string from the next n tokens
func (io *Io) NextStrings(n int) []string {
	res := make([]string, n)
	for i := 0; i < n; i++ {
		res[i] = io.Next()
	}
	return res
}

// NextInt returns the int from the next token
func (io *Io) NextInt() int {
	res, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return res
}

// NextInts returns the []int from the next n tokens
func (io *Io) NextInts(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextInt()
	}
	return res
}

// NextFloat returns the float64 from the next token
func (io *Io) NextFloat() float64 {
	res, err := strconv.ParseFloat(io.Next(), 64)
	if err != nil {
		panic(err)
	}
	return res
}

// NextFloats returns the []float64 from the next n tokens
func (io *Io) NextFloats(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextFloat()
	}
	return res
}

// Println prints the input to the writer in an easy-to-see form
func (io *Io) Println(a ...interface{}) {
	var values []string
	for i := 0; i < len(a); i++ {
		values = append(values, "%v")
	}
	io.Printfln(strings.Join(values, " "), a...)
}

// Print calls Fprint to the writer
func (io *Io) Print(a interface{}) {
	fmt.Fprint(io.writer, a)
}

// Printf calls Fprintf to the writer
func (io *Io) Printf(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format, a...)
}

// Printfln calls Fprint to the writer
func (io *Io) Printfln(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format+"\n", a...)
}

// PrintInts prints ints with space and new line at the end
func (io *Io) PrintInts(ints []int) {
	for i, e := range ints {
		io.Print(e)

		if i == len(ints)-1 {
			io.Println()
		} else {
			io.Print(" ")
		}
	}
}

// Debug calls Println and Flush immediately
func (io *Io) Debug(a ...interface{}) {
	if io == nil {
		return
	}

	io.Println(a...)
	io.Flush()
}

/* Math Helpers */

// MOD is 10^9 + 7
const MOD = 1000000007

// Max of the ints
func Max(numbers ...int) int {
	max := numbers[0]
	for i, number := range numbers {
		if i == 0 {
			continue
		}
		if number > max {
			max = number
		}
	}
	return max
}

// Min of the ints
func Min(numbers ...int) int {
	max := numbers[0]
	for i, number := range numbers {
		if i == 0 {
			continue
		}
		if max > number {
			max = number
		}
	}
	return max
}

// DigitSum returns sum of the int's digits
func DigitSum(n int) int {
	if n < 0 {
		return -1
	}

	res := 0

	for n > 0 {
		res += n % 10
		n /= 10
	}

	return res
}

// Sum of the ints
func Sum(numbers ...int) int {
	sum := 0

	for _, number := range numbers {
		sum += number
	}

	return sum
}

// Pow calculates the pow for int with O(log e)
func Pow(a, e int) int {
	if a < 0 || e < 0 {
		panic(fmt.Sprintf("Pow was called for a < 0 or e < 0, a: %d, e: %d", a, e))
	}

	if e == 0 {
		return 1
	}

	if e%2 == 0 {
		half := Pow(a, e/2)
		return half * half
	}

	return a * Pow(a, e-1)
}

// Abs returns the absolute value of the input
func Abs(a int) int {
	if a < 0 {
		return -a
	}

	return a
}

/* Structure Helpers */

// Set is orderless List
type Set map[interface{}]struct{}

// NewSet returns empty Set
func NewSet() *Set {
	return &Set{}
}

// Add the value to the set
func (set *Set) Add(value interface{}) {
	(*set)[value] = struct{}{}
}

// Includes check the set has the value
func (set *Set) Includes(value interface{}) bool {
	_, included := (*set)[value]
	return included
}

// Remove deletes the value from the set if exists
func (set *Set) Remove(value interface{}) {
	if !set.Includes(value) {
		return
	}

	delete(*set, value)
}

// ImmutableSort returns sorted slice without mutating original one
func ImmutableSort(slice []int) []int {
	res := make([]int, len(slice))
	copy(res, slice)
	sort.Ints(res)
	return res
}

/* Util helpers */

// Ternary is like `cond ? a : b`. should assert the returned value like `Ternary(cond, a, b).(int)`
func Ternary(cond bool, a, b interface{}) interface{} {
	if cond {
		return a
	}

	return b
}

// TernaryInt uses Ternary and assert the value as int
func TernaryInt(cond bool, a, b int) int {
	return Ternary(cond, a, b).(int)
}

// TernaryString uses Ternary and assert the value as string
func TernaryString(cond bool, a, b string) string {
	return Ternary(cond, a, b).(string)
}


package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	a := getNextInt(scanner)
	b := getNextInt(scanner)
	c := getNextInt(scanner)

	ans := a + b + c
	max := a
	if max < b {
		max = b
	}
	if max < c {
		max = c
	}
	fmt.Fprintln(writer, ans+9*max)

	writer.Flush()
}

Global OOD problem IDs are disjoint from train, validation, and in-distribution test problem IDs.

Score : 100 points

Problem Statement

You have decided to give an allowance to your child depending on the outcome of the game that he will play now.

The game is played as follows:

There are three "integer panels", each with a digit between 1 and 9 (inclusive) printed on it, and one "operator panel" with a + printed on it.

The player should construct a formula of the form X + Y, by arranging the four panels from left to right. (The operator panel should not be placed at either end of the formula.)

Then, the amount of the allowance will be equal to the resulting value of the formula.

Given the values A, B and C printed on the integer panels used in the game, find the maximum possible amount of the allowance.

Constraints

All values in input are integers.

1 \leq A, B, C \leq 9

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the maximum possible amount of the allowance.

Sample Input 1

1 5 2

Sample Output 1

53

The amount of the allowance will be 53 when the panels are arranged as 52+1, and this is the maximum possible amount.

Sample Input 2

9 9 9

Sample Output 2

108

Sample Input 3

6 6 7

Sample Output 3

82

Submitted source-code file size, in bytes.

Execution CPU time reported by official Project CodeNet metadata, in milliseconds.

Peak memory usage reported by official Project CodeNet metadata, in kilobytes.


package main

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

/*********** I/O ***********/

var (
	// ReadString returns a WORD string.
	ReadString func() string
	stdout     *bufio.Writer
)

func init() {
	ReadString = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	// Split sets the split function for the Scanner. The default split function is ScanLines.
	// Split panics if it is called after scanning has started.
	r.Split(bufio.ScanWords)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}

// ReadInt returns an integer.
func ReadInt() int {
	return int(readInt64())
}

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

// ReadIntSlice returns an integer slice that has n integers.
func ReadIntSlice(n int) []int {
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt()
	}
	return b
}

// ReadRuneSlice returns a rune slice.
func ReadRuneSlice() []rune {
	return []rune(ReadString())
}

/*********** Arithmetic ***********/

// Max returns the max integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Max(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m < integer {
			m = integer
		}
	}
	return m
}

// Min returns the min integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Min(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m > integer {
			m = integer
		}
	}
	return m
}

// PowInt is integer version of math.Pow
func PowInt(a, e int) int {
	if a < 0 || e < 0 {
		panic(errors.New("[argument error]: PowInt does not accept negative integers"))
	}
	fa := float64(a)
	fe := float64(e)
	fanswer := math.Pow(fa, fe)
	return int(fanswer)
}

// AbsInt is integer version of math.Abs
func AbsInt(a int) int {
	fa := float64(a)
	fanswer := math.Abs(fa)
	return int(fanswer)
}

// Gcd returns the Greatest Common Divisor of two natural numbers.
// Gcd only accepts two natural numbers (a, b >= 1).
// 0 or negative number causes panic.
// Gcd uses the Euclidean Algorithm.
func Gcd(a, b int) int {
	if a <= 0 || b <= 0 {
		panic(errors.New("[argument error]: Gcd only accepts two NATURAL numbers"))
	}
	if a < b {
		a, b = b, a
	}

	// Euclidean Algorithm
	for b > 0 {
		div := a % b
		a, b = b, div
	}

	return a
}

// Lcm returns the Least Common Multiple of two natural numbers.
// Lcd only accepts two natural numbers (a, b >= 1).
// 0 or negative number causes panic.
// Lcd uses the Euclidean Algorithm indirectly.
func Lcm(a, b int) int {
	if a <= 0 || b <= 0 {
		panic(errors.New("[argument error]: Gcd only accepts two NATURAL numbers"))
	}

	// a = a'*gcd, b = b'*gcd, a*b = a'*b'*gcd^2
	// a' and b' are relatively prime numbers
	// gcd consists of prime numbers, that are included in a and b
	gcd := Gcd(a, b)

	// not (a * b / gcd), because of reducing a probability of overflow
	return (a / gcd) * b
}

/*********** Utilities ***********/

// DeleteElement returns a *NEW* slice, that have the same and minimum length and capacity.
// DeleteElement makes a new slice by using easy slice literal.
func DeleteElement(s []int, i int) []int {
	if i < 0 || len(s) <= i {
		panic(errors.New("[index error]"))
	}
	// appendのみの実装
	n := make([]int, 0, len(s)-1)
	n = append(n, s[:i]...)
	n = append(n, s[i+1:]...)
	return n
}

// Concat returns a *NEW* slice, that have the same and minimum length and capacity.
func Concat(s, t []rune) []rune {
	n := make([]rune, 0, len(s)+len(t))
	n = append(n, s...)
	n = append(n, t...)
	return n
}

// UpperRune is rune version of `strings.ToUpper()`.
func UpperRune(r rune) rune {
	str := strings.ToUpper(string(r))
	return []rune(str)[0]
}

// LowerRune is rune version of `strings.ToLower()`.
func LowerRune(r rune) rune {
	str := strings.ToLower(string(r))
	return []rune(str)[0]
}

// ToggleRune returns a upper case if an input is a lower case, v.v.
func ToggleRune(r rune) rune {
	var str string
	if 'a' <= r && r <= 'z' {
		str = strings.ToUpper(string(r))
	} else if 'A' <= r && r <= 'Z' {
		str = strings.ToLower(string(r))
	} else {
		str = string(r)
	}
	return []rune(str)[0]
}

// ToggleString iteratively calls ToggleRune, and returns the toggled string.
func ToggleString(s string) string {
	inputRunes := []rune(s)
	outputRunes := make([]rune, 0, len(inputRunes))
	for _, r := range inputRunes {
		outputRunes = append(outputRunes, ToggleRune(r))
	}
	return string(outputRunes)
}

// Strtoi is a wrapper of `strconv.Atoi()`.
// If `strconv.Atoi()` returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

/*********** Binary Search ***********/

// LowerBound returns an index of a slice whose value is EQUAL TO AND LARGER THAN A KEY VALUE.
func LowerBound(s []int, key int) int {
	isLarger := func(index, key int) bool {
		if s[index] >= key {
			return true
		} else {
			return false
		}
	}

	left, right := -1, len(s)

	for right-left > 1 {
		mid := left + (right-left)/2
		if isLarger(mid, key) {
			right = mid
		} else {
			left = mid
		}
	}

	return right
}

// UpperBound returns an index of a slice whose value is EQUAL TO AND SMALLER THAN A KEY VALUE.
func UpperBound(s []int, key int) int {
	isSmaller := func(index, key int) bool {
		if s[index] <= key {
			return true
		} else {
			return false
		}
	}

	left, right := -1, len(s)

	for right-left > 1 {
		mid := left + (right-left)/2
		if isSmaller(mid, key) {
			left = mid
		} else {
			right = mid
		}
	}

	return left
}

/*********** Factorization, Prime Number ***********/

// TrialDivision returns the result of prime factorization of integer N.
func TrialDivision(n int) map[int]int {
	if n <= 0 {
		panic(errors.New("[argument error]: TrialDivision only accepts a NATURAL number"))
	}
	if n == 1 {
		return map[int]int{1: 1}
	}

	p := map[int]int{}
	sqrt := math.Pow(float64(n), 0.5)
	for i := 2; i <= int(sqrt); i++ {
		exp := 0
		for n%i == 0 {
			exp++
			n /= i
		}

		if exp == 0 {
			continue
		}
		p[i] = exp
	}
	if n > 1 {
		p[n] = 1
	}

	return p
}

// IsPrime judges whether an argument integer is a prime number or not.
func IsPrime(n int) bool {
	if n == 1 {
		return false
	}

	sqrt := math.Pow(float64(n), 0.5)
	for i := 2; i <= int(sqrt); i++ {
		if n%i == 0 {
			return false
		}
	}

	return true
}

/********** sort package (snippets) **********/
//sort.Sort(sort.IntSlice(s))
//sort.Sort(sort.Reverse(sort.IntSlice(s)))
//sort.Sort(sort.Float64Slice(s))
//sort.Sort(sort.StringSlice(s))

/********** copy function (snippets) **********/
//a = []int{0, 1, 2}
//b = make([]int, len(a))
//copy(b, a)

/********** I/O usage **********/

//str := ReadString()
//i := ReadInt()
//X := ReadIntSlice(n)
//S := ReadRuneSlice()

/*******************************************************************/

const mod = 1e9 + 7

var a, b, c int

func main() {
	a, b, c = ReadInt(), ReadInt(), ReadInt()
	fmt.Println(Max(10*a+b+c, a+10*b+c, a+b+10*c))
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := make([]int, 3)
	for i := 0; i < 3; i++ {
		fmt.Scan(&nums[i])
	}

	sort.Sort(sort.Reverse(sort.IntSlice(nums)))
    ans := nums[0]*10 + nums[1] + nums[2]
	fmt.Println(ans)
}


package main

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

func main() {
	s := IOInitialize()
	A := Int(s)
	B := Int(s)
	C := Int(s)
	nums := []int{A, B, C}
	index := max(nums)
	res := 0
	for i, num := range nums {
		if i == index {
			res += num * 10
		} else {
			res += num
		}
	}
	fmt.Println(res)
}

func max(nums []int) int {
	res := 0
	n := nums[0]
	for i, num := range nums {
		if n < num {
			n = num
			res = i
		}
	}
	return res
}

func IOInitialize() *bufio.Scanner {
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)
	return s
}

func Int(s *bufio.Scanner) int {
	if !s.Scan() {
		panic("scan error")
	}

	value, err := strconv.Atoi(s.Text())
	if err != nil {
		panic("text to int error")
	}
	return value
}

func String(s *bufio.Scanner) string {
	if !s.Scan() {
		panic("scan error")
	}

	return s.Text()
}

func scanNums(s *bufio.Scanner, len int) (nums []int) {
	for i := 0; i < len; i++ {
		num := Int(s)
		nums = append(nums, num)
	}
	return
}

func scanstrings(s *bufio.Scanner, len int) (strs []string) {
	for i := 0; i < len; i++ {
		str := String(s)
		strs = append(strs, str)
	}
	return
}


package main

import (
  "fmt"
  "sort"
)

func main() {
  var n, m, X, Y int
  fmt.Scan(&n, &m, &X, &Y)
  x := make([]int, n)
  y := make([]int, m)
  for i := 0; i < n; i++ {
    fmt.Scan(&x[i])
  }
  for i := 0; i < m; i++ {
    fmt.Scan(&y[i])
  }
  x = append(x, X)
  y = append(y, Y)
  sort.Ints(x)
  sort.Ints(y)

  ans := "No War"
  if x[n] >= y[0] {
    ans = "War"
  }
  fmt.Println(ans)
}

Score : 200 points

Problem Statement

Our world is one-dimensional, and ruled by two empires called Empire A and Empire B.

The capital of Empire A is located at coordinate X, and that of Empire B is located at coordinate Y.

One day, Empire A becomes inclined to put the cities at coordinates x_1, x_2, ..., x_N under its control, and Empire B becomes inclined to put the cities at coordinates y_1, y_2, ..., y_M under its control.

If there exists an integer Z that satisfies all of the following three conditions, they will come to an agreement, but otherwise war will break out.

X < Z \leq Y

x_1, x_2, ..., x_N < Z

y_1, y_2, ..., y_M \geq Z

Determine if war will break out.

Constraints

All values in input are integers.

1 \leq N, M \leq 100

-100 \leq X < Y \leq 100

-100 \leq x_i, y_i \leq 100

x_1, x_2, ..., x_N \neq X

x_i are all different.

y_1, y_2, ..., y_M \neq Y

y_i are all different.

Input

Input is given from Standard Input in the following format:

N M X Y
x_1 x_2 ... x_N
y_1 y_2 ... y_M

Output

If war will break out, print War; otherwise, print No War.

Sample Input 1

3 2 10 20
8 15 13
16 22

Sample Output 1

No War

The choice Z = 16 satisfies all of the three conditions as follows, thus they will come to an agreement.

X = 10 < 16 \leq 20 = Y

8, 15, 13 < 16

16, 22 \geq 16

Sample Input 2

4 2 -48 -1
-20 -35 -91 -23
-22 66

Sample Output 2

War

Sample Input 3

5 3 6 8
-10 3 1 5 -100
100 6 14

Sample Output 3

War


package main

import "fmt"

func main(){
	var N,M,X,Y int
	fmt.Scan(&N,&M,&X,&Y)
	x := make([]int,N)
	y := make([]int,M)
	for i:=0;i<N;i++{
		fmt.Scan(&x[i])
	}
	for i:=0;i<M;i++ {
		fmt.Scan(&y[i])
	}
	xmax := x[0]
	ymin := y[0]

	for i:=0;i<N;i++{
		if xmax < x[i]{
			xmax = x[i]
		}

	}
	xmax++
	for i:=0;i<M;i++{
		if ymin > x[i]{
			ymin = x[i]
		}
	}

	if xmax < ymin && X < Y {
		fmt.Println("No War")
	}else {
		fmt.Println("War")
	}

}


package main

import (
	"fmt"
)

func main() {
	var N, M, X, Y, in int
	fmt.Scan(&N, &M, &X, &Y)
	xarr := make([]int, N)
	yarr := make([]int, M)
	xmax := -100
	ymin := 100
	for i := 0; i < N; i++ {
		fmt.Scan(&in)
		if in > xmax {
			xmax = in
		}
		xarr[i] = in
	}
	for i := 0; i < M; i++ {
		fmt.Scan(&in)
		if in < ymin {
			ymin = in
		}
		yarr[i] = in
	}
	r := "War"
	for i := X + 1; i <= Y; i++ {
		if i > xmax && i <= ymin {
			r = "No War"
			break
		}
	}
	fmt.Println(r)
}


package main

import (
	"fmt"
)

func max(a []int) int {
	max := a[0]
	for _, v := range a {
		if max < v {
			max = v
		}
	}
	return max
}

func min(a []int) int {
	min := a[0]
	for _, v := range a {
		if v < min {
			min = v
		}
	}
	return min
}

func main() {
	var N, M, X, Y int
	fmt.Scan(&N, &M, &X, &Y)

	x := make([]int, N)
	for i := 0; i < N; i++ {
		fmt.Scan(&x[i])
	}
	y := make([]int, M)
	for i := 0; i < M; i++ {
		fmt.Scan(&y[i])
	}

	xmax := max(x)
	ymin := min(y)

	for z := X + 1; z <= Y; z++ {
		if xmax < z && z <= ymin {
			fmt.Println("No War")
			return
		}
	}
	fmt.Println("War")
}


// Package main provides
//
// File:  b.go
// Author: ymiyamoto
//
// Created on Sun Dec  2 04:51:26 2018
//
package main

import (
	"fmt"
	"sort"
)

var n, m, x, y int

func main() {
	fmt.Scan(&n, &m, &x, &y)

	xs := make([]int, n)
	ys := make([]int, m)

	for i := range xs {
		fmt.Scan(&xs[i])
	}
	sort.Ints(xs)
	max := xs[len(xs)-1]

	for i := range ys {
		fmt.Scan(&ys[i])
	}
	sort.Ints(ys)
	min := ys[0]

	sort.Ints(ys)
	for i := x + 1; i <= y; i++ {
		if max < i && i <= min {
			fmt.Println("No War")
			return
		}
	}
	fmt.Println("War")
}


// Package main provides
//
// File:  b.go
// Author: ymiyamoto
//
// Created on Sun Dec  2 04:51:26 2018
//
package main

import (
	"fmt"
	"sort"
)

var n, m, x, y int

func main() {
	fmt.Scan(&n, &m, &x, &y)

	xs := make([]int, n)
	ys := make([]int, m)

	for i := range xs {
		fmt.Scan(&xs[i])
	}
	sort.Ints(xs)
	max := xs[len(xs)-1]

	for i := range ys {
		fmt.Scan(&ys[i])
	}
	min := ys[0]

	sort.Ints(ys)
	for i := x; i <= y; i++ {
		if max < i && i <= min {
			fmt.Println("No War")
			return
		}
	}
	fmt.Println("War")
}


package main

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

func main(){
	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	arr := strings.Split(sc.Text(), " ")
	N, _ := strconv.Atoi(arr[0])
	M, _ := strconv.Atoi(arr[1])
	X, _ := strconv.Atoi(arr[2])
	Y, _ := strconv.Atoi(arr[3])
	sc.Scan()
	x_list := strings.Split(sc.Text(), " ")
	var x, y, x_max int
	var is_war bool
	x_max = X
	for i:=0; i<N; i++{
		x, _ = strconv.Atoi(x_list[i])
		if x > Y{
			is_war = true
			break
		}
		if x > x_max{
			x_max = x
		}
	}
	sc.Scan()
	y_list := strings.Split(sc.Text(), " ")
	for i:=0; i<M; i++{
		y, _ = strconv.Atoi(y_list[i])
		if y < x_max{
			is_war = true
			break
		}
	}

	if is_war{
		fmt.Println("War")
	} else {
		fmt.Println("No war")
	}
}


package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strconv"
	"strings"
)

var (
	// ErrLineNotFound -
	ErrLineNotFound = errors.New("lines: line not found")
)

type onError int

const (
	onErrorPanic onError = iota
	onErrorError
)

// Lines represents multi line.
type Lines struct {
	r       io.Reader
	w       io.Writer
	onError onError

	store []string
}

// NewLines create lines from provided input reader.
func New(r io.Reader) *Lines {
	lines, err := newLines(r, ioutil.Discard, onErrorPanic)
	if err != nil {
		panic(err)
	}
	return lines
}

// Line represents single line.
type Line struct {
	store string
	field int
}

// Line return given n line.
func (ls *Lines) Line(n int) *Line {
	line, err := ls.line(n)
	if err != nil {
		panic(err)
	}
	return line
}

func (ls *Lines) line(n int) (*Line, error) {
	if n >= len(ls.store) {
		return nil, ErrLineNotFound
	}
	return &Line{store: ls.store[n]}, nil
}

func (l *Line) Ints() []int {
	ints, err := l.ints()
	if err != nil {
		panic(err)
	}
	return ints
}

func (l *Line) ints() ([]int, error) {
	var ints []int
	fields := strings.Fields(l.store)
	for _, s := range fields {
		i, err := strconv.Atoi(s)
		if err != nil {
			return nil, err
		}
		ints = append(ints, i)
	}
	return ints, nil
}

// Field specify current field scope.
func (l *Line) Field(n int) *Line {
	clone := l.clone()
	clone.field = n
	return clone
}

func (l *Line) Int() int {
	ints, err := l.ints()
	if err != nil {
		panic(err)
	}
	return ints[l.field]
}

func newLines(r io.Reader, w io.Writer, onError onError) (*Lines, error) {
	lines := &Lines{
		r:       r,
		w:       w,
		onError: onErrorError,
	}
	return lines, lines.init()
}

func (ls *Lines) init() error {
	s := bufio.NewScanner(ls.r)
	for s.Scan() {
		ls.store = append(ls.store, s.Text())
	}
	return s.Err()
}

func (l *Line) clone() *Line {
	clone := *l
	return &clone
}

func main() {
	lines := New(os.Stdin)

	line0 := lines.Line(0).Ints()

	x, y := line0[2], line0[3]
	xs := lines.Line(1).Ints()
	ys := lines.Line(2).Ints()

	cands := candidates(x, y)

	var oks []int
loop:
	for _, cand := range cands {
		for _, x := range xs {
			if x >= cand {
				continue loop
			}
		}

		for _, y := range ys {
			if y < cand {
				continue loop
			}
		}
		oks = append(oks, cand)
	}

	if len(oks) > 0 {
		fmt.Println("No War")
	} else {
		fmt.Println("War")
	}
}

func candidates(x, y int) []int {
	if x >= y {
		return nil
	}
	var ints []int
	for i := x + 1; i <= y; i++ {
		ints = append(ints, i)
	}
	return ints
}


package main

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

func main() {
	r := bufio.NewReader(os.Stdin)
	s, _ := r.ReadString('\n')
	s = strings.TrimRight(s, " \t\n")
	slice := strings.Split(s, " ")
	a := string(slice[0])
	b := string(slice[1])
	A, _ := strconv.Atoi(a)
	B, _ := strconv.Atoi(b)

	for i := 1; i <= 3; i++ {
		if A*B*i%2 == 1 {
			fmt.Println("Yes")
			os.Exit(0)
		}
	}
	fmt.Println("No")
	os.Exit(0)

}

Score : 100 points

Problem Statement

You are given integers A and B, each between 1 and 3 (inclusive).

Determine if there is an integer C between 1 and 3 (inclusive) such that A \times B \times C is an odd number.

Constraints

All values in input are integers.

1 \leq A, B \leq 3

Input

Input is given from Standard Input in the following format:

A B

Output

If there is an integer C between 1 and 3 that satisfies the condition, print Yes; otherwise, print No.

Sample Input 1

3 1

Sample Output 1

Yes

Let C = 3. Then, A \times B \times C = 3 \times 1 \times 3 = 9, which is an odd number.

Sample Input 2

1 2

Sample Output 2

No

Sample Input 3

2 2

Sample Output 3

No


// https://atcoder.jp/contests/abc109/tasks/abc109_a

package main

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

// d: debug IO. it can print debug in test.
func solve(io *Io, d *Io) {
	A := io.NextInt()
	B := io.NextInt()

	can := A%2 == 1 && B%2 == 1
	res := TernaryString(can, "Yes", "No")
	io.Println(res)
}

func main() {
	io := NewIo()
	defer io.Flush()
	solve(io, nil)
}

/* IO Helpers */

// Io combines reader, writer, & tokens as the state when processing the input
type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

// NewIo creates Io with Stdin & Stdout
func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

// Flush calls the writer's Flush
func (io *Io) Flush() {
	io.writer.Flush()
}

// NextLine returns the string from reader.ReadLine()
func (io *Io) NextLine() string {
	if io.nextToken < len(io.tokens) {
		panic("io.nextToken < len(io.tokens)")
	}

	var buffer bytes.Buffer

	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buffer.Write(line)
		if !isPrefix {
			break
		}
	}

	return buffer.String()
}

// NextLines returns []string from next n lines
func (io *Io) NextLines(n int) []string {
	res := make([]string, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextLine()
	}
	return res
}

// Next returns the string token (partial string of the line divided by spaces)
func (io *Io) Next() string {
	if io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}

	res := io.tokens[io.nextToken]
	io.nextToken++
	return res
}

// NextStrings returns the []string from the next n tokens
func (io *Io) NextStrings(n int) []string {
	res := make([]string, n)
	for i := 0; i < n; i++ {
		res[i] = io.Next()
	}
	return res
}

// NextInt returns the int from the next token
func (io *Io) NextInt() int {
	res, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return res
}

// NextInts returns the []int from the next n tokens
func (io *Io) NextInts(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextInt()
	}
	return res
}

// NextFloat returns the float64 from the next token
func (io *Io) NextFloat() float64 {
	res, err := strconv.ParseFloat(io.Next(), 64)
	if err != nil {
		panic(err)
	}
	return res
}

// NextFloats returns the []float64 from the next n tokens
func (io *Io) NextFloats(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = io.NextFloat()
	}
	return res
}

// Println prints the input to the writer in an easy-to-see form
func (io *Io) Println(a ...interface{}) {
	var values []string
	for i := 0; i < len(a); i++ {
		values = append(values, "%v")
	}
	io.Printfln(strings.Join(values, " "), a...)
}

// Print calls Fprint to the writer
func (io *Io) Print(a interface{}) {
	fmt.Fprint(io.writer, a)
}

// Printf calls Fprintf to the writer
func (io *Io) Printf(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format, a...)
}

// Printfln calls Fprint to the writer
func (io *Io) Printfln(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format+"\n", a...)
}

// PrintInts prints ints with space and new line at the end
func (io *Io) PrintInts(ints []int) {
	for i, e := range ints {
		io.Print(e)

		if i == len(ints)-1 {
			io.Println()
		} else {
			io.Print(" ")
		}
	}
}

// Debug calls Println and Flush immediately
func (io *Io) Debug(a ...interface{}) {
	if io == nil {
		return
	}

	io.Println(a...)
	io.Flush()
}

/* Math Helpers */

// MOD is 10^9 + 7
const MOD = 1000000007

// Max of the ints
func Max(numbers ...int) int {
	max := numbers[0]
	for i, number := range numbers {
		if i == 0 {
			continue
		}
		if number > max {
			max = number
		}
	}
	return max
}

// Min of the ints
func Min(numbers ...int) int {
	max := numbers[0]
	for i, number := range numbers {
		if i == 0 {
			continue
		}
		if max > number {
			max = number
		}
	}
	return max
}

// DigitSum returns sum of the int's digits
func DigitSum(n int) int {
	if n < 0 {
		return -1
	}

	res := 0

	for n > 0 {
		res += n % 10
		n /= 10
	}

	return res
}

// Sum of the ints
func Sum(numbers ...int) int {
	sum := 0

	for _, number := range numbers {
		sum += number
	}

	return sum
}

// Pow calculates the pow for int with O(log e)
func Pow(a, e int) int {
	if a < 0 || e < 0 {
		panic(fmt.Sprintf("Pow was called for a < 0 or e < 0, a: %d, e: %d", a, e))
	}

	if e == 0 {
		return 1
	}

	if e%2 == 0 {
		half := Pow(a, e/2)
		return half * half
	}

	return a * Pow(a, e-1)
}

// Abs returns the absolute value of the input
func Abs(a int) int {
	if a < 0 {
		return -a
	}

	return a
}

/* Structure Helpers */

// Set is orderless List
type Set map[interface{}]struct{}

// NewSet returns empty Set
func NewSet() *Set {
	return &Set{}
}

// Add the value to the set
func (set *Set) Add(value interface{}) {
	(*set)[value] = struct{}{}
}

// Includes check the set has the value
func (set *Set) Includes(value interface{}) bool {
	_, included := (*set)[value]
	return included
}

// Remove deletes the value from the set if exists
func (set *Set) Remove(value interface{}) {
	if !set.Includes(value) {
		return
	}

	delete(*set, value)
}

// ImmutableSort returns sorted slice without mutating original one
func ImmutableSort(slice []int) []int {
	res := make([]int, len(slice))
	copy(res, slice)
	sort.Ints(res)
	return res
}

/* Util helpers */

// Ternary is like `cond ? a : b`. should assert the returned value like `Ternary(cond, a, b).(int)`
func Ternary(cond bool, a, b interface{}) interface{} {
	if cond {
		return a
	}

	return b
}

// TernaryInt uses Ternary and assert the value as int
func TernaryInt(cond bool, a, b int) int {
	return Ternary(cond, a, b).(int)
}

// TernaryString uses Ternary and assert the value as string
func TernaryString(cond bool, a, b string) string {
	return Ternary(cond, a, b).(string)
}


package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	a := getNextInt(scanner)
	b := getNextInt(scanner)

	ans := "Yes"

	if (a*b)&1 == 0 {
		ans = "No"
	}

	fmt.Fprintln(writer, ans)
	writer.Flush()
}


package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	a := getNextInt(scanner)
	b := getNextInt(scanner)

	ans := "Yes"

	if a*b^1 == 0 {
		ans = "No"
	}

	fmt.Fprintln(writer, ans)
	writer.Flush()
}


package main

import (
	"fmt"
	"os"
)

func main() {
	nums := ScanNums(2)
	for _, n := range nums {
		if n%2 == 0 {
			fmt.Print("No")
			os.Exit(0)
		}
	}
	fmt.Print("Yes")
}

func ScanNums(len int) (nums []int) {
	var num int
	for i := 0; i < len; i++ {
		fmt.Scan(&num)
		nums = append(nums, num)
	}
	return
}


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a == 2 || b == 2 {
		fmt.Println("No")
	} else {
		fmt.Println("Yes")
	}
}


package main

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

func main() {
	sc := NewScanner()

	a := sc.NextInt()
	b := sc.NextInt()
	if a%2 == 0 || b%2 == 0 {
		fmt.Println("No")
		return
	}
	fmt.Println("Yes")
	return

}

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) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			result = append(result, v)
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	result = append(result, v)

	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 main() {
	var a, b int
	fmt.Scan(&a, &b)
	if a*b%2 == 1 {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}


package main

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

func main() {
	stdin := bufio.NewScanner(os.Stdin)
	stdin.Scan()
	text := stdin.Text()
	strs := strings.Fields(text)
	a, err := strconv.Atoi(strs[0])
	if err != nil {
		panic(err)
	}
	b, err := strconv.Atoi(strs[1])
	if err != nil {
		panic(err)
	}
	result := a * b
	if result % 2 == 1 || (result * 3) % 2 == 1 {
		print("Yes")
	} else {
		print("No")
	}
}


package main

import "fmt"

type word struct {
	name string
	sum rune
}

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

	words := make([]word,n)
 	cnt := make(map[rune]bool,n)
	for i := 0; i < n; i++ {
		fmt.Scan(&words[i].name)
		for j := 0; j < len(words[i].name); j++ {
          words[i].sum += rune(words[i].name[j])
		}
      	if cnt[words[i].sum] {
          	fmt.Println("No")
          	return
      	}
      	cnt[words[i].sum] = true
    }
  	fmt.Println("Yes")
}

Score : 200 points

Problem Statement

Takahashi is practicing shiritori alone again today.

Shiritori is a game as follows:

In the first turn, a player announces any one word.

In the subsequent turns, a player announces a word that satisfies the following conditions:

That word is not announced before.

The first character of that word is the same as the last character of the last word announced.

In this game, he is practicing to announce as many words as possible in ten seconds.

You are given the number of words Takahashi announced, N, and the i-th word he announced, W_i, for each i. Determine if the rules of shiritori was observed, that is, every word announced by him satisfied the conditions.

Constraints

N is an integer satisfying 2 \leq N \leq 100.

W_i is a string of length between 1 and 10 (inclusive) consisting of lowercase English letters.

Input

Input is given from Standard Input in the following format:

N
W_1
W_2
:
W_N

Output

If every word announced by Takahashi satisfied the conditions, print Yes; otherwise, print No.

Sample Input 1

4
hoge
english
hoge
enigma

Sample Output 1

No

As hoge is announced multiple times, the rules of shiritori was not observed.

Sample Input 2

9
basic
c
cpp
php
python
nadesico
ocaml
lua
assembly

Sample Output 2

Yes

Sample Input 3

8
a
aa
aaa
aaaa
aaaaa
aaaaaa
aaa
aaaaaaa

Sample Output 3

No

Sample Input 4

3
abc
arc
agc

Sample Output 4

No


package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	N := nextInt()
	Wn := make([]string, N)
	Wnsort := make([]string, N)
	for i := range Wn {
		Wn[i] = nextLine()
	}
	copy(Wnsort, Wn)

	sort.Strings(Wnsort)
	for i := 0; i < N-1; i++ {
		if Wn[i][len(Wn[i])-1] != Wn[i+1][0] || Wnsort[i+1] == Wnsort[i] {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}

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
}


package main
import(
  "fmt"
)
func main(){
  var n, i, j int
  var temp byte
  fmt.Scan(&n)
  a:=make([]string, n)
  for i=0;i<n;i++{
    fmt.Scan(&a[i])
  }
  if n==1{
    fmt.Println("Yes")
    return
  }
  temp=a[0][0]
  for i=0;i<n-1;i++{
    if temp==a[i][0]{
      temp=a[i][len(a[i])-1]
    }else{
      fmt.Println("No")
      return
    }
  }
  for i=0;i<n-1;i++{
    for j=i+1;j<n;j++{
      if a[i]==a[j]{
        fmt.Println("No")
        return
      }
    }
  }
  fmt.Println("Yes")
}


package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	mp := make(map[string]int)
	var word string
	fmt.Scan(&word)
	start := word[len(word) - 1]
	mp[word] = 1
	for i := 0; i < n - 1; i++ {
		fmt.Scan(&word)
		if word[0] != start {
			fmt.Println("No")
			return
		}
		_, ok := mp[word]
		if ok {
			fmt.Println("No")
			return
		}
		start = word[len(word) - 1]
		mp[word] = 1
	}
	fmt.Println("Yes")
}


package main

import "fmt"

func contains(arr []string, str string) bool {
	for _, v := range arr {
		if str == v {
			return true
		}
	}
	return false
}

func main() {
	var n, flag int
	var last_char, tmp string
	fmt.Scan(&n)
	ws := make([]string, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&tmp)
		if contains(ws, tmp) {
			flag = 1
		}
		ws[i] = tmp
	}
	if flag == 1 {
		fmt.Println("No")
		return
	}
	for i, word := range ws {
		if i == 0 {
			last_char = word[(len(word) - 1):]
		} else {
			if word[:1] != last_char {
				fmt.Println("No")
				return
			} else {
				last_char = word[(len(word) - 1):]
			}
		}
	}
	fmt.Println("Yes")
}


package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	ws := make([]string, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&ws[i])
	}
	result := true
	for i := 1; i < n; i++ {
		if ws[i][0] != ws[i-1][len(ws[i-1])-1] {
			result = false
		}
		for j := 0; j < i; j++ {
			if ws[i] == ws[j] {
				result = false
			}
		}
		if result == false {
			break
		}
	}
	if result {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	var num int

	if sc.Scan() {
		num, _ = strconv.Atoi(sc.Text())
	}

	logs := make([]string, num)

	for i := 0; i < num; i++ {
		var text string
		if sc.Scan() {
			text = sc.Text()
		}

		logs[i] = text
	}

	result := true

	for i, log := range logs {
		logCopy := logs
		for j, otherLog := range logCopy {

			// Ignore same word

			if i == j {
				continue
			}

			// Check for same words
			if log == otherLog {
				result = false
				break
			}
		}

		if (i + 1) == len(logs) {
			break
		}

		firstWord := string(log[0])
		lastWord := logCopy[i+1][len(logCopy[i+1])-1:]

		if firstWord == lastWord {
			result = false
			break
		}
	}

	if result {
		fmt.Print("Yes")
	} else {
		fmt.Print("No")
	}
}


package main

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

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

func solve(in io.Reader, out io.Writer) {
	var n int
	fmt.Fscanf(in, "%d", &n)

	m := map[string]int{}
	var w, pre string
	pre = ""

	ans := true

	for i := 0; i < n; i++ {
		fmt.Fscan(in, &w)

		if pre == "" {
			pre = w
			m[w] = 1
			continue
		}

		_, ok := m[w]
		if ok || pre[len(pre)-1] != w[0] {
			ans = false
		}
		pre = w
	}
	if ans {
		fmt.Fprintln(out, "Yes")
	} else {
		fmt.Fprintln(out, "No")
	}
}


package main

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

type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

func (io *Io) Flush() {
	err := io.writer.Flush()
	if err != nil {
		panic(err)
	}
}

func (io *Io) NextLine() string {
	var buffer []byte
	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buffer = append(buffer, line...)
		if !isPrefix {
			break
		}
	}
	return string(buffer)
}

func (io *Io) Next() string {
	for io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}
	r := io.tokens[io.nextToken]
	io.nextToken++
	return r
}

func (io *Io) NextInt() int {
	i, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return i
}

func (io *Io) NextInt64() int64 {
	i, err := strconv.ParseInt(io.Next(), 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func (io *Io) NextFloat() float64 {
	i, err := strconv.ParseFloat(io.Next(), 64)
	if err != nil {
		panic(err)
	}
	return i
}

func (io *Io) PrintLn(a ...interface{}) {
	fmt.Fprintln(io.writer, a...)
}

func (io *Io) Printf(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format, a...)
}

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

func (io *Io) PrintBool(b bool, trueS, falseS string) {
	if b {
		io.PrintLn(trueS)
	} else {
		io.PrintLn(falseS)
	}
}

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

func absi(a int) int {
	if a > 0 {
		return a
	} else {
		return -a
	}
}

func b2i(b bool) int {
	if b {
		return 1
	}
	return 0
}

type Int64s []int64
func (f Int64s) Len() int {
	return len(f)
}
func (f Int64s) Less(i, j int) bool {
	return f[i] < f[j]
}

func (f Int64s) Swap(i, j int) {
	f[i], f[j] = f[j], f[i]
}

func solve(io *Io) {
	n := io.NextInt()

	used := map[string]bool{}
	s := io.Next()
	used[s] = true

	ok := true
	for i := 1; i < n; i++ {
		s2 := io.Next()
		exists := used[s2]
		if exists {
			ok = false
		}
		used[s2] = true

		if s[len(s)-1] != s2[0] {
			ok = false
		}
		s = s2
	}

	io.PrintBool(ok, "Yes", "No")
}

func main() {
	io := NewIo()
	defer io.Flush()

	solve(io)
}


package main

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

const (
	initialBufSize = 100000
	maxBufSize     = 1000000
)

var sc *bufio.Scanner

func initScanner(r io.Reader) *bufio.Scanner {
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords) // bufio.ScanLines
	return sc
}

func main() {
	sc = initScanner(os.Stdin)
	fmt.Println(resolve(parseProblem()))
}

func parseProblem() int {
	n, x := scanInt(sc), scanInt(sc)
	xs := make([]int, n+1)
	for i := 0; i < n; i++ {
		xs[i] = scanInt(sc)
	}
	xs[n] = x
	sort.Sort(sort.IntSlice(xs))
	df := xs[1] - xs[0]
	for i := 1; i < n; i++ {
		v := xs[i+1] - xs[i]
		df = gcd(df, v)
	}
	return df
}

func gcd(a, b int) int {
	for b > 0 {
		t := a / b
		a, b = b, a-t*b
	}
	return a
}

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	a, _ := strconv.Atoi(sc.Text())
	return int(a)
}

func nextString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

func nextIntSlice(sc *bufio.Scanner, n int) (a []int) {

	a = make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt(sc)
	}
	return a
}

func resolve(n int) int {
	return n
}

// snip-scan-funcs
func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return int(i)
}
func scanString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

Score : 300 points

Problem Statement

There are N cities on a number line. The i-th city is located at coordinate x_i.

Your objective is to visit all these cities at least once.

In order to do so, you will first set a positive integer D.

Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:

Move 1: travel from coordinate y to coordinate y + D.

Move 2: travel from coordinate y to coordinate y - D.

Find the maximum value of D that enables you to visit all the cities.

Here, to visit a city is to travel to the coordinate where that city is located.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq X \leq 10^9

1 \leq x_i \leq 10^9

x_i are all different.

x_1, x_2, ..., x_N \neq X

Input

Input is given from Standard Input in the following format:

N X
x_1 x_2 ... x_N

Output

Print the maximum value of D that enables you to visit all the cities.

Sample Input 1

3 3
1 7 11

Sample Output 1

2

Setting D = 2 enables you to visit all the cities as follows, and this is the maximum value of such D.

Perform Move 2 to travel to coordinate 1.

Perform Move 1 to travel to coordinate 3.

Perform Move 1 to travel to coordinate 5.

Perform Move 1 to travel to coordinate 7.

Perform Move 1 to travel to coordinate 9.

Perform Move 1 to travel to coordinate 11.

Sample Input 2

3 81
33 105 57

Sample Output 2

24

Sample Input 3

1 1
1000000000

Sample Output 3

999999999


package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	N := nextInt()
	X := nextInt()
	ans := 0
	for i := 0; i < N; i++ {
		ans = gcdof2numbers(abs(nextInt(), X), ans)
		fmt.Println(ans)

	}
	fmt.Println(ans)
}

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

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

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


package main

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

func main() {
	var n, x int
	s := wordScanner(100)
	scanInts(s, &n, &x)
	l := scanIntSlice(s, n)

	sort.Ints(l)
	d := make([]int, n)
	for i, xi := range l {
		d[i] = abs(x - xi)
	}

	ans := d[0]
	for _, di := range d {
		ans = gcd(ans, di)
	}

	fmt.Println(ans)
}

func gcd(x, y int) int {
	for x%y != 0 {
		x, y = y, x%y
	}
	return y
}

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

func wordScanner(n int) *bufio.Scanner {
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)
	b := make([]byte, n)
	s.Buffer(b, n)
	return s
}

func scanInts(s *bufio.Scanner, vals ...*int) {
	for i := range vals {
		s.Scan()
		n, _ := strconv.Atoi(s.Text())
		*vals[i] = n
	}
}

func scanIntSlice(s *bufio.Scanner, n int) []int {
	vals := make([]int, n)
	for i := range vals {
		s.Scan()
		m, _ := strconv.Atoi(s.Text())
		vals[i] = m
	}
	return vals
}


package main

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

func main() {
	sc := NewScanner()

	n := sc.NextInt()

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

	x[0] = sc.NextInt()

	for i := 1; i <= n; i++ {
		x[i] = sc.NextInt()
	}

	sort.Ints(x)
	//	fmt.Printf("%+v\n", x) // output for debug

	ans := 100000000001
	for i := 1; i < n+1; i++ {
		if x[i]-x[i-1] < ans {
			ans = x[i] - x[i-1]
		}
	}
	fmt.Printf("%v\n", ans)

}

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) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			result = append(result, v)
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	result = append(result, v)

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

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

	var xx = make([]int, n)
	for i := range xx {
		fmt.Scan(&xx[i])
	}
	xx = append(xx, x)
	sort.Ints(xx)
	if x == 1 {
		fmt.Println(xx[1] - x)
		return
	}

	var deff_temp []int
	var deff []int
	var maxD int
	for i := 0; i < n; i++ {
		temp := xx[i] - xx[i+1]
		if temp < 0 {
			deff_temp = append(deff_temp, -temp)
		} else {
			deff_temp = append(deff_temp, temp)
		}
	}
	sort.Ints(deff_temp)
	for i := 0; i < len(deff_temp); i++ {
		if deff_temp[i] != 0 {
			deff = append(deff, deff_temp[i])
		}
	}
	maxD = deff[0]
	for i := 0; i < len(deff); i++ {
		////////////////
		if deff[i]%deff[0] != 0 {
			if deff[0]%2 == 0 && deff[i]%2 == 0 {
				maxD = 2
			} else if deff[0]%3 == 0 && deff[i]%3 == 0 {
				maxD = 3
			} else if deff[0]%5 == 0 && deff[i]%5 == 0 {
				maxD = 5
			}
		}
	}
	fmt.Println(maxD)

}


package main

import (
	"fmt"
	"sort"
)

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

	var xx = make([]int, n)
	for i := range xx {
		fmt.Scan(&xx[i])
	}
	xx = append(xx, x)
	sort.Ints(xx)
	if x == 1 {
		fmt.Println(xx[0] - x)
		return
	}

	var deff []int
	for i := 0; i < n; i++ {
		temp := xx[i] - xx[i+1]
		if temp < 0 {
			deff = append(deff, -temp)
		} else {
			deff = append(deff, temp)
		}
	}
	sort.Ints(deff)
	fmt.Println(deff)
	for i := 0; i < len(deff); i++ {
		if deff[i]%deff[0] != 0 {
			fmt.Println(1)
			return
		}
	}
	fmt.Println(deff[0])

}


package main

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

func NextSlice(n int) []int {
	in := bufio.NewScanner(os.Stdin)
	var mat []int
	in.Scan()
	temp := strings.Split(in.Text(), " ")

	for i := 0; i < n; i++ {
		li, _ := strconv.Atoi(temp[i])
		mat = append(mat, li)
	}
	return mat
}
func main() {
	var n, x int
	fmt.Scan(&n, &x)
	xx := NextSlice(n)

	for i := 0; i < n; i++ {
		if x-xx[i] < 0 {
			xx[i] -= x
		} else {
			xx[i] = x - xx[i]
		}
	}
	sort.Ints(xx)
	for i := 0; i < len(xx); i++ {
		for j := 0; j < len(xx); {
			if xx[j]%xx[i] == 0 {
				j++
			}
			if j == len(xx)-1 {
				fmt.Println(xx[i])
				return
			}
		}
	}
}


// by syu
package main

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

var in = NewScanner(os.Stdin, 0)

func main() {
	N, X := in.Int(), in.Int()
	x := in.ArrayInt(N)
	x = append(x, X)
	sort.Ints(x)
	ans := x[1] - x[0]
	for i := 0; i < len(x)-1; i++ {
		gcd := Gcd(ans, x[i+1]-x[i])
		if gcd < ans {
			ans = gcd
		}
	}
	Pln(ans)
}

type Scanner struct {
	*bufio.Scanner
}

func NewScanner(r io.Reader, max int) *Scanner {
	s := bufio.NewScanner(r)
	s.Split(bufio.ScanWords)
	if max <= 0 {
		max = 1048576
	}
	s.Buffer([]byte{}, max)
	return &Scanner{s}
}
func (s *Scanner) Int() int {
	s.Scan()
	i, e := strconv.ParseInt(s.Text(), 10, 64)
	if e != nil {
		panic(e)
	}
	return int(i)
}
func (s *Scanner) ArrayInt(n int) (r []int) {
	for i := 0; i < n; i++ {
		r = append(r, s.Int())
	}
	return
}
func Pln(s ...interface{}) {
	fmt.Println(s...)
}
func Gcd(a, b int) int {
	t := 0
	for b != 0 {
		t = a % b
		a = b
		b = t
	}
	return a
}


package main

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

// const abcd = "abcdefghijklmnopqrstuvwxyz"
// const ABCD = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
var dr = [...]int{0, 1, 1, 1, 0, -1, -1, -1, 0}
var dc = [...]int{1, 1, 0, -1, -1, -1, 0, 1, 0}

func main() {
	log.SetFlags(log.Lshortfile)
	nextReader = NewScanner()
	N := nextInt()
	X := nextInt()
	x := nextInts(N)
	x = append(x, X)
	sort.Ints(x)
	var m int
	var g int
	for i := 1; i < N+1; i++ {
		m = x[i] - x[i-1]
		if g == 0 {
			g = m
		} else {
			g = gcd(g, m)
		}
	}
	fmt.Println(g)
}

func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	for b != 0 {
		a, b = b, a%b
	}
	return a
}
func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

func max(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}
func min(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r > a[i] {
			r = a[i]
		}
	}
	return r
}
func sum(a []int) (r int) {
	for i := range a {
		r += a[i]
	}
	return r
}
func minmax(a, b int) (int, int) {
	if a > b {
		return b, a
	}
	return a, b
}

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

var nextReader func() string

func NewScanner() func() string {
	r := bufio.NewScanner(os.Stdin)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)
	return func() string {
		r.Scan()
		return r.Text()
	}
}
func nextString() string {
	return nextReader()
}
func nextInt64() int64 {
	v, _ := strconv.ParseInt(nextReader(), 10, 64)
	return v
}
func nextInt() int {
	v, _ := strconv.Atoi(nextReader())
	return v
}
func nextInts(n int) []int {
	r := make([]int, n)
	for i := 0; i < n; i++ {
		r[i] = nextInt()
	}
	return r
}
func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(nextReader(), 64)
	return f
}


package main

import "fmt"

func main() {
	// Code for B - Ringo's Favorite Numbers
	var D, N int
	fmt.Scanf("%d %d", &D, &N)

	if D == 0 {
		if N == 100 {
			fmt.Println(N + 1)
		} else {
			fmt.Println(N)
		}
	} else if D == 1 {
		fmt.Println(N * 100)
	} else {
		fmt.Println(N * 10000)
	}
}

Score: 200 points

Problem Statement

Today, the memorable AtCoder Beginner Contest 100 takes place. On this occasion, Takahashi would like to give an integer to Ringo.

As the name of the contest is AtCoder Beginner Contest 100, Ringo would be happy if he is given a positive integer that can be divided by 100 exactly D times.

Find the N-th smallest integer that would make Ringo happy.

Constraints

D is 0, 1 or 2.

N is an integer between 1 and 100 (inclusive).

Input

Input is given from Standard Input in the following format:

D N

Output

Print the N-th smallest integer that can be divided by 100 exactly D times.

Sample Input 1

0 5

Sample Output 1

5

The integers that can be divided by 100 exactly 0 times (that is, not divisible by 100) are as follows: 1, 2, 3, 4, 5, 6, 7, ...

Thus, the 5-th smallest integer that would make Ringo happy is 5.

Sample Input 2

1 11

Sample Output 2

1100

The integers that can be divided by 100 exactly once are as follows: 100, 200, 300, 400, 500, 600, 700, 800, 900, 1 \ 000, 1 \ 100, ...

Thus, the integer we are seeking is 1 \ 100.

Sample Input 3

2 85

Sample Output 3

850000

The integers that can be divided by 100 exactly twice are as follows: 10 \ 000, 20 \ 000, 30 \ 000, ...

Thus, the integer we are seeking is 850 \ 000.


package main

import "fmt"

func main() {
	// Code for B - Ringo's Favorite Numbers
	var D, N int
	fmt.Scanf("%d %d", &D, &N)

	if D == 0 {
		fmt.Println(N)
	} else if D == 1 {
		fmt.Println(N * 100)
	} else {
		fmt.Println(N * 10000)
	}
}


package main

import (
	"fmt"
)

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

	var ans int
	switch d {
	case 0:
		ans = 1 * n
	case 1:
		ans = 100 * n
	case 2:
		ans = 10000 * n
	}
	fmt.Println(ans)
}


package main

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

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

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

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

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

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

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

func main() {
	sc.Split(bufio.ScanWords)
	D, N := getInt(), getInt()

	x := 1
	for i := 0; i < D; i++ {
		x *= 100
	}

	y := 0
	for i := 0; i < N; i++ {
		y += x
	}

	if x*100 == y {
		y++
	}
	out(y)
}


package main

import (
  "fmt"
)

func pow(args ...int) int {
  x, y := args[0], args[1]
  res := 1
  if len(args) == 3 {
    mod := args[2]
    for y != 0 {
      if y & 1 == 1 {res = res * x % mod}
      y >>= 1
      x = x * x % mod
    }
  }  else {
    for y != 0 {
      if y & 1 == 1 {res *= x}
      y >>= 1
      x *= x
    }
  }
  return res
}

func main() {
  var d, n int
  fmt.Scan(&d, &n)
  if n == 100 {
    fmt.Println(pow(10, d) * 101)
  } else {
    fmt.Println(pow(10, d) * n)
  }

}


package main

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

func main() {
	r := bufio.NewReader(os.Stdin)
	var d, n int
	fmt.Fscan(r, &d)
	fmt.Fscan(r, &n)

	ans := 1
	for i := 1; i <= d; i++ {
		ans *= 100
	}
	ans *= n

	fmt.Println(ans)
}


package main

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

func pow(a, n int) int {
	ret := 1
	for n > 0 {
		if n&1 == 1 {
			ret *= a
		}
		a *= a
		n >>= 1
	}
	return ret
}

func main() {
	sc.Split(bufio.ScanWords)
	d, n := nextInt(), nextInt()
	var ans int
	p := pow(100, d)
	ans = p * n
	puts(ans)
	wt.Flush()
}

var (
	sc = bufio.NewScanner(os.Stdin)
	wt = bufio.NewWriter(os.Stdout)
)

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

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

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}


package main

import "fmt"

func main() {
	var d, n int
	fmt.Scan(&d, &n)
	switch d {
	case 0:
		fmt.Printf("%d", n)
	case 1:
		fmt.Printf("%d", n*100)
	case 2:
		fmt.Printf("%d", n*10000)
	}
}


package main

import (
  "fmt"
  "math"
)

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

  fmt.Println(math.Pow(100, d) * n)
}


package main

import "fmt"

func main() {
	var d int
	var n int
	var ans int

	fmt.Scan(&d, &n)

	switch d {
	case 0:
		ans = n
	case 1:
		ans = n * 100
	case 2:
		ans = n * 100 * 100
	}

	fmt.Println(ans)
}


package main

import "fmt"

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

	if d == 0 {
		if n == 100 {
			fmt.Println(n - 1)
		} else {
			fmt.Println(n)
		}
	} else if d == 1 {
		fmt.Println(n * 100)
	} else if d == 2 {
		fmt.Println(n * 10000)
	}
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var D, N int
	fmt.Scan(&D, &N)
	if N <= 99 {
		fmt.Println(math.Pow(100, float64(D)) * float64(N))
	} else {
		fmt.Println(math.Pow(100, float64(D)) * float64(101))
	}
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var D, N int
	fmt.Scan(&D, &N)
	if D == 0 {
		fmt.Println(N)
	} else {
		fmt.Println(math.Pow(100, float64(D)) * float64(N))
	}
}


package main

import (
  "fmt"
)

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  if a == 0 {
    if b == 100 {
      fmt.Println(b+1)
    } else {
      fmt.Println(b)
    }
  } else if a == 1 {
    res := 100 * b
    if b == 100 {
      fmt.Println(res+100)
    } else {
      fmt.Println(res)
    }
  } else {
    res := 100 * 100 * b
    if b == 100 {
      fmt.Println(res+10000)
    } else {
      fmt.Println(res)
    }
  }
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var d, n float64
	fmt.Scan(&d, &n)
	fmt.Println(int(math.Pow(100, d) * n))
}


package main

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

func main() {
	var sc = bufio.NewScanner(os.Stdin)
	sc.Scan()
	s := strings.Split(sc.Text(), " ")
	D, _ := strconv.Atoi(s[0])
	N, _ := strconv.Atoi(s[1])
	a := 0
	switch D {
	case 0:
		if N != 100 {
			a = N
		}else{
			a = N+1
		}
	case 1:
		if N != 100 {
			a = N * 100
		}else{
			a = (N+1) * 100
		}
	case 2:
		if N != 100 {
			a = N * (100 * 100)
		}else{
			a = (N+1) * (100 * 100)
		}

	}
	fmt.Print(a)
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b, e int
	var c int = 100
	fmt.Scan(&a, &b)
	c = int(math.Pow(float64(c), float64(a)))
	e = c
	for i := a; i <= b; i++ {
		c += e
	}
	fmt.Println(c)
}


package main

import "fmt"

func main() {
    var d, n int
    fmt.Scanln(&d, &n)
    if d == 0 {
        fmt.Printf("%d\n", n * 1)
    } else if d == 1 {
        fmt.Printf("%d\n", n * 100)
    } else if d == 2 {
        fmt.Printf("%d\n", n * 10000)
    } else {
        fmt.Printf(":(\n")
    }
}


package main

import "fmt"

func main() {

	var a, b, c, x int
	fmt.Scan(&a, &b, &c, &x)

	var ans int
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {

				if i*500+j*100+k*50 == x {
					ans++
				}
			}
		}
	}
	fmt.Print(ans)
}

Score : 200 points

Problem Statement

You have A 500-yen coins, B 100-yen coins and C 50-yen coins (yen is the currency of Japan).
In how many ways can we select some of these coins so that they are X yen in total?

Coins of the same kind cannot be distinguished. Two ways to select coins are distinguished when, for some kind of coin, the numbers of that coin are different.

Constraints

0 \leq A, B, C \leq 50

A + B + C \geq 1

50 \leq X \leq 20 000

A, B and C are integers.

X is a multiple of 50.

Input

Input is given from Standard Input in the following format:

A
B
C
X

Output

Print the number of ways to select coins.

Sample Input 1

2
2
2
100

Sample Output 1

2

There are two ways to satisfy the condition:

Select zero 500-yen coins, one 100-yen coin and zero 50-yen coins.

Select zero 500-yen coins, zero 100-yen coins and two 50-yen coins.

Sample Input 2

5
1
0
150

Sample Output 2

0

Note that the total must be exactly X yen.

Sample Input 3

30
40
50
6000

Sample Output 3

213


package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func main() {
  var a,b,c,x int

  sc.Split(bufio.ScanWords)
  a = nextInt() // 500
  b = nextInt() // 100
  c = nextInt() // 50
  x = nextInt()

  cnt:=0

  var i_max, j_max, k_max int

  if a > x/500 {
    i_max = x/500
  } else {
    i_max = a
  }
  if b > x/100 {
    j_max = x/100
  } else {
    j_max = b
  }
  if c > x/50 {
    k_max = x/50
  } else {
    k_max = c
  }

  // fmt.Print("%d %d %d", i_max, j_max, k_max)

  for i:=0; i<=i_max; i++ {
    for j:=0; j<=j_max; j++ {
      for k:=0; k<=k_max; k++ {
        if i*500+j*100+k*50 == x {
          cnt++
        }
      }
    }
  }

  fmt.Print(cnt)
}


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

func main() {
  sc.Split(bufio.ScanWords)
  a := nextInt()
  b := nextInt()
  c := nextInt()
  x := nextInt()

  count := 0
  for i := 0; i <= a; i++ {
    for j := 0; j <= b; j++ {
      for r := 0; r <= c; r++ {
		  if (i * 500 + j * 100 + r * 50) == x {
			  count++
		  }
      }
    }
  }
  fmt.Println(count)

}

func nextString() (string) {
	sc.Scan()
	v := sc.Text()
	return v
}

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

func nextFloat() (float64) {
	sc.Scan()
	v, e := strconv.ParseFloat(sc.Text(), 64)
    if e != nil { panic(e) }
    return v
}


package main

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

var sc = bufio.NewScanner(os.Stdin)
func next() string{
    sc.Scan()
    return sc.Text()
}

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

func main() {
    var (
        a     int
        b     int
        c     int
        x     int
        count int
    )

    a = nextInt()
    b = nextInt()
    c = nextInt()
    x = nextInt()

    for i := 0; i <= a; i++ {
        for j := 0; j <= b; j++ {
            for k := 0; k <= c; k++ {
                if x == 500*i + 100*j + 50*k {
                    count++
                }
            }
        }
    }

    fmt.Println(count)
}


package main

import (
  "fmt"
)

/**
in
2
2
2
100
 */
func main() {
  var a, b, c, target int
  fmt.Scan(&a, &b, &c, &target)
  cnt := 0
  for i:=0 ; i <= a ; i++ {
    for j:=0 ; j<=b ; j++ {
      for k:=0 ; k<=c ; k++ {
        if i*500 + j*100 + k*50 == target {
          cnt++
        }
      }
    }
  }
  fmt.Println(cnt)
}


package main

import "fmt"

func main() {
	var a, b, c, x int
	fmt.Scan(&a)
	fmt.Scan(&b)
	fmt.Scan(&c)
	fmt.Scan(&x)

	var result int
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for m := 0; m <= c; m++ {
				if i*500+j*100+m*50 == x {
					result++
				}
			}
		}
	}
	fmt.Println(result)
}


package main

import "fmt"

func main() {
	var A, B, C, X, count int
	fmt.Scan(&A, &B, &C, &X)
	for i := 0; i <= A; i++ {
		for j := 0; j <= B; j++ {
			for k := 0; k <= C; k++ {
				if i*500+j*100+k*50 == X {
					count++
				}
			}
		}
	}
	fmt.Println(count)
}


package main

import (
	"fmt"
)

func main() {
	var a,b,c,d int
	fmt.Scan(&a)
	fmt.Scan(&b)
	fmt.Scan(&c)
	fmt.Scan(&d)

	count := 0
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {
				total := 500 * i + 100 * j + 50 * k
				if total == d {
					count++
				}
			}
		}
	}

	fmt.Println(count)
}


package main

import "fmt"

func main() {
	var a, b, c, x, ans int
	fmt.Scan(&a, &b, &c, &x)
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {
				if i*500+j*100+k*50 == x {
					ans++
				}
			}
		}
	}
	fmt.Println(ans)
}


package main

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

var sc = bufio.NewScanner(os.Stdin)
var ReadString func() string
var ReadLine func() string
var ReadInt64 func() int64
var ReadInt func() int
var ReadIntSlice func(int) []int
var ReadInt64Slice func(int) []int64
var GetIntAbs func(int) int
var Atoi func(string) int
var FindMin func([] int) int
var FindMax func([] int) int

func init() {
	ReadString = newReadString()
	ReadLine = readLine
	ReadInt64 = readInt64
	ReadInt = readInt
	ReadIntSlice = readIntSlice
	FindMin = findMin
	FindMax = findMax
}

func main() {
	A := ReadInt()
	B := ReadInt()
	C := ReadInt()
	X := ReadInt()

	var r int
	for a := 0; a < A; a++ {
		for b := 0; b < B; b++ {
			for c := 0; c < C; c++ {
				total := (500 * a) + (100 * b) + (50 * c)
				if total == X {
					r += 1
				}
			}
		}
	}
	fmt.Println(r)
}

/*------ scan ------*/

func newReadString() func() string {
	sc.Buffer(make([]byte, 1024), 2048)
	sc.Split(bufio.ScanWords)
	return func() string {
		if !sc.Scan() {
			panic("scanできなかった")
		}
		return sc.Text()
	}
}

func readLine() string {
	if !sc.Scan() {
		panic("line をscanできなかった")
	}
	return sc.Text()
}

func readInt64() int64 {
	i, err := strconv.ParseInt(ReadString(), 0, 64)
	if err != nil {
		fmt.Println("parseInt失敗")
		panic(err.Error())
	}
	return int64(i)
}

func readInt() int {
	i := ReadInt64()
	return int(i)
}

func readIntSlice(n int) []int {
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		arr[i] = ReadInt()
	}
	return arr
}

func readInt64Slice(n int) []int64 {
	arr := make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = ReadInt64()
	}
	return arr
}

/*------ number util ------*/

func getIntAbs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

func atoi(a string) int {
	i, err := strconv.Atoi(a)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func findMin(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	min := arr[0]
	for _, v := range arr {
		if v < min {
			min = v
		}
	}
	return min
}

func findMax(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	max := arr[0]
	for _, v := range arr {
		if v > max {
			max = v
		}
	}
	return max
}


package main

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

func main() {
	scanner := makeScanner(1024)
	a := eGetInt(scanner)
	b := eGetInt(scanner)
	c := eGetInt(scanner)
	x := eGetInt(scanner)
	count := 0
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {
				sum := i*500 + j*100 + k*50
				if sum == x {
					count++
				}
			}
		}
	}
	fmt.Println(count)
}

////////////////////////////////////////////////////////////////////////////////
// ライブラリ
////////////////////////////////////////////////////////////////////////////////
func makeScanner(maxByte int) *bufio.Scanner {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]uint8, 0, 8192), maxByte)
	return scanner
}
func makeWordScanner() *bufio.Scanner {
	scanner := makeScanner(8192)
	scanner.Split(bufio.ScanWords)
	return scanner
}
func eGetLine(r *bufio.Scanner) string {
	if r.Scan() {
		return r.Text()
	}
	err := r.Err()
	if err != nil {
		log.Fatal(err)
	}
	// EOF
	return ""
}

func eGetInt(r *bufio.Scanner) int {
	line := eGetLine(r)
	return eAtoi(line)
}
func eGetInt64(r *bufio.Scanner) int64 {
	line := eGetLine(r)
	return eAtoInt64(line)
}
func eGetFields(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Fields(line)
}
func eGetInts(r *bufio.Scanner) []int {
	fields := eGetFields(r)
	ints := make([]int, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoi(fields[i])
	}
	return ints
}
func eGetInt64s(r *bufio.Scanner) []int64 {
	fields := eGetFields(r)
	ints := make([]int64, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoInt64(fields[i])
	}
	return ints
}
func eGetChars(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Split(line, "")
}
func eAtoi(s string) int {
	n, err := strconv.Atoi(s)
	if err != nil {
		log.Fatal(err)
	}
	return n
}
func eAtoInt64(s string) int64 {
	n, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		log.Fatal(err)
	}
	return n
}


package main

import (
	"fmt"
	"math"
)

var X, A, B, C, ans int

func main() {
	fmt.Scan(&A, &B, &C, &X)

	for i := 0; i <= A; i++ {
		for j := 0; j <= B; j++ {
			for k := 0; k <= C; k++ {
				if 500*i+100*j+50*k == X {
					ans++
				}
			}
		}
	}
	fmt.Println(ans)

}

/*  ----------------------------------------  */

func combination(x, y int) int {
	return permutation(x, y) / permutation(y, y)
}

func permutation(x, y int) int {
	var ans int = 1
	for i := x - y; 0 < i; i-- {
		ans *= i
	}
	return ans
}

func max(x ...int) int {
	var res int = x[0]
	for i := 1; i < len(x); i++ {
		res = int(math.Max(float64(x[i]), float64(res)))
	}
	return res
}

func min(x ...int) int {
	var res int = x[0]
	for i := 1; i < len(x); i++ {
		res = int(math.Min(float64(x[i]), float64(res)))
	}
	return res
}
func pow(x, y int) int { return int(math.Pow(float64(x), float64(y))) }
func abs(x int) int    { return int(math.Abs(float64(x))) }
func floor(x int) int  { return int(math.Floor(float64(x))) }

type XY struct {
	x int
	y int
}
type SortBy []XY

func (a SortBy) Len() int      { return len(a) }
func (a SortBy) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a SortBy) Less(i, j int) bool {
	if a[i].x == a[j].x {
		return a[i].y > a[j].y
	}
	return a[i].x > a[j].x
}


package main

import(
	"fmt"
)

func main() {
	var (
		fhy, hy, fy, sum, count int
	)
	fmt.Scan(&fhy, &hy, &fy, &sum)
	for i:= 0;i<fhy+1; i++{
		for j:= 0; j<hy+1; j++{
			for k:= 0; k< fy+1; k++ {
				if fhy*500+hy*100+fy*50 ==sum {
					count++
				}
			}
		}
	}
	fmt.Println(count)
}


package main

import "fmt"

func main() {
  var a, b, c, x int
  fmt.Scan(&a, &b, &c, &x)

  var count int
  count = 0
  for i := 0; i <= a; i++ {
    for j := 0; j <= b; j++ {
      for k := 0; k <=c; k++ {
        if x == 500 * a + 100 * b + 50 * c {
        	count++
        }
      }
    }
  }
  fmt.Println(count)
}


package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)
	var b int
	fmt.Scan(&b)
	var c int
	fmt.Scan(&c)
	var x int
	fmt.Scan(&x)
	count := 0
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {
				if 500*i+100*j+50*k == x {
					count++
				}
			}
		}
	}
	fmt.Println(count)
}


// Package main provides
//
// File:  b.go
// Author: ymiyamoto
//
// Created on Tue Jan  1 01:14:02 2019
//
package main

import "fmt"

func main() {
	var A, B, C, X int
	fmt.Scan(&A, &B, &C, &X)
	ans := 0
	for a := 0; a <= A; a++ {
		for b := 0; b <= B; b++ {
			for c := 0; c < C; c++ {
				if 500*a+100*b+50*c == X {
					ans++
				}
			}
		}
	}
	fmt.Println(ans)
}


package main

import "fmt"

func main() {
	var A, B, C, X, cnt int
	fmt.Scan(&A, &B, &C, &X)

	for a := 0; a <= A; a++ {
		for b := 0; b <= B; b++ {
			for c := 0; c <= C; c++ {
				if 500*a+100*b+50*c == X {
					cnt++
				}
			}
		}
	}
	fmt.Println(cnt)
}


package main

import "fmt"

func main() {
	var a, b, c, x int
	fmt.Scanf("%d\n%d\n%d\n%d\n", &a, &b, &c, &x)
	ans := 0
	for i := 0; i <= a; i++ {
		for j := 0; j <= b; j++ {
			for k := 0; k <= c; k++ {
				if i*500+j*100+k*50 == x {
					// fmt.Println("i=", i)
					// fmt.Println("j=", j)
					// fmt.Println("k=", k)
					ans++
				}
			}
		}
	}

	fmt.Println(ans)
}


package main

import (
    "fmt"
)

func main() {
    var a, b int
    fmt.Scan(&a, &b)
    if product := a * b; product%2 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

Score : 100 points

Problem Statement

AtCoDeer the deer found two positive integers, a and b.
Determine whether the product of a and b is even or odd.

Constraints

1 ≤ a,b ≤ 10000

a and b are integers.

Input

Input is given from Standard Input in the following format:

a b

Output

If the product is odd, print Odd; if it is even, print Even.

Sample Input 1

3 4

Sample Output 1

Even

As 3 × 4 = 12 is even, print Even.

Sample Input 2

1 21

Sample Output 2

Odd

As 1 × 21 = 21 is odd, print Odd.


package main

import "fmt"

func main() {
	var s string
	fmt.Scanf("%s", &s)
	cnt := 0
	for _, l := range s {
		if string(l) == "1" {
			cnt++
		}
	}
	fmt.Printf("%d", cnt)
}


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scanf("%d %d", &a, &b)
	if ((a * b) % 2) == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main
import (
    "fmt"
)

func main() {
    var x, y int
    fmt.Scan(&x, &y)
    if z := x * y; z % 2 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}


package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if product := a * b; product%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanf("%d", &a)
	fmt.Scanf("%d", &b)
	result := (a * b) % 2
	if result == 1 {
		fmt.Printf("%s", "Odd")
	} else {
		fmt.Printf("%s", "Even")
	}
}


package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	var product = a * b
	if product%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main

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

func main() {
	if len(os.Args) != 3 {
		fmt.Fprintf(os.Stderr, "Wrong number of arguments.")
		os.Exit(1)
	}

	a, _ := strconv.Atoi(os.Args[1])
	b, _ := strconv.Atoi(os.Args[2])

	if a&b&1 == 1 {
		fmt.Printf("Odd")
	} else {
		fmt.Printf("Even")
	}
}


package main

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

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

func main() {
	a := nextInt()
	b := nextInt()
	defer out.Flush()
	a *= b
	if a%2 == 0 {
		out.WriteString("Even")
	} else {
		out.WriteString("Odd")
	}
	out.Flush()
	fmt.Println()

}
func next() string {
	sc.Scan()
	return sc.Text()
}
func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}


package main

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

// 文字列を1行入力
func StrStdin() (stringReturned string) {
	scanner := bufio.NewScanner(os.Stdin)

	scanner.Scan()
	stringInput := scanner.Text()

	stringReturned = strings.TrimSpace(stringInput)

	return
}

// 整数値を1つ取得
// func IntStdin() (int, error) {
// 	stringInput := StrStdin()
// 	return strconv.Atoi(strings.TrimSpace(stringInput))
// }

// 空白や空文字だけの値を除去したSplit()
func SplitWithoutEmpty(stringTargeted string, delim string) (stringReturned []string) {
	stringSplited := strings.Split(stringTargeted, delim)

	for _, str := range stringSplited {
		if str != "" {
			stringReturned = append(stringReturned, str)
		}
	}

	return
}

// デリミタで分割して文字列スライスを取得
func SplitStrStdin(delim string) (stringReturned []string) {
    // 文字列で1行取得
    stringInput := StrStdin()

    // 空白で分割
    // stringSplited := strings.Split(stringInput, delim)
    stringReturned = SplitWithoutEmpty(stringInput, delim)

    return
}

// デリミタで分割して整数値スライスを取得
func SplitIntStdin(delim string) (intSlices []int, err error) {
	// 文字列スライスを取得
	stringSplited := SplitStrStdin(" ")

	// 整数スライスに保存
	for i := range stringSplited {
		var iparam int
		var errMsg string
		iparam, err = strconv.Atoi(stringSplited[i])

		if err != nil {
			return
		}
		errMsg = catchNumError(iparam, i)
		if errMsg != "" {
			if errMsg := numError(); errMsg != nil {
				log.Fatal(errMsg)
				return
			}
		}
		intSlices = append(intSlices, iparam)

	}

	return
}

// 数値の条件を判定
func catchNumError(num int, index int) (errMsg string) {
	if (index == 0 && num >= 1) || (index == 1 && num < 10000) {
		return
	}else {
		errMsg = "条件満たしてないよ"
		return
	}

}

// 偶数か奇数を判定
func detectEvenOdd(num []int) (msg string) {
	if ((num[0]*num[1]) % 2) == 0 {
		msg = "Even"
		return
	}else {
		msg = "Odd"
		return
	}
}
func numError() error {
	return errors.New("条件満たしてないよ")
}
func main() {
	i, err := SplitIntStdin(" ")
	var msg string
	if err == nil {
		msg = detectEvenOdd(i)
		fmt.Println(msg)
	}
}


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	if product := a * b; product % 2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func getInput() (int, int, error) {
	sc.Split(bufio.ScanWords)
	a := make([]int, 2)
	for i := range a {
		sc.Scan()
		n, err := strconv.Atoi(sc.Text())
		a[i] = n
		if err != nil {
			return 0, 0, err
		}
	}
	return a[0], a[1], nil
}

func main() {

	a, b, err := getInput()
	if err != nil {
		fmt.Printf("error: %s\n", err)
		return
	}

	if (a*b)&0x00000001 == 1 {
		fmt.Println("Odd")
		return
	}

	fmt.Println("Even")

}


package main

import (
  "fmt"
)

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  if product := a * b; product % 2 == 0 {
    fmt.Println("Even")
  } else {
    fmt.Println("Odd")
  }
}


package main

import (
	"fmt"
)

func main() {
	var a, b int

	fmt.Scanf("%d %d", &a, &b)

	switch a*b%2{
	case 0:
		fmt.Println("Even")
	case 1:
		fmt.Println("Odd")
	}
}


package main

import (
    "fmt"
)

func main() {

    var a, b int
    ans := "Odd"

    fmt.Scan(&a, &b)

  if (a * b) % 2 == 0 {
        ans = "Even"
    }
    fmt.Println(ans)
}


package main
import (
    "fmt"
)

func main() {

var a,b int
fmt.Scan(&a, &b)
    an := a * b
    if an % 2 == 1{
        fmt.Println("Odd")
    } else {
        fmt.Println("Even")
    }
}


package main

import (
  "fmt"
)

func main() {
  a := 0
  b := 0
  fmt.Scan(&a)
  fmt.Scan(&b)
  if a * b % 2 == 0 {
    fmt.Println("Even")
  } else {
    fmt.Println("Odd")
  }
}


package main

import "fmt"

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  if a*b%2 == 0 {
    fmt.Println("Even")
    return
  }
  fmt.Println("Odd")
}


package main

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

/*
var rdr = bufio.NewReaderSize(os.Stdin, 1000000)
// readLine can read long line string (at least 10^5)
func readLine() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}
// NextLine reads a line text from stdin, and then returns its string.
func NextLine() string {
	return readLine()
}
*/

var sc = bufio.NewScanner(os.Stdin)

// NextLine reads a line text from stdin, and then returns its string.
func NextLine() string {
	sc.Scan()
	return sc.Text()
}

// NextIntsLine reads a line text, that consists of **ONLY INTEGERS DELIMITED BY SPACES**, from stdin.
// And then returns intergers slice.
func NextIntsLine() []int {
	ints := []int{}
	intsStr := NextLine()
	tmp := strings.Split(intsStr, " ")
	for _, s := range tmp {
		integer, _ := strconv.Atoi(s)
		ints = append(ints, integer)
	}
	return ints
}

// NextStringsLine reads a line text, that consists of **STRINGS DELIMITED BY SPACES**, from stdin.
// And then returns strings slice.
func NextStringsLine() []string {
	str := NextLine()
	return strings.Split(str, " ")
}

// NextRunesLine reads a line text, that consists of **ONLY CHARACTERS ARRANGED CONTINUOUSLY**, from stdin.
// Ant then returns runes slice.
func NextRunesLine() []rune {
	return []rune(NextLine())
}

// Max returns the max integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Max(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m < integer {
			m = integer
		}
	}
	return m
}

// Min returns the min integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Min(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m > integer {
			m = integer
		}
	}
	return m
}

// PowInt is integer version of math.Pow
func PowInt(a, e int) int {
	if a < 0 || e < 0 {
		panic(errors.New("[argument error]: PowInt does not accept negative integers"))
	}
	fa := float64(a)
	fe := float64(e)
	fanswer := math.Pow(fa, fe)
	return int(fanswer)
}

// AbsInt is integer version of math.Abs
func AbsInt(a int) int {
	fa := float64(a)
	fanswer := math.Abs(fa)
	return int(fanswer)
}

// DeleteElement returns a *NEW* slice, that have the same and minimum length and capacity.
// DeleteElement makes a new slice by using easy slice literal.
func DeleteElement(s []int, i int) []int {
	if i < 0 || len(s) <= i {
		panic(errors.New("[index error]"))
	}
	// appendのみの実装
	n := make([]int, 0, len(s)-1)
	n = append(n, s[:i]...)
	n = append(n, s[i+1:]...)
	return n
}

// Concat returns a *NEW* slice, that have the same and minimum length and capacity.
func Concat(s, t []rune) []rune {
	n := make([]rune, 0, len(s)+len(t))
	n = append(n, s...)
	n = append(n, t...)
	return n
}

// UpperRune is rune version of `strings.ToUpper()`.
func UpperRune(r rune) rune {
	str := strings.ToUpper(string(r))
	return []rune(str)[0]
}

// LowerRune is rune version of `strings.ToLower()`.
func LowerRune(r rune) rune {
	str := strings.ToLower(string(r))
	return []rune(str)[0]
}

// ToggleRune returns a upper case if an input is a lower case, v.v.
func ToggleRune(r rune) rune {
	var str string
	if 'a' <= r && r <= 'z' {
		str = strings.ToUpper(string(r))
	} else if 'A' <= r && r <= 'Z' {
		str = strings.ToLower(string(r))
	} else {
		str = string(r)
	}
	return []rune(str)[0]
}

// ToggleString iteratively calls ToggleRune, and returns the toggled string.
func ToggleString(s string) string {
	inputRunes := []rune(s)
	outputRunes := make([]rune, 0, len(inputRunes))
	for _, r := range inputRunes {
		outputRunes = append(outputRunes, ToggleRune(r))
	}
	return string(outputRunes)
}

// Strtoi is a wrapper of `strconv.Atoi()`.
// If `strconv.Atoi()` returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

// sort package (snippets)
//sort.Sort(sort.IntSlice(s))
//sort.Sort(sort.Reverse(sort.IntSlice(s)))
//sort.Sort(sort.Float64Slice(s))
//sort.Sort(sort.StringSlice(s))

// copy function
//a = []int{0, 1, 2}
//b = make([]int, len(a))
//copy(b, a)

/*******************************************************************/

var a, b int

func main() {
	tmp := NextIntsLine()
	a, b = tmp[0], tmp[1]
	if a*b%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	x := a * b
	if x%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}


package main

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

func main() {
	a := nextInt()
	b := nextInt()

	if (a*b)%2 == 0 {
		fmt.Println("Even")
	} else {
		fmt.Println("Odd")
	}
}

// 以下がテンプレート

var nextReader func() string

func init() {
	nextReader = NewScanner()
}

func NewScanner() func() string {
	r := bufio.NewScanner(os.Stdin)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)
	return func() string {
		r.Scan()
		return r.Text()
	}
}
func nextString() string {
	return nextReader()
}
func nextInt64() int64 {
	v, _ := strconv.ParseInt(nextReader(), 10, 64)
	return v
}
func nextInt() int {
	v, _ := strconv.Atoi(nextReader())
	return v
}
func nextInts(n int) []int {
	r := make([]int, n)
	for i := 0; i < n; i++ {
		r[i] = nextInt()
	}
	return r
}
func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(nextReader(), 64)
	return f
}


package main

import (
	"os"
	"bufio"
)

func main()  {

	r := bufio.NewReader(os.Stdin)
	a, _ := r.ReadByte()
	b, _ := r.ReadByte()

	if a * b % 2 == 0 {
		println("Even")
	} else{
		println("Odd")
	}

}


package main

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

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

	num1str, err := stdin.ReadString([]byte(" ")[0])
	num1, err := strconv.Atoi(num1str)
	if err != nil {
		panic(err)
	}
	num2str, err := stdin.ReadString([]byte(" ")[0])
	num2, err := strconv.Atoi(num2str)
	if err != nil {
		panic(err)
	}
	if ((num1 % 2) * (num2 % 2)) == 1 {
		fmt.Println("Odd")
	} else {
		fmt.Println("Even")
	}
}


package main
import (
    "fmt"
)

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

    if (a*b) % 2 == 0 {
        fmt.Print("Even")
    } else{
        fmt.Print("Odd")
    }

}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	sc.Scan()
	a, err := strconv.Atoi(sc.Text())
	if err != nil {
		fmt.Println(err)
	}
	return a
}

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

	N := scanInt()
	Y := scanInt()

	for a := 0; a <= N; a++ {
		for b := 0; b+a <= N; b++ {
			total := 10000*a + 5000*b + 1000*(N-a-b)
			if total == Y {
				fmt.Println(a, b, N-a-b)
				return
			}
		}
	}
	fmt.Println(-1, -1, -1)
}

Score : 300 points

Problem Statement

The commonly used bills in Japan are 10000-yen, 5000-yen and 1000-yen bills. Below, the word "bill" refers to only these.

According to Aohashi, he received an otoshidama (New Year money gift) envelope from his grandfather that contained N bills for a total of Y yen, but he may be lying. Determine whether such a situation is possible, and if it is, find a possible set of bills contained in the envelope. Assume that his grandfather is rich enough, and the envelope was large enough.

Constraints

1 ≤ N ≤ 2000

1000 ≤ Y ≤ 2 × 10^7

N is an integer.

Y is a multiple of 1000.

Input

Input is given from Standard Input in the following format:

N Y

Output

If the total value of N bills cannot be Y yen, print -1 -1 -1.

If the total value of N bills can be Y yen, let one such set of bills be "x 10000-yen bills, y 5000-yen bills and z 1000-yen bills", and print x, y, z with spaces in between. If there are multiple possibilities, any of them may be printed.

Sample Input 1

9 45000

Sample Output 1

4 0 5

If the envelope contained 4 10000-yen bills and 5 1000-yen bills, he had 9 bills and 45000 yen in total. It is also possible that the envelope contained 9 5000-yen bills, so the output 0 9 0 is also correct.

Sample Input 2

20 196000

Sample Output 2

-1 -1 -1

When the envelope contained 20 bills in total, the total value would be 200000 yen if all the bills were 10000-yen bills, and would be at most 195000 yen otherwise, so it would never be 196000 yen.

Sample Input 3

1000 1234000

Sample Output 3

14 27 959

There are also many other possibilities.

Sample Input 4

2000 20000000

Sample Output 4

2000 0 0


package main

import (
	"fmt"
)

func main() {
	var n, y int

	fmt.Scan(&n, &y)
	for i := 0; i <= n; i++ {
		for j := 0; j <= (n - i); j++ {
			k := n - i - j
			if i*10000+j*5000+k*1000 == y {
				fmt.Println(i, j, k)
				return
			}
		}
	}
	fmt.Println(-1, -1, -1)
}


package main

import "fmt"

func main() {
	var n, y int
	fmt.Scan(&n, &y)
	fmt.Println(calcMoney(n, y))
}

func calcMoney(n int, yen int) (str string) {
	for x := 0; x <= n; x++ {
		for y := 0; y <= n-x; y++ {
			z := n - x - y
			if 0 <= z {
				if yen == 10000*x+5000*y+1000*z {
					return fmt.Sprintf("%d %d %d", x, y, z)
				}
			}
		}
	}
	return "-1 -1 -1"
}


package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	var N, Y int
	fmt.Fscan(reader, &N, &Y)

	for i := N; i >= 0; i-- {
		for j := N - i; j >= 0; j-- {
			total := 10000*i + 5000*j + 1000*(N-i-j)

			if total == Y {
				fmt.Fprintln(writer, i, j, (N - i - j))
				return
			}
		}
	}

	fmt.Fprintln(writer, -1, -1, -1)

}


package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	var N, Y int
	fmt.Fscan(reader, &N, &Y)

	for i := N; i >= 0; i-- {
		for j := N - i; j >= 0; j-- {
			total := 10000*i + 5000*j + 1000*(N-i-j)

			// if total <= Y {
			if total == Y {
				fmt.Fprintln(writer, i, j, (N - i - j))
				// } else {
				// 	fmt.Fprintln(writer, -1, -1, -1)
				return
			}

			// }
		}
	}

	fmt.Fprintln(writer, -1, -1, -1)

}


package main

import "fmt"

func main() {
	var N, sum int
	fmt.Scan(&N, &sum)
	result := [3]int{-1, -1, -1}

BREAK_LABEL:
	for i := 0; i < N; i++ {
		for j := 0; j < N-i; j++ {
			if sum == 10000*i+5000*j+1000*(N-i-j) {
				result[0] = i
				result[1] = j
				result[2] = N - i - j
				break BREAK_LABEL
			}
		}
	}
	fmt.Printf("%d %d %d", result[0], result[1], result[2])
}


package main

import "fmt"

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

	var ans = []int{-1, -1, -1}
	for i := 0; i <= n; i++ {
		for j := 0; j <= n-i; j++ {
			k := n - i - j
			if i*10000+j*5000+k*1000 == y {
				ans[0] = i
				ans[1] = j
				ans[2] = k
			}
		}
	}
	for _, v := range ans {
		fmt.Printf("%v ", v)
	}
	fmt.Println()
}


package main

import "fmt"

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

	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if n < i+j {
				continue
			}

			if y == (10000*i + 5000*j + 1000*(n-(i+j))) {
				fmt.Printf("%d %d %d\n", i, j, n-(i+j))
				return
			}
		}
	}
	fmt.Println("-1 -1 -1")
}


package main

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

type Pair struct {
	p1, p2 interface{}
}

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
)

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

func main() {
	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)

	N, Y := readInt(), readInt()

	// x , y , z
	// x + y + z = N
	// 10000x + 5000y + 1000z = Y
	// 3元連立一次方程式

	hit := false
	for x := 0; x <= N; x++ {
		for y := 0; y <= N; y++ {
			for z := 0; z <= N; z++ {
				if x+y+z > N {
					continue
				}
				ans := 10000*x + 5000*y + 1000*z
				if ans == Y {
					fmt.Println(x, y, z)
					hit = true
					goto end
				}
			}
		}
	}
end:
	if !hit {
		fmt.Println(-1, -1, -1)
	}
}

/*==========================================
 *             Library
 *==========================================*/
func write(s string) {
	writer.WriteString(s)
}

func print() {
	writer.Flush()
}

// scanner.Split(bufio.ScanWords) をコメントアウトしないと使用不可
func readLine() (s string) {
	if scanner.Scan() {
		s = scanner.Text()
	}
	return s
}

func readInt() (read int) {
	scanner.Scan()
	read, err := strconv.Atoi(scanner.Text())
	if err != nil {
		panic(err)
	}
	return
}

func readFloat() (read float64) {
	scanner.Scan()
	read, err := strconv.ParseFloat(scanner.Text(), 64)
	if err != nil {
		panic(err)
	}
	return
}

func readRunes() (read []rune) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, v)
	}
	return
}

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

func readStrings() (read []string) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, string(v))
	}
	return
}

func s2i(s string) int {
	var intVal, e = strconv.Atoi(s)
	if e != nil {
		panic(e)
	}
	return intVal
}

func i2s(i int) string {
	var strVal = strconv.Itoa(i)
	return strVal
}

func s2f(s string) float64 {
	var floatVal, e = strconv.ParseFloat(s, 64)
	if e != nil {
		panic(e)
	}
	return floatVal
}

func sum(i []int) int {
	sum := 0
	for _, val := range i {
		sum += val
	}
	return sum
}

func split(s string) []string {
	return strings.Fields(s)
}

func strAry2intAry(strs []string) []int {
	var ret = make([]int, 0, len(strs))
	for _, str := range strs {
		var intVal, e = strconv.Atoi(string(str))
		if e != nil {
			panic(e)
		}
		ret = append(ret, intVal)
	}
	return ret
}

func intAry2strAry(nums []int) []string {
	var ret = make([]string, 0, len(nums))
	for _, num := range nums {
		var strVal = strconv.Itoa(num)
		ret = append(ret, strVal)
	}
	return ret
}

func ary2str(strs []string) string {
	return strings.Join(strs, " ")
}

func reverse(res []int) []int {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}

func initalize(res []int, init int) {
	if len(res) == 0 {
		return
	}
	res[0] = init
	for i := 0; i < len(res); i++ {
		copy(res[i:], res[:i])
	}
}

//
// func regexpExample() {
//     // Your code here!
//     var str = "13:20"
//     r := regexp.MustCompile(`(\d+):(\d+)`)
//     fmt.Println(r.FindStringSubmatch(str))
// }

// type Country struct {
//     gold int
//     silver int
//     blonze int
// }

// // 複数ソートのサンプル
// func stableSortExample() []Country{
//     var country = []Country {
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:3, blonze:2},
//         {gold:1, silver:3, blonze:3},
//     }
//     sort.SliceStable(country, func(i, j int) bool { return country[i].blonze > country[j].blonze })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].silver > country[j].silver })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].gold > country[j].gold })
//     return country
// }


package main

import (
    "fmt"
    "os"
)

func main() {

    var N, Y int
    fmt.Fscanf(os.Stdin, "%d %d", &N, &Y)

    for a := 0; a <= N; a++ {
        for b := 0; b <= N; b++ {
            if a+b > N {
                break
            }
            remain := Y - a*10000 - b*5000
            if remain < 0 {
                break
            }
            c := remain / 1000
            if a+b+c > N {
                break
            }
            fmt.Printf("%d %d %d\n", a, b, c)
            return
        }
    }
    fmt.Printf("-1 -1 -1\n")
}


package main

import (
	"fmt"
	"strconv"
)

func main() {
	var (
		n      int
		y      int
		result string = "-1 -1 -1"
	)

	fmt.Scan(&n, &y)

	for i := 0; i < n+1; i++ {
		for j := 0; j < n+1-i; j++ {
			for k := 0; k < n+1-i-j; k++ {
				if n != i+j+k {
					continue
				}

				if y == 10000*i+5000*j+1000*k {
					result = strconv.Itoa(i) + " " + strconv.Itoa(j) + " " + strconv.Itoa(k)
				}
			}
		}
	}

	fmt.Println(result)
}


package main

import "fmt"

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

	for i := 0; i <= n; i++ {
		for j := 0; i+j <= n; j++ {
			if 10000*i+5000*j+1000*(n-i-j) == y {
				fmt.Println(i, j, (n - i - j))
				return
			}
		}
	}
	fmt.Println(-1, -1, -1)
}


package main

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

func main() {
	n, y := getInt(), getInt()

	ans := [3]int{-1, -1, -1}
	for i := 0; i <= n; i++ {
		for j := 0; j <= n-i; j++ {
			k := (n - i - j)
			yen10000, yen5000, yen1000 := i*10000, j*5000, k*1000
			cand := yen10000 + yen5000 + yen1000

			if y == cand {
				ans = [3]int{i, j, k}
			}
		}
	}

	fmt.Println(ans[0], ans[1], ans[2])
}

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

var sc = bufio.NewScanner(os.Stdin)

func init() {
	// buf := 200001
	// sc.Buffer(make([]byte, buf), buf)
	sc.Split(bufio.ScanWords)
}

func getInt() int {
	i, err := strconv.Atoi(getString())
	if err != nil {
		panic(err)
	}
	return i
}

func getString() string {
	sc.Scan()
	s := sc.Text()
	return s
}


package main

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

var stdin = bufio.NewScanner(os.Stdin)

func main() {
	arr := scanArrayInt()
	n, y := arr[0], arr[1]
	ret := []int{-1, -1, -1}
	for y10000 := 0; y10000 <= n; y10000++ {
		for y5000 := 0; y5000 <= n; y5000++ {
			y1000 := n - y10000 + y5000
			t := y10000*10000 + y5000*5000 + y1000*1000
			if t == y {
				ret = []int{y10000, y5000, y1000}
			}
		}
	}
	fmt.Println(ret[0], ret[1], ret[2])
}
func scanArrayInt() []int {
	var ret = []int{}
	stdin.Scan()
	for _, s := range strings.Split(stdin.Text(), " ") {
		i, _ := strconv.Atoi(s)
		ret = append(ret, i)
	}
	return ret
}


package main

import (
	"fmt"
)

func main() {
	var n, y int
	fmt.Scan(&n, &y)
	y /= 1000
	for i := 0; i <= n; i++ {
		if i*10 > y {
			break
		}
		for j := 0; j <= n-i; j++ {
			k := n - i - j
			if i*10+j*5+k == y {
				fmt.Println(i, j, k)
				return
			}
		}
	}
	fmt.Println(-1, -1, -1)
}


package main

import (
	"fmt"
)

func main() {
	var n, y int
	fmt.Scan(&n, &y)
	for i := 0; i <= n; i++ {
		for j := 0; j <= n-i; j++ {
			k := (y - i*10000 + j*5000) / 1000
			if i+j+k == n {
				fmt.Println(i, j, k)
				return
			}
		}
	}
	fmt.Println(-1, -1, -1)
}