package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	re := regexp.MustCompile(`\r?\n`)
	if garland, err := reader.ReadString('\n'); err != nil {
		if err != io.EOF {
			return
		}
	} else {
		garland = re.ReplaceAllString(garland, "")

		needs := make([]int, 4)
		color_idx := make([]int, 4) // Index of RBYG

		for i := 0; i < len(garland); i++ {
			k := i % 4
			if 'R' == garland[i] {
				color_idx[0] = k
			} else if 'B' == garland[i] {
				color_idx[1] = k
			} else if 'Y' == garland[i] {
				color_idx[2] = k
			} else if 'G' == garland[i] {
				color_idx[3] = k
			} else if '!' == garland[i] {
				needs[k]++
			} else {
				fmt.Println("Error")
				return
			}
		}

		for i := 0; i < 4; i++ {
			fmt.Printf("%d ", needs[color_idx[i]])
		}
		fmt.Println()
	}
}

package main

import (
	"fmt"
	)

func main() {
	var input string
	fmt.Scanln(&input)
	d := map[string]int{
		"R":0,
		"B":1,
		"Y":2,
		"G":3,
	}
	cnt := []int{0, 0, 0, 0}
	mod := []int{-1, -1, -1, -1}
	for i, s := range(input) {
		if string(s) == "!" {
			continue
		}
		x := d[string(s)]
		cnt[x]++
		mod[x] = i % 4
	}
	for i := 0; i < 4; i++ {
		val := len(input) / 4
		if len(input) % 4 > mod[i] {
			val++
		}
		fmt.Printf("%d ", val - cnt[i])
	}
}

package main

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

func solve() {
	str1 := readString()
	a := []byte(str1)
	res := make([]int, 4)
	dfs(a, 0, res)
	for i := 0; i < len(res); i++ {
		if i > 0 {
			fmt.Printf(" %d", res[i])
		} else {
			fmt.Printf("%d", res[i])
		}
	}
	fmt.Println()
}

func dfs(a []byte, pos int, res []int) bool {
	if pos == len(a) {
		return true
	}
	if a[pos] != '!' {
		if dfs(a, pos+1, res) {
			return true
		}
	} else {
		for j, v := range "RBYG" {
			ch := byte(v)
			ok := true
			for j := 0; j < 3; j++ {
				k := pos - j - 1
				if k >= 0 && a[k] == ch {
					ok = false
					break
				}
				k = pos + j + 1
				if k < len(a) && a[k] == ch {
					ok = false
					break
				}
			}
			if ok {
				a[pos] = ch
				if dfs(a, pos+1, res) {
					res[j]++
					return true
				}
				a[pos] = '!'
			}
		}
	}
	return false
}

var scanner *bufio.Scanner

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

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

// IO

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

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

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

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

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

package main
import (
	"fmt"
)

func main() {
	var bulbs string
	fmt.Scanln(&bulbs)

	r, b, y, g := 0, 0, 0, 0

	len_bulbs := len(bulbs)

	for i := 0; i < len_bulbs; i++ {
		if bulbs[i] == '!' {
			for j := i % 4; j < len_bulbs; j = j + 4 {
				c := bulbs[j]
				if c == 'R' {
					r++
					break
				} else if c == 'B' {
					b++
					break
				} else if c == 'Y' {
					y++
					break
				} else if c == 'G' {
					g++
					break
				}
			}
		}
	}

	fmt.Println(r, b, y, g)
}

package main

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

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

	S := io.NextLine()

	dead := make([]int, 4)
	index := make([]int, 256)
	for i, c := range S {
		if c == '!' {
			dead[i % 4]++
		} else {
			index[c] = i % 4
		}
	}
	io.Printf("%d %d %d %d\n", dead[index['R']], dead[index['B']], dead[index['Y']], dead[index['G']])

	io.FlushOutput()
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package main

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

func main() {
	sc := NewScanner()
	S := sc.NextLine()
	color := map[int]rune{}

	for i, v := range S {
		if v == '!' {
			continue
		}
		color[i % 4] = v
	}
	ans := map[rune]int{}

	for i, v := range S {
		if v == '!' {
			ans[color[i % 4]]++
		}
	}
	fmt.Println(ans['R'], ans['B'], ans['Y'], ans['G'])

}

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

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

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

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

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

	return mp
}

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

package main
import (
	"fmt"
)

func main() {
	var bulbs string
	fmt.Scanln(&bulbs)

	r, b, y, g := 0, 0, 0, 0

	len_bulbs := len(bulbs)

	for i := 0; i < len_bulbs; i++ {
		if bulbs[i] == '!' {
			for j := i % 4; j < len_bulbs; j = j + 4 {
				switch bulbs[j] {
					case 'R':
						r++
						break
					case 'B':
						b++
						break
					case 'Y':
						y++
						break
					case 'G':
						g++
						break
				}
			}
		}
	}

	fmt.Println(r, b, y, g)
}


package main

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

// github.com/EndlessCheng/codeforces-go
func CF1183H(_r io.Reader, _w io.Writer) {
	var n int
	var k, ans int64
	var s []byte
	Fscan(bufio.NewReader(_r), &n, &k, &s)
	prev := [26]int{}
	dp := make([][]int64, n+1)
	for i := range dp {
		dp[i] = make([]int64, n+1)
	}
	dp[0][0] = 1
	for i := 1; i <= n; i++ {
		c := s[i-1] - 'a'
		dp[i][0] = 1
		for j := 1; j <= i; j++ {
			dp[i][j] = dp[i-1][j] + dp[i-1][j-1]
			if p := prev[c]; p > 0 {
				dp[i][j] -= dp[p-1][j-1]
			}
		}
		prev[c] = i
	}
	k--
	for l := n - 1; l >= 0; l-- {
		cnt := dp[n][l]
		if cnt > k {
			ans += int64(n-l) * k
			k = 0
			break
		}
		k -= cnt
		ans += int64(n-l) * cnt
	}
	if k > 0 {
		ans = -1
	}
	Fprint(_w, ans)
}

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


package main

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

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

	var n, t, d int
	Fscan(in, &n, &t)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := []int{}
	for i := 0; i < n+10 && t > 0; i++ {
		t--
		cur := len(dp)
		for _, v := range a {
			if p := sort.SearchInts(dp, v+1); p < len(dp) {
				dp[p] = v
			} else {
				dp = append(dp, v)
			}
		}
		d = len(dp) - cur
		cur = len(dp)
	}
	if t == 0 {
		Fprint(out, len(dp))
		return
	}
	Fprintln(out, len(dp)+t*d)
}

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

package main

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

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

	var n, t, d int
	Fscan(in, &n, &t)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := []int{}
	for i := 0; i < 110 && t > 0; i++ {
		t--
		cur := len(dp)
		for _, v := range a {
			if p := sort.SearchInts(dp, v+1); p < len(dp) {
				dp[p] = v
			} else {
				dp = append(dp, v)
			}
		}
		d = len(dp) - cur
		cur = len(dp)
	}
	if t == 0 {
		Fprint(out, len(dp))
		return
	}
	Fprintln(out, len(dp)+t*d)
}

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

package main

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

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

	var n, t, d int
	Fscan(in, &n, &t)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := []int{}
	for i := 0; i < 310 && t > 0; i++ {
		t--
		cur := len(dp)
		for _, v := range a {
			if p := sort.SearchInts(dp, v+1); p < len(dp) {
				dp[p] = v
			} else {
				dp = append(dp, v)
			}
		}
		d = len(dp) - cur
		cur = len(dp)
	}
	if t == 0 {
		Fprint(out, len(dp))
		return
	}
	Fprintln(out, len(dp)+t*d)
}

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

package main

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

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

	var n, t int
	Fscan(in, &n, &t)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := []int{}
	f := func() {
		for _, v := range a {
			if i := sort.SearchInts(dp, v+1); i < len(dp) {
				dp[i] = v
			} else {
				dp = append(dp, v)
			}
		}
	}
	f()
	if t == 1 {
		Fprint(out, len(dp))
		return
	}
	f()
	Fprint(out, len(dp)+t-2)
}

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

package main

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

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

	var n, t, d int
	Fscan(in, &n, &t)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := []int{}
	f := func() {
		for _, v := range a {
			if i := sort.SearchInts(dp, v+1); i < len(dp) {
				dp[i] = v
			} else {
				dp = append(dp, v)
			}
		}
	}
	for i := 0; i < 5 && t > 0; i++ {
		t--
		cur := len(dp)
		f()
		d = len(dp) - cur
		cur = len(dp)
	}
	if t == 0 {
		Fprint(out, len(dp))
		return
	}
	Fprintln(out, len(dp)+t*d)
}

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


package main

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

var reader io.Reader
var scanner *bufio.Scanner

func Init(io io.Reader, max_token_size int) {
	reader = bufio.NewReader(io)
	scanner = bufio.NewScanner(reader)
	// max token size
	scanner.Split(bufio.ScanWords)
	scanner.Buffer([]byte{}, max_token_size)
}

func stderr(v ...interface{}) {
	fmt.Fprintln(os.Stderr, v...)
}

func die(v ...interface{}) {
	fmt.Fprintln(os.Stderr, v...)
	os.Exit(1)
}

func NextInt() int {
	bytes := NextBytes()
	i, err := Atoi(bytes)
	if err != nil {
		die(err)
	}
	return i
}
func NextInt64() int64 {
	bytes := NextBytes()
	i, err := Atoi64(bytes)
	if err != nil {
		die(err)
	}
	return i
}

func NextBytes() []byte {
	if !scanner.Scan() {
		die(scanner.Err())
	}
	bytes := scanner.Bytes()
	copied := make([]byte, len(bytes))
	copy(copied, bytes)
	return copied
}

func Atoi(b []byte) (int, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	n := 0
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

func Atoi64(b []byte) (int64, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	var n int64
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int64(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

func ExtendByteArray(a []byte, size int) []byte {
	if size <= len(a) {
		return a
	} else {
		return append(a, make([]byte, size-len(a))...)
	}
}

func ExtendIntArray(a []int, size int) []int {
	if size <= len(a) {
		return a
	} else {
		return append(a, make([]int, size-len(a))...)
	}
}

func reverseInts(a []int) {
	for l, r := 0, len(a)-1; l < r; l, r = l+1, r-1 {
		a[l], a[r] = a[r], a[l]
	}
}

func unique(a []int) int {
	newLen := 0
	n := len(a)
	for i := 0; i < n; i++ {
		if newLen == 0 || a[i] != a[newLen-1] {
			a[newLen] = a[i]
			newLen++
		}
	}
	return newLen
}

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

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

func main() {
	inf := os.Stdin
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	// inf, err := os.Open("a.in")
	// if err != nil {
	// 	die(err)
	// }
	// out, err := os.Create("a.out")
	// if err != nil {
	// 	die(err)
	// }
	// defer out.Close()
	Init(inf, 1000010)

	u := NextInt64()
	v := NextInt64()
	MAXP := 63
	MAXC := 100
	a := make([]int, MAXP)
	b := make([]int, MAXP)

	// u = 1000000000000000000
	// v = 1000000000000000000

	for i := 0; i < MAXP; i++ {
		a[i] = int(u & 1)
		b[i] = int(v & 1)
		u >>= 1
		v >>= 1
	}

	dp := make([][]int, MAXP)
	p := make([][][3]int, MAXP)
	for i := 0; i < MAXP; i++ {
		dp[i] = make([]int, MAXC)
		p[i] = make([][3]int, MAXC)
		for j := 0; j < MAXC; j++ {
			dp[i][j] = -1
		}
	}

	MAXINT := 1000000000

	var f func(i, carry int) int
	f = func(i, carry int) int {

		if i == -1 {
			if carry == 0 {
				return 0
			} else {
				return MAXINT
			}
		}

		if dp[i][carry] != -1 {
			return dp[i][carry]
		}

		res := MAXINT
		resk1, resc := -1, -1

		for k1 := 0; k1 < MAXC*2; k1++ {
			if (k1 >> 1) > carry {
				break
			}
			if (k1 & 1) != a[i] {
				continue
			}
			for ncarry := 0; ncarry < MAXC; ncarry++ {
				if ((k1 + ncarry) >> 1) > carry {
					break
				}
				if ((k1+ncarry)>>1) == carry && ((k1+ncarry)&1) == b[i] {
					t := max(k1, f(i-1, ncarry))
					if t < res {
						res = t
						resk1 = k1
						resc = ncarry
					}
				}
			}
		}
		dp[i][carry] = res
		p[i][carry][1] = resk1
		p[i][carry][2] = resc
		return res
	}

	res := f(MAXP-1, 0)
	if res == MAXINT {
		fmt.Fprintln(out, -1)
		return
	}

	fmt.Fprintln(out, res)

	ans := make([]int64, res)

	for i, carry, j := MAXP-1, 0, 0; i >= 0; i-- {
		ncarry := p[i][carry][2]
		k1 := p[i][carry][1]
		for k1 > 0 {
			ans[j] |= (int64(1) << uint(i))
			j++
			if j == res {
				j = 0
			}
			k1--
		}
		carry = ncarry
	}

	for i := 0; i < res; i++ {
		fmt.Fprint(out, ans[i], " ")
	}
}

package main

import "fmt"

func main() {
	var u, v uint64
	fmt.Scanf("%d %d", &u, &v)
	res, found := solve(u, v)
	if !found {
		fmt.Println(-1)
	} else {
		fmt.Println(len(res))
		for i := 0; i < len(res); i++ {
			fmt.Printf("%d ", res[i])
		}
	}
}

func solve(u uint64, v uint64) ([]uint64, bool) {
	if u > v || u&1 != v&1 {
		return nil, false
	}

	if u == 0 && v == 0 {
		return nil, true
	}

	if u == v {
		return []uint64{u}, true
	}

	x := (v - u) >> 1
	// u, x, x is an answer with length 3
	for i := 0; i < 63; i++ {
		if (x>>i)&1 == 1 {
			if (u>>i)&1 == 1 {
				// can' be true
				return []uint64{u, x, x}, true
			}
		}
	}

	return []uint64{u + x, x}, true
}

package main

import (
	"bufio"
	"fmt"
)

func main() {
	var u,v int64
	fmt.Scanf("%d %d\n", &u, &v)
	if u > v {
		fmt.Println(-1)
		return
	}
	if u == v {
		if u == 0 {
			fmt.Println(0)
			return
		} else {
			fmt.Println(1)
			fmt.Println(u)
			return
		}
	}
	if (v - u) % 2 != 0 {
		fmt.Println(-1)
		return
	}
	c1 := u
	c2 := (v - u) / 2
	if (c1 + c2) ^ c2 == u {
		fmt.Println(2)
		fmt.Println(c2, c1+c2)
	} else {
		fmt.Println(3)
		fmt.Println(c2, c2, c1)
	}
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

/*
URL:
https://codeforces.com/problemset/problem/1325/D
*/

package main

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

/********** FAU standard libraries **********/

//fmt.Sprintf("%b\n", 255) 	// binary expression

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

//str := ReadString()
//i := ReadInt()
//X := ReadIntSlice(n)
//S := ReadRuneSlice()
//a := ReadFloat64()
//A := ReadFloat64Slice(n)

//str := ZeroPaddingRuneSlice(num, 32)
//str := PrintIntsLine(X...)

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

const (
	// General purpose
	MOD          = 1000000000 + 7
	ALPHABET_NUM = 26
	INF_INT64    = math.MaxInt64
	INF_BIT60    = 1 << 60
	INF_INT32    = math.MaxInt32
	INF_BIT30    = 1 << 30
	NIL          = -1

	// for dijkstra, prim, and so on
	WHITE = 0
	GRAY  = 1
	BLACK = 2
)

func init() {
	// bufio.ScanWords <---> bufio.ScanLines
	ReadString = newReadString(os.Stdin, bufio.ScanWords)
	stdout = bufio.NewWriter(os.Stdout)
}

var (
	u, v int64
)

func main() {
	u, v = ReadInt64_2()

	if u == v && u == 0 {
		fmt.Println(0)
		return
	}

	if u == v {
		fmt.Println(1)
		fmt.Println(u)
		return
	}

	if u > v {
		fmt.Println(-1)
		return
	}

	if u%2 != v%2 {
		fmt.Println(-1)
		return
	}

	x := (v - u) / 2
	if x&u == 0 {
		fmt.Println(2)
		fmt.Println(u+x, x)
	} else {
		fmt.Println(3)
		fmt.Println(u, x, x)
	}
}

// NthBit returns nth bit value of an argument.
// n starts from 0.
func NthBit(num int64, nth int) int64 {
	return num >> uint(nth) & 1
}

// OnBit returns the integer that has nth ON bit.
// If an argument has nth ON bit, OnBit returns the argument.
func OnBit(num int64, nth int) int64 {
	return num | (1 << uint(nth))
}

// OffBit returns the integer that has nth OFF bit.
// If an argument has nth OFF bit, OffBit returns the argument.
func OffBit(num int64, nth int) int64 {
	return num & ^(1 << uint(nth))
}

// PopCount returns the number of ON bit of an argument.
func PopCount(num int64) int {
	res := 0

	for i := 0; i < 70; i++ {
		if ((num >> uint(i)) & 1) == 1 {
			res++
		}
	}

	return res
}

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

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

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

func newReadString(ior io.Reader, sf bufio.SplitFunc) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+9)) // for Codeforces
	r.Split(sf)

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

// ReadInt returns an integer.
func ReadInt() int {
	return int(readInt64())
}
func ReadInt2() (int, int) {
	return int(readInt64()), int(readInt64())
}
func ReadInt3() (int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64())
}
func ReadInt4() (int, int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64()), int(readInt64())
}

// ReadInt64 returns as integer as int64.
func ReadInt64() int64 {
	return readInt64()
}
func ReadInt64_2() (int64, int64) {
	return readInt64(), readInt64()
}
func ReadInt64_3() (int64, int64, int64) {
	return readInt64(), readInt64(), readInt64()
}
func ReadInt64_4() (int64, int64, int64, int64) {
	return readInt64(), readInt64(), readInt64(), 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
}

// ReadInt64Slice returns as int64 slice that has n integers.
func ReadInt64Slice(n int) []int64 {
	b := make([]int64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt64()
	}
	return b
}

// ReadFloat64 returns an float64.
func ReadFloat64() float64 {
	return float64(readFloat64())
}

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

// ReadFloatSlice returns an float64 slice that has n float64.
func ReadFloat64Slice(n int) []float64 {
	b := make([]float64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadFloat64()
	}
	return b
}

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

/*********** Debugging ***********/

// ZeroPaddingRuneSlice returns binary expressions of integer n with zero padding.
// For debugging use.
func ZeroPaddingRuneSlice(n, digitsNum int) []rune {
	sn := fmt.Sprintf("%b", n)

	residualLength := digitsNum - len(sn)
	if residualLength <= 0 {
		return []rune(sn)
	}

	zeros := make([]rune, residualLength)
	for i := 0; i < len(zeros); i++ {
		zeros[i] = '0'
	}

	res := []rune{}
	res = append(res, zeros...)
	res = append(res, []rune(sn)...)

	return res
}

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

// PrintIntsLine returns integers string delimited by a space.
func PrintIntsLine(A ...int) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.Itoa(A[i])
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintIntsLine returns integers string delimited by a space.
func PrintInts64Line(A ...int64) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.FormatInt(A[i], 10) // 64bit int version
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintfDebug is wrapper of fmt.Fprintf(os.Stderr, format, a...)
func PrintfDebug(format string, a ...interface{}) {
	fmt.Fprintf(os.Stderr, format, a...)
}

// PrintfBufStdout is function for output strings to buffered os.Stdout.
// You may have to call stdout.Flush() finally.
func PrintfBufStdout(format string, a ...interface{}) {
	fmt.Fprintf(stdout, format, a...)
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var u, v int64
	var a [4]int64
	var times int
	var ll1 int64 = 1
	var out string
	fmt.Scan(&u)
	fmt.Scan(&v)
	//u = 0
	//v = 0

	if u > v || ((u ^ v) & 1) != 0 {
		fmt.Println(-1)
		return
	}

	for i := 0; i < 63; i++ {
		times = 0
		if (u & (ll1 << i)) != 0 {
			times += 1
			u ^= ll1 << i
			v -= ll1 << i
		}
		if (u & (ll1 << (i + 1))) != (v & (ll1 << (i + 1))) {
			times += 2
			v -= ll1 << (i + 1)
		}

		for j := 0; j < times; j++ {
			a[j] ^= ll1 << i
		}
	}

	for i := 0; i < 4; i++ {
		if a[i] == 0 {
			out = strconv.Itoa(i) + "\n" + out
			break
		}
		out += fmt.Sprintf("%v ", a[i])
	}
	fmt.Println(out)

	return
}

package main

import (
	"fmt"
)

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

	if !can(u, v) {
		fmt.Println("-1")
		return
	}

	if u == 0 && v == 0 {
		fmt.Println("0")
		return
	}

	d := v - u
	comp := d / 2

	if comp == 0 {
		fmt.Println("1")
		fmt.Println(u)
	} else if (u & comp) == 0 {
		fmt.Println("2")
		fmt.Printf("%d %d\n", u|comp, comp)
	} else {
		fmt.Println("3")
		fmt.Printf("%d %d %d\n", u, comp, comp)
	}
}

func can(u, v uint64) bool {
	if (u > v) || ((v-u)%2) == 1 {
		return false
	}
	return true
}

package main

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

// github.com/EndlessCheng/codeforces-go
func CF1325D(in io.Reader, out io.Writer) {
	var xor, sum int64
	Fscan(in, &xor, &sum)
	if xor > sum || (sum-xor)&1 > 0 {
		Fprint(out, -1)
	} else if xor == sum {
		if xor == 0 {
			Fprint(out, 0)
		} else {
			Fprint(out, "1\n", xor)
		}
	} else if and := (sum - xor) / 2; and&xor > 0 {
		Fprint(out, "3\n", xor, and, and)
	} else {
		Fprint(out, "2\n", xor|and, and)
	}
}

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

package main

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

type BufferedWriter interface {
    Printf(format string, a ...interface{})
    Flush()
}

type writerImpl struct {
    *bufio.Writer
}

func NewBufferedWriter(writer io.Writer) BufferedWriter {
    return &writerImpl{Writer: bufio.NewWriter(writer)}
}

func (impl *writerImpl) Printf(f string, a ...interface{}) {
    fmt.Fprintf(impl.Writer, f, a...)
}

func (impl *writerImpl) Flush() {
    impl.Writer.Flush()
}

type WordScanner interface {
    NextInt() int
    NextInt64() int64
    NextString() string
}

type wordScannerImpl struct {
    *bufio.Scanner
}

func NewWordScanner(reader io.Reader) WordScanner {
    s := bufio.NewScanner(reader)
    s.Split(bufio.ScanWords)
    return &wordScannerImpl{Scanner: s}
}

func (impl *wordScannerImpl) NextInt() int {
    impl.Scan()
    bb := impl.Bytes()
    i := 0
    for _, b := range bb {
        i *= 10
        i += int(b - '0')
    }
    return i
}

func (impl *wordScannerImpl) NextInt64() int64 {
    impl.Scan()
    bb := impl.Bytes()
    i := int64(0)
    for _, b := range bb {
        i *= 10
        i += int64(b - '0')
    }
    return i
}

func (impl *wordScannerImpl) NextString() string {
    impl.Scan()
    return impl.Text()
}

var reader = NewWordScanner(os.Stdin)
var writer = NewBufferedWriter(os.Stdout)

func main() {
    defer writer.Flush()
    u, v := reader.NextInt64(), reader.NextInt64()
    if u > v {
        writer.Printf("-1\n")
        return
    }
    if u == v {
        if u == 0 {
            writer.Printf("0\n")
        } else {
            writer.Printf("1\n%d\n", u)
        }
        return
    }
    diff := v - u
    if diff % 2 == 1 {
        writer.Printf("-1\n")
        return
    }
    num := diff / 2
    if num & u == 0 {
        writer.Printf("2\n%d %d\n", u | num, num)
    } else {
        writer.Printf("3\n%d %d %d\n", u, num, num)
    }
}

package main

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

var reader io.Reader
var scanner *bufio.Scanner

func Init(io io.Reader, max_token_size int) {
	reader = bufio.NewReader(io)
	scanner = bufio.NewScanner(reader)
	// max token size
	scanner.Split(bufio.ScanWords)
	scanner.Buffer([]byte{}, max_token_size)
}

func stderr(v ...interface{}) {
	fmt.Fprintln(os.Stderr, v...)
}

func die(v ...interface{}) {
	fmt.Fprintln(os.Stderr, v...)
	os.Exit(1)
}

func NextInt() int {
	bytes := NextBytes()
	i, err := Atoi(bytes)
	if err != nil {
		die(err)
	}
	return i
}
func NextInt64() int64 {
	bytes := NextBytes()
	i, err := Atoi64(bytes)
	if err != nil {
		die(err)
	}
	return i
}

func NextBytes() []byte {
	if !scanner.Scan() {
		die(scanner.Err())
	}
	bytes := scanner.Bytes()
	copied := make([]byte, len(bytes))
	copy(copied, bytes)
	return copied
}

func Atoi(b []byte) (int, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	n := 0
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

func Atoi64(b []byte) (int64, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	var n int64
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int64(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

func ExtendByteArray(a []byte, size int) []byte {
	if size <= len(a) {
		return a
	} else {
		return append(a, make([]byte, size-len(a))...)
	}
}

func ExtendIntArray(a []int, size int) []int {
	if size <= len(a) {
		return a
	} else {
		return append(a, make([]int, size-len(a))...)
	}
}

func reverseInts(a []int) {
	for l, r := 0, len(a)-1; l < r; l, r = l+1, r-1 {
		a[l], a[r] = a[r], a[l]
	}
}

func unique(a []int) int {
	newLen := 0
	n := len(a)
	for i := 0; i < n; i++ {
		if newLen == 0 || a[i] != a[newLen-1] {
			a[newLen] = a[i]
			newLen++
		}
	}
	return newLen
}

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

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

func main() {
	inf := os.Stdin
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	// inf, err := os.Open("a.in")
	// if err != nil {
	// 	die(err)
	// }
	// out, err := os.Create("a.out")
	// if err != nil {
	// 	die(err)
	// }
	// defer out.Close()
	Init(inf, 1000010)

	u := NextInt64()
	v := NextInt64()
	MAXP := 63
	MAXC := 4
	a := make([]int, MAXP)
	b := make([]int, MAXP)

	for i := 0; i < MAXP; i++ {
		a[i] = int(u & 1)
		b[i] = int(v & 1)
		u >>= 1
		v >>= 1
	}

	dp := make([][]int, MAXP)
	p := make([][][3]int, MAXP)
	for i := 0; i < MAXP; i++ {
		dp[i] = make([]int, MAXC)
		p[i] = make([][3]int, MAXC)
		for j := 0; j < MAXC; j++ {
			dp[i][j] = -1
		}
	}

	MAXINT := 1000000000

	var f func(i, carry int) int
	f = func(i, carry int) int {

		if i == -1 {
			if carry == 0 {
				return 0
			} else {
				return MAXINT
			}
		}

		if dp[i][carry] != -1 {
			return dp[i][carry]
		}

		res := MAXINT
		resk1, resc := -1, -1

		for k1 := 0; k1 < MAXP*2; k1++ {
			if (k1 >> 1) > carry {
				break
			}
			if (k1 & 1) != a[i] {
				continue
			}
			for ncarry := 0; ncarry < MAXC; ncarry++ {
				if ((k1 + ncarry) >> 1) > carry {
					break
				}
				if ((k1+ncarry)>>1) == carry && ((k1+ncarry)&1) == b[i] {
					t := max(k1, f(i-1, ncarry))
					if t < res {
						res = t
						resk1 = k1
						resc = ncarry
					}
				}
			}
		}
		dp[i][carry] = res
		p[i][carry][1] = resk1
		p[i][carry][2] = resc
		return res
	}

	res := f(MAXP-1, 0)
	if res == MAXINT {
		fmt.Fprintln(out, -1)
		return
	}

	fmt.Fprintln(out, res)

	ans := make([]int, res)

	for i, carry, j := MAXP-1, 0, 0; i >= 0; i-- {
		ncarry := p[i][carry][2]
		k1 := p[i][carry][1]
		for k1 > 0 {
			ans[j] |= (1 << uint(i))
			j++
			if j == res {
				j = 0
			}
			k1--
		}
		carry = ncarry
	}

	for i := 0; i < res; i++ {
		fmt.Fprint(out, ans[i], " ")
	}
}

package main

import (
	"bufio"
	"fmt"
)

func main() {
	var u,v int64
	fmt.Scanf("%d %d\n", &u, &v)
	if u > v {
		fmt.Println(-1)
		return
	}
	if u == v {
		if u == 0 {
			fmt.Println(0)
			return
		} else {
			fmt.Println(1)
			fmt.Println(u)
		}
	}
	if (v - u) % 2 != 0 {
		fmt.Println(-1)
		return
	}
	c1 := u
	c2 := (v - u) / 2
	if (c1 + c2) ^ c2 == u {
		fmt.Println(2)
		fmt.Println(c2, c1+c2)
	} else {
		fmt.Println(3)
		fmt.Println(c1, c2, c2)
	}
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

import (
	"fmt"
	"log"
)

func main() {
	var u, v int64
	var a []int64
	var ll1 int64 = 1
	fmt.Scan(&u)
	fmt.Scan(&v)

	if u > v || ((u ^ v) & 1) != 0 {
		fmt.Println(-1)
		return
	}
	if u == 0 && v == 0 {
		fmt.Println(0)
		return
	}

	for i := 0; i < 63; i++ {
		log.Printf("%v %v", u, v)
		if (u & (ll1 << i)) != 0 {
			a = append(a, ll1 << i)
			u ^= ll1 << i
			v -= ll1 << i
		}
		if (u & (ll1 << (i + 1))) != (v & (ll1 << (i + 1))) {
			a = append(a, ll1 << i)
			a = append(a, ll1 << i)
			v -= ll1 << (i + 1)
		}
	}

	fmt.Println(len(a))
	for i := 0; i < len(a); i++ {
		fmt.Printf("%v ", a[i])
	}

	return
}

package main

import (
	"fmt"
)

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

	if !can(u, v) {
		fmt.Println("-1")
		return
	}

	d := v - u
	comp := uint64(0)
	for i := 0; i <= 64; i++ {
		if d%2 == 1 {
			comp += uint64(1) << uint64(i-1)
		}
		d /= 2
	}

	if comp == 0 {
		fmt.Println("1")
		fmt.Println(u)
	} else if (u & comp) == 0 {
		fmt.Println("2")
		fmt.Printf("%d %d\n", u|comp, comp)
	} else {
		fmt.Println("3")
		fmt.Printf("%d %d %d\n", u, comp, comp)
	}
}

func can(u, v uint64) bool {
	if (u > v) || ((v-u)%2) == 1 {
		return false
	}
	return true
}


package main

import "os"
import "bufio"
import "math"
import "strconv"

func main(){
	var n float64
	r := bufio.NewScanner(os.Stdin)
	r.Split(bufio.ScanWords)
	w := bufio.NewWriter(os.Stdout)
	r.Scan()
	n, _ = strconv.ParseFloat(r.Text(), 64)
	a := (-1+math.Sqrt(8*n-7))/2
	var b float64
	var j int64
	for i:=1; float64(i)<=a; i++ {
		b = (math.Sqrt(1+8*n-4*float64(i)-4*float64(i)*float64(i))-1)/2
		j = int64(b)
		if float64(j) == b && j != 0 {
			w.WriteString("YES\n")
			w.Flush()
			return
		}
	}
	w.WriteString("NO\n")
	w.Flush()
	return
}

package main

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

func scanInt(scanner *bufio.Scanner) int {
  scanner.Scan()
  x, _ := strconv.Atoi(scanner.Text())
  return x
}

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

  triangular := map[int64]bool{}
  k := int64(0)
  for {
    k++
    x := k*(k+1)/2
    if x > 1000000000 {
      break
    }
    triangular[x] = true
  }

  n := int64(scanInt(scanner))
  for x := range triangular {
    _, found := triangular[n-x]
    if found {
      writer.WriteString("YES\n")
      return
    }
  }
  writer.WriteString("NO\n")
}

// 192A-ahalim,dikai,eric
package main

import (
	"fmt"
	"math"
)

func main() {
	var i,n,m,k,l,p int64
	fmt.Scan(&n)
	if n==1 {
		fmt.Println("NO")
		return
	}
	l = int64(math.Sqrt(float64(n*2)))
	m = 0
	for i=1;i<=l;i++{
		p = n-i*(i+1)/2
		k = int64((math.Sqrt(float64(8*p+1))-1)/2)
		if k > 0 {
			if k*(k+1)+i*(i+1)== 2*n{
				m =1
				fmt.Println("YES")
				break
			}
		}
	}
	if m == 0{
		fmt.Println("NO")
	}
}

//rextester.com:1.6.2--codeforces.com:1.7.3
package main
import("fmt";"math")
func main(){
    var a float64;fmt.Scan(&a);a*=2;b:=false
    for i:=1;i<int(math.Sqrt(a));i++{
        c:=int(a)-i*i-i;d:=int(math.Sqrt(float64(c)))
        if(d*(d+1)==c){b=true}
    }
    if(b){fmt.Print("YES")}else{fmt.Print("NO")}
}

// 192A
package main

import (
	"fmt"
	"math"
)

func main() {
	var n, i, j float64
	fmt.Scan(&n)
	for i = 1; i*(i+1)/2 <= n; i++ {
		j = math.Sqrt(n*2 - i*(i+1))
		x := int64(j)
		if x > 0 && x*(x+1)+int64(i)*(int64(i)+1) == int64(n)*2 {
			fmt.Print("YES")
			return
		}
	}
	fmt.Print("NO")
	return
}

// 192A-mic
package main

import (
	"fmt"
	"math"
)

func main() {
	var n, i, diff, f, c, sq float64
	flag := false
	fmt.Scan(&n)
	for i = 1; (i * (i + 1)) < 2*n; i++ {
		diff = 2*n - (i * (i + 1))
		sq = math.Sqrt(diff)
		f = math.Floor(sq)
		c = math.Ceil(sq)
		if f != c && f*c == diff {
			flag = true
			break
		}
	}
	if flag {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

// 192A
package main

import (
	"fmt"
	"math"
)

func main() {
	var n, i, j float64
	fmt.Scan(&n)
	for i = 1; i*(i+1)/2 <= n; i++ {
		j = math.Sqrt(n*2 - i*(i+1))
		if j > 0 && j*(j+1)+i*(i+1) == n*2 {
			fmt.Print("YES")
			return
		}
	}
	fmt.Print("NO")
	return
}


package main

import (
	"bufio"
	"os"
	"fmt"
)
var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)
func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{}) { fmt.Fscanf(reader, f, a...) }
func readLine()(string,error) 			{ return reader.ReadString('\n') }

func main() {
	defer writer.Flush()
	var t,s string
	scanf("%s\n%s", &t, &s);
	c := 0
	for _, i := range s {
		if i == '-' {
			if c > 0 {
				c--
			}
		}
		if i == '+' {
			c++
		}
	}
	fmt.Println(c)
}

package main

import "fmt"

func main() {
	var n int32
	var str string
	fmt.Scanf("%d\n",&n)
	fmt.Scanf("%s\n",&str)
	ans:=0
	for _,c:=range str{
		if c=='+'{
			ans++
		}else if c=='-'{
			if ans>0{
				ans--
			}
		}
	}
	fmt.Println(ans)
}

package main

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

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

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

func main() {
	defer writer.Flush()
	var d int
	scanf("%d\n", &d)
	var s string
	scanf("%s", &s)
	sa := []byte(s)
	cur := 0
	for _, c := range sa {
		if c == '-' {
			cur--
		} else {
			cur++
		}
		if cur < 0 {
			cur = 0
		}
	}

	printf("%d", cur)
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var nStr string
	fmt.Scanln(&nStr)
	n, _ := strconv.Atoi(nStr)

	var pattern string
	fmt.Scanln(&pattern)

	ct := 0
	minSeen := 0
	for i := 0; i < n; i++ {
		if pattern[i] == '+' {
			ct++
		} else if pattern[i] == '-' {
			ct--
		}
		if ct < minSeen {
			minSeen = ct
		}
	}
	fmt.Println(ct - minSeen)
}

package main

import (
	"fmt"
)
func main() {
	n := 0
	fmt.Scan(&n)
	s := ""
	fmt.Scan(&s)
	ans := 0
	for _, char := range(s) {
		if char == rune('+') {
			ans = ans + 1
		} else if char == rune('-') {
			if ans != 0 {
				ans = ans - 1
			}
		}
	}
	fmt.Println(ans)
}

package main

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

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

func Solve(n int, s string) int {
	rollingSum := 0
	lowestRollingSum := 0
	for _, elem := range s {
		if string(elem) == "-" {
			rollingSum -= 1
		} else if string(elem) == "+" {
			rollingSum += 1
		}
		lowestRollingSum = min(lowestRollingSum, rollingSum)
	}
	return -1*lowestRollingSum + rollingSum
}

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

	var n int
	var s string
	fmt.Fscanf(reader, "%d\n", &n)
	fmt.Fscanf(reader, "%s\n", &s)
	fmt.Fprintf(writer, "%d\n", Solve(n, s))
}

package main

import (
	"fmt"
)

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

func main(){
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	ans := n
	var i int
	var temp int

	for i = 0 ; i <= 100;i++{
		temp = i
		for _, char := range (s){
			if(char =='+'){
				temp ++
			}
			if(char =='-'){
				temp --
				if(temp <= -1){
				temp = -1
				break;
				}
			}
		}
		if(temp >= 0){
			ans = min(ans,temp)
		}
	}
	fmt.Print(ans)

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

func main()  {
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	ans := 100
	for i := 0 ;i <= 100 ;i ++{
		t := i
		check := true
	for index,_ := range s{
		if(string(s[index]) == "+"){
			t ++
		}else{
				t --;
				if(t <= -1){
				check = false
				break;
				}
		}
	}
	if(check){

		ans = min(t,ans)
	}
	}
	fmt.Print(ans)

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

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

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

func main()  {
	var n int
	fmt.Scan(&n)
	s := ReadStr()
	ans := 0
	for index,_ := range s{
		if(string(s[index]) == "+"){
			ans ++
		}else{
				ans --;
		}

	}
	fmt.Print(max(ans,0))

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

func main()  {
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	var ans int
	for index,_ := range s{
		if(string(s[index]) == "+"){
			ans ++
		}else{
				ans --;
		}

	}
	fmt.Print(max(ans,0))

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

func main()  {
	var n int
	fmt.Scan(&n)
	s := ReadStr()
	ans := 0
	for _,i := range s{
		if(string(i) == "+"){
			ans ++
		}else{
				ans --;
		}

	}
	fmt.Println(max(ans,0))

}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var scanner *bufio.Scanner = bufio.NewScanner(os.Stdin)
func ReadStr() string{
	scanner.Scan()
	return scanner.Text()
}

func ReadInt(x int) (res int)  {
	scanner.Scan()

	n,err := strconv.Atoi(scanner.Text())
	res = n
	if err != nil{
		panic(err)
	}
	return
}

type building struct
{
	a , b ,c int
}

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

func main()  {
	var n int
	fmt.Scan(&n)
	s := ReadStr()
	ans := 100
	for i := 0 ; i <= 100;i++{
		t := i
		yes := true
		for _,i := range s{
			if(string(i) == "-"){
				t --;
				if(t <= -1){
					yes = false
					break;
				}
			}else{
				t ++
			}
		}
		if(yes){
			ans = min(ans,t)
		}
	}
	fmt.Println(ans)

}

package main

import "fmt"

func main() {
	var n int32
	var str string
	fmt.Scanf("%d\n",&n)
	fmt.Scanf("%s\n",&str)
	fmt.Println(n)
	fmt.Println(str)
	ans:=0
	for _,c:=range str{
		if c=='+'{
			ans++
		}else if c=='-'{
			if ans>0{
				ans--
			}
		}
	}
	fmt.Println(ans)
}

package main

import "fmt"

func main() {
	var n int32
	var str string
	fmt.Scanf("%d",&n)
	fmt.Scanf("%s",&str)
	ans:=0
	for _,c:=range str{
		if c=='+'{
			ans++
		}else if c=='-'{
			if ans>0{
				ans--
			}
		}
	}
	fmt.Println(ans)
}

package main

import "fmt"

func main() {
	var n int32
	var str string
	fmt.Scanf("%d",&n)
	fmt.Scanf("%s",&str)
	fmt.Println(n)
	fmt.Println(str)
	ans:=0
	for _,c:=range str{
		if c=='+'{
			ans++
		}else if c=='-'{
			if ans>0{
				ans--
			}
		}
	}
	fmt.Println(ans)
}

package main

import "fmt"

func main() {
	var n int64
	var str string
	fmt.Scanf("%d",&n)
	fmt.Scanf("%s",&str)
	ans:=0
	for _,c:=range str{
		if c=='+'{
			ans++
		}else{
			if ans>0{
				ans--
			}
		}
	}
	fmt.Println(ans)
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	nStr, _ := reader.ReadString('\n')
	nStr = strings.TrimSuffix(nStr, "\n")
	n, _ := strconv.Atoi(nStr)
	pattern, _ := reader.ReadString('\n')

	ct := 0
	minSeen := 0
	for i := 0; i < n; i++ {
		if pattern[i] == '+' {
			ct++
		} else if pattern[i] == '-' {
			ct--
		}
		if minSeen > ct {
			minSeen = ct
		}
	}

	fmt.Println(ct - minSeen)
}

package main

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

func readline(reader *bufio.Reader) string {
	str, _ := reader.ReadString('\n')
	return strings.TrimSuffix(str, "\n")
}

func readInt(reader *bufio.Reader) int {
	str := readline(reader)
	n, _ := strconv.Atoi(str)
	return n
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	n := readInt(reader)
	pattern := readline(reader)

	ct := 0
	minSeen := 0
	for i := 0; i < n; i++ {
		if pattern[i] == '+' {
			ct++
		} else if pattern[i] == '-' {
			ct--
		}
		if ct < minSeen {
			minSeen = ct
		}
	}
	fmt.Println(ct, minSeen)
	fmt.Println(ct - minSeen)
}

package main

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

func readline(reader *bufio.Reader) string {
	str, _ := reader.ReadString('\n')
	return strings.TrimSuffix(str, "\n")
}

func readInt(reader *bufio.Reader) int {
	str := readline(reader)
	n, _ := strconv.Atoi(str)
	return n
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	n := readInt(reader)
	pattern := readline(reader)

	ct := 0
	minSeen := 0
	for i := 0; i < n; i++ {
		if pattern[i] == '+' {
			ct++
		} else if pattern[i] == '-' {
			ct--
		}
		if ct < minSeen {
			minSeen = ct
		}
	}
	fmt.Println(ct - minSeen)
}

package main

import (
	"fmt"
)

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

func main(){
	var n int
	fmt.Scanf("%d",&n)
	var s string
	fmt.Scanf("%s",&s)
	ans := n
	var i , j int
	for i = 0 ; i <= 100;i++{
		temp := i
		for j = 0 ; j < len(s); j ++{
			if(s[j] =='+'){
				temp ++
			}
			if(s[j] =='-'){
				temp --
				if(temp <= -1){
				temp = -1
				break;
				}
			}
		}
		if(temp >= 0){
			ans = min(ans,temp)
		}
	}
	fmt.Print(ans)

}

package main

import (
	"fmt"
)

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

func main(){
	var n int
	fmt.Scanf("%d",&n)
	var s string
	fmt.Scanf("%s",&s)
	ans := 100
	var i , j int
	for i = 0 ; i <= 100;i++{
		temp := i
		for j = 0 ; j < len(s); j ++{
			if(s[j] =='+'){
				temp ++
			}
			if(s[j] =='-'){
				temp --
				if(temp <= -1){
				temp = -1
				}
			}
		}
		if(temp >= 0){
			ans = min(ans,temp)
		}
	}
	fmt.Print(ans)

}

package main

import (
	"fmt"
)

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

func main(){
	var n int
	fmt.Scan(&n)
	var s string
	fmt.Scan(&s)
	ans := n
	var i int
	var temp int

	for i = 0 ; i <= 10;i++{
		temp = i
		for _, char := range (s){
			if(char =='+'){
				temp ++
			}
			if(char =='-'){
				temp --
				if(temp <= -1){
				temp = -1
				break;
				}
			}
		}
		if(temp >= 0){
			ans = min(ans,temp)
		}
	}
	fmt.Print(ans)

}


package main

import "fmt"

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

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

	for passed(a, k) == false {
		a = append(a, k)
	}

	fmt.Printf("%d", len(a)-n)
}

func passed(a []int, k int) bool {
	avg := calcAvg(a)
	if avg+0.5 >= float64(k) {
		return true
	}
	return false
}

func calcAvg(a []int) float64 {
	total := 0
	for _, value := range a {
		total += value
	}
	return float64(total) / float64(len(a))
}

package main

import (
	"fmt"
	"os"
)

var n int
var m int
var tmp int

func main() {
	fmt.Scan(&n)
	fmt.Scan(&m)
	suma := 0
	for i := 0; i < n; i++ {
		fmt.Scan(&tmp)
		suma += tmp
	}

	ansa := 0
	for {
		if float64(m)-float64(suma)/float64((ansa+n)) <= float64(0.5) {
			fmt.Println(ansa)
			os.Exit(0)
		}
		suma += m
		ansa++

	}

}

package main

import "fmt"

func main() {
    var n int
    var k int
    fmt.Scanf("%d %d\n", &n, &k)
    sum := 0
    for i := 0; i < n; i++ {
    	var x int
    	fmt.Scanf("%d", &x)
    	sum += x
    }
    ret := 0
    for 2 * sum < (ret + n) * (2 * k - 1) {
    	/*
    	sum / (ret + n) >= (k - 0.5)
    	2 * sum / (ret + n) >= 2 * k - 1
    	2 * sum >= (ret + n) * (2 * k - 1)
    	*/
    	sum += k
    	ret += 1
    }
    fmt.Printf("%d\n", ret)
}


package main

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

func main() {
	var (
		n, x, y int64
	)

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

	scanner.Scan()
	n, _ = strconv.ParseInt(scanner.Text(), 10, 64)

	scanner.Scan()
	x, _ = strconv.ParseInt(scanner.Text(), 10, 64)

	scanner.Scan()
	y, _ = strconv.ParseInt(scanner.Text(), 10, 64)

	dw := min(abs(x-1), abs(y-1))
	db := min(abs(x-n), abs(y-n))

	if dw <= db {
		fmt.Println("White")
	} else {
		fmt.Println("Black")
	}
}

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

	return -a
}

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

	return b
}

package main

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

var scanner *bufio.Scanner

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

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

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

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

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

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

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

package main

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

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

// IO helper functions

// Returns next token from input.  It must be initialized by SetInput()
// before the first call.
var nextToken func() ([]byte, error)
var nextLine func() ([]byte, error)

// Holds a buffer for output.  It must be initialized by SetOutput().
// All IO fucntions (read*() and [e]print*()) should write to OutputWriter
// instead of this.
var OutputBuffer *bufio.Writer

// Holds an io.Writer.  It must be initialized by SetOutput()
var OutputWriter io.Writer

// Set IO functions for interactive input/output.
func SetInteractive(w io.Writer, r io.Reader) {
	SetUnbefferedInput(r)
	OutputBuffer = nil
	OutputWriter = w
}

// Setup OutputBuffer and OutputWriter.
func SetOutput(w io.Writer) {
	OutputBuffer = bufio.NewWriter(w)
	OutputWriter = OutputBuffer
}

// Flushes OutputBuffer
func Flush() {
	if OutputBuffer != nil {
		OutputBuffer.Flush()
	}
}

// Returns true if c is a white space
func IsSpace(c byte) bool {
	switch c {
	case '\t', '\n', '\v', '\f', '\r', ' ':
		return true
	}
	return false
}

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

// Setup nextToken with input buffer.
func SetInput(r io.Reader) {
	buf := new(bytes.Buffer)
	var b []byte

	var i int
	rest := func() ([]byte, error) {
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		return b[j:i], nil
	}
	initial := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextToken = rest
		return rest()
	}
	nextToken = initial

	restLn := func() ([]byte, error) {
		for i < len(b) && IsNewLine(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsNewLine(b[i]) {
			i++
		}
		return b[j:i], nil
	}

	initialLn := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextLine = restLn
		return restLn()
	}
	nextLine = initialLn
}

// Setup nextToken without input buffer.
func SetUnbefferedInput(r io.Reader) {
	buf := bufio.NewReader(r)
	var b []byte

	var i int
	nextToken = func() ([]byte, error) {
		var err error
		if i == len(b) {
			b, err = buf.ReadBytes('\n')
			if err != nil {
				return nil, err
			}
			i = 0
			j := len(b) - 1
			for 0 <= j && IsSpace(b[j]) {
				j--
			}
			b = b[0 : j+1]
		}
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		if i == j {
			return nil, io.ErrUnexpectedEOF
		}
		return b[j:i], nil
	}
}

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

// IO functions

// Reads next token and return it as []byte
func readb() []byte {
	b, err := nextToken()
	if err != nil {
		panic(err)
	}
	return b
}

// Reads next token and return it as string
func reads() string {
	return string(readb())
}

// Read next line as []byte
func readbln() []byte {
	b, err := nextLine()
	if err != nil {
		panic(err)
	}
	return b
}

// Read next line as string
func readsln() string {
	return string(readbln())
}

// Reads next token and return it as int64
func readll() int64 {
	i, err := strconv.ParseInt(reads(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// Reads next token and return it as int
func readi() int {
	return int(readll())
}

// Reads next token and return it as float64
func readf() float64 {
	f, err := strconv.ParseFloat(reads(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// Write args to OutputWriter with the format f
func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(OutputWriter, f, args...)
}

// Write args to OutputWriter without format
func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(OutputWriter, args...)
}

// Write args to stderr with the format f
func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

// Write args to stderr without format
func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

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

// Simple math functions

const (
	// big prime
	INF  = 1000000007
	INF2 = 1000000009
	INF3 = 998244353
)

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

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

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

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

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

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

// egcd(a, b) returns d, x, y:
//   d is gcd(a,b)
//   x, y are  integers that satisfy ax + by = d
func egcd(a, b int) (int, int, int) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcd(b, a%b)
	return d, y, x - a/b*y
}

func egcdll(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcdll(b, a%b)
	return d, y, x - a/b*y
}

func gcd(a, b int) int {
	d, _, _ := egcd(a, b)
	return d
}

func gcdll(a, b int64) int64 {
	d, _, _ := egcdll(a, b)
	return d
}

// set up IO functions
func init() {
	// for non-interactive
	SetInput(os.Stdin)
	SetOutput(os.Stdout)

	// Enable below when interactive.  Its ok to leave above intact.
	// SetInteractive(os.Stdout, os.Stdin)
}

func main() {
	defer Flush()

	n := readll()
	x := readll()
	y := readll()

	dw := dist(n, 1, 1, x, y)
	db := dist(n, n, n, x, y)

	if dw <= db {
		println("White")
	} else {
		println("Black")
	}

}

func dist(n, sx, sy, gx, gy int64) int64 {
	dx := absll(gx - sx)
	dy := absll(gy - sy)

	return maxll(dx, dy)
}

package main

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

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

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

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

func main() {
	defer writer.Flush()
	var x, y, n, a, b int64
	scanf("%d\n", &n)
	scanf("%d %d\n", &x, &y)

	a = max(x-1, y-1)
	b = max(n-x, n-y)
	if a <= b {
		printf("White\n")
	} else {
		printf("Black")
	}

}

package main

import (
	"fmt"
	"bufio"
	"os"
)
func Abs(x uint64,y uint64)uint64{
	if x>y{
		return x-y
	}
	return y-x
}
func Min(x uint64,y uint64)uint64{
	if x>y{
		return y
	}
	return x
}
type Point struct {
	x uint64
	y uint64
	ans uint64
}

func Slove_White(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y++
			return temp.ans+Abs(y,temp.y)
		}
		if temp.y==y{
			temp.x++
			return temp.ans+Abs(x,temp.x)

		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x+=add
		temp.y+=add
		temp.ans+=add
	}
	return temp.ans
}

func Slove_Block(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y--
			return temp.ans+Abs(x,temp.x)
		}
		if temp.y==y{
			temp.x--
			return temp.ans+Abs(y,temp.y)
		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x-=add
		temp.y-=add
		temp.ans+=add
	}
	return temp.ans
}

var in = bufio.NewReaderSize(os.Stdin, 2<<16)
func main(){
	var n,x,y uint64
	fmt.Fscan(in, &n)

	fmt.Fscan(in, &x, &y)
	white:=Point{x:1,y:1,ans:0}
	white_ans:=Min(Abs(white.x,x),Abs(white.y,y))
	white.x+=white_ans
	white.y+=white_ans
	white_ans+=Abs(white.x,x)
	white_ans+=Abs(white.y,y)

	block:=Point{x:n,y:n,ans:0}
	block_ans:=Min(Abs(block.x,x),Abs(block.y,y))
	block.x-=block_ans
	block.y-=block_ans
	block_ans+=Abs(block.x,x)
	block_ans+=Abs(block.y,y)

	//fmt.Println(white_ans,block_ans)
	if white_ans<=block_ans{
		fmt.Println("White")
	}else{
		fmt.Println("Black")
	}

}

package main

import (
	"fmt"
	"bufio"
	"os"
)
func Abs(x uint64,y uint64)uint64{
	if x>y{
		return x-y
	}
	return y-x
}
func Min(x uint64,y uint64)uint64{
	if x>y{
		return y
	}
	return x
}
type Point struct {
	x uint64
	y uint64
	ans uint64
}

func Slove_White(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y++
			return temp.ans+Abs(y,temp.y)
		}
		if temp.y==y{
			temp.x++
			return temp.ans+Abs(x,temp.x)

		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x+=add
		temp.y+=add
		temp.ans+=add
	}
	return temp.ans
}

func Slove_Block(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y--
			return temp.ans+Abs(x,temp.x)
		}
		if temp.y==y{
			temp.x--
			return temp.ans+Abs(y,temp.y)
		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x-=add
		temp.y-=add
		temp.ans+=add
	}
	return temp.ans
}

var in = bufio.NewReaderSize(os.Stdin, 2<<16)
func main(){
	var n,x,y uint64
	fmt.Fscan(in, &n)

	fmt.Fscan(in, &x, &y)
	white:=Point{x:1,y:1,ans:0}
	white_ans:=Min(Abs(white.x,x),Abs(white.y,y))
	white.x+=white_ans
	white.y+=white_ans
	white_ans+=Abs(white.x,x)
	white_ans+=Abs(white.y,y)

	block:=Point{x:n,y:n,ans:0}
	block_ans:=Min(Abs(block.x,x),Abs(block.y,y))
	block.x+=block_ans
	block.y+=block_ans
	block_ans+=Abs(block.x,x)
	block_ans+=Abs(block.y,y)

	//fmt.Println(white_ans,block_ans)
	if white_ans<=block_ans{
		fmt.Println("White")
	}else{
		fmt.Println("Black")
	}

}

package main

import (
	"fmt"
	"bufio"
	"os"
)
func Abs(x uint64,y uint64)uint64{
	if x>y{
		return x-y
	}
	return y-x
}
func Min(x uint64,y uint64)uint64{
	if x>y{
		return y
	}
	return x
}
type Point struct {
	x uint64
	y uint64
	ans uint64
}

func Slove_White(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y++
			return temp.ans+Abs(y,temp.y)
		}
		if temp.y==y{
			temp.x++
			return temp.ans+Abs(x,temp.x)

		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x+=add
		temp.y+=add
		temp.ans+=add
	}
	return temp.ans
}

func Slove_Block(temp Point,n,x,y uint64)uint64{
	for {
		if temp.x==x&&temp.y==y{
			break
		}
		if temp.x==x{
			temp.y--
			return temp.ans+Abs(x,temp.x)
		}
		if temp.y==y{
			temp.x--
			return temp.ans+Abs(y,temp.y)
		}
		add:=Min(Abs(x,temp.x),Abs(y,temp.y))
		temp.x-=add
		temp.y-=add
		temp.ans+=add
	}
	return temp.ans
}
var in = bufio.NewReaderSize(os.Stdin, 2<<16)
func main(){
	var n,x,y uint64
	fmt.Fscan(in, &n)

	fmt.Fscan(in, &x, &y)
	white:=Point{x:1,y:1,ans:0}
	white_ans:=Slove_White(white,n,x,y)

	block:=Point{x:n,y:n,ans:0}
	block_ans:=Slove_Block(block,n,x,y)

	//fmt.Println(white_ans,block_ans)
	if white_ans<=block_ans{
		fmt.Println("White")
	}else{
		fmt.Println("Black")
	}

}

package main

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

var scanner *bufio.Scanner

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

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

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

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

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

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

	whiteX :=  int64(math.Abs(float64(x - 1)))
	whiteY := int64(math.Abs(float64(y - 1)))
	blackX := int64(math.Abs(float64(n - x)))
	blackY := int64(math.Abs(float64(n - y)))

	if (whiteX + whiteY) <= (blackX + blackY) {
		return "White"
	} else {
		return "Black"
	}
}

package main

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

var scanner *bufio.Scanner

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

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

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

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

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

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

	whiteX :=  int64(math.Abs(float64(1 - x)))
	whiteY := int64(math.Abs(float64(1 - y)))
	blackX := int64(math.Abs(float64(n - x)))
	blackY := int64(math.Abs(float64(n - y)))

	if (whiteX + whiteY) <= (blackX + blackY) {
		return "White"
	} else {
		return "Black"
	}
}

package main

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

var scanner *bufio.Scanner

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

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

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

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

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

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

	whiteX :=  int(math.Abs(float64(1 - x)))
	whiteY := int(math.Abs(float64(1 - y)))
	blackX := int(math.Abs(float64(n - x)))
	blackY := int(math.Abs(float64(n - y)))

	if (whiteX + whiteY) <= (blackX + blackY) {
		return "White"
	} else {
		return "Black"
	}
}

package main

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

func main() {
	var (
		n, x, y int
	)

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

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

	scanner.Scan()
	x, _ = strconv.Atoi(scanner.Text())

	scanner.Scan()
	y, _ = strconv.Atoi(scanner.Text())

	dw := min(abs(x-1), abs(y-1))
	db := min(abs(x-n), abs(y-n))

	if dw <= db {
		fmt.Println("White")
	} else {
		fmt.Println("Black")
	}
}

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

	return -a
}

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

	return b
}


package main

import "fmt"

func main() {
	var n,m int;
	_,_ = fmt.Scanf("%d %d",&n,&m)
	var u = n-m;
	var l = m-1;
	if u==0 && l==0{
		fmt.Println(m)
	}else if(u > l){
		fmt.Println(m+1)
	}else{
		fmt.Println(m-1)
	}
}

package main

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

func I(i ...interface{}) error {
	_, err := fmt.Fscan(r, i...)
	return err
}

func O(o ...interface{}) {
	fmt.Fprint(w, o...)
}

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

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

type Int int64

func main() {
	defer w.Flush()
	var n, m Int
	for I(&n, &m) == nil {
		solve(n, m)
	}
}

func solve(n, m Int) {
	var ans Int
	if n == Int(1) {
		ans = 1
	} else if m-1 >= n-m {
		ans = m - 1
	} else {
		ans = m + 1
	}
	O(ans, "\n")
}

package main

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

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

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

	n, m := nextInt(), nextInt()

	if n == 1 {
		println(1)
		return
	}

	if m-1 < n-m {
		println(m + 1)
	} else {
		println(m - 1)
	}
}

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

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

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

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

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

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

package main

import "fmt"

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

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

func chances(a, m, n int) int {
    cnt := 0
    for c := 1; c <= n; c++ {
        if abs(a - c) < abs(c - m) {
            cnt++
        }
    }
    return cnt
}*/

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

    /*
    best := 1
    best_chances := 0
    for a := 1; a <= n; a++ {
        cnt := chances(a, m, n)
        if cnt > best_chances {
            best = a
            best_chances = cnt
        }
    }
    fmt.Println(best) */

    if n == 1 {
        fmt.Println(1)
    } else if n - m > m - 1 {
        fmt.Println(m + 1)
    } else {
        fmt.Println(m - 1)
    }
}

// salom project main.go
package main

import (
	"fmt";

)

func main() {
	var m,n int64
	fmt.Scan(&n,&m)
	if ( m==1 )&&(n==1) {
	fmt.Print("1")
	return
	}
	m=m*2
	if m>n {
		fmt.Print(m/2-1)
	}else{
		fmt.Print(m/2+1)
	}
}

package main

import "fmt"

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

    a := m - 1
    if a < n - m {
        a = m + 1
    }
    if a == 0 {
        a = m
    }
    fmt.Println(a)
}

package main

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

var N, M int

func main() {
	fsc := NewFastScanner()
	N, M = fsc.NextInt(), fsc.NextInt()
	if N == 1 {
		fmt.Println(1)
		os.Exit(0)
	}
	var left, right int
	left = M - 1
	right = N - M
	// fmt.Println(left, right)
	if right > left {
		fmt.Println(M + 1)
	} else if right <= left {
		fmt.Println(M - 1)
	}

}

//template
type FastScanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewFastScanner() *FastScanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1024)
	return &FastScanner{r: rdr}
}
func (s *FastScanner) 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 *FastScanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *FastScanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *FastScanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *FastScanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *FastScanner) 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 (
        n int
        m int
    )
    fmt.Scan(&n)
    fmt.Scan(&m)

    a := m - 1
    if a < n - m {
        a = m + 1
    }
    fmt.Println(a)
}

package main

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

var N, M int

func main() {
	fsc := NewFastScanner()
	N, M = fsc.NextInt(), fsc.NextInt()
	var left, right int
	left = M - 1
	right = N - M
	fmt.Println(left, right)
	if right > left {
		fmt.Println(M + 1)
	} else if right <= left {
		fmt.Println(M - 1)
	}

}

//template
type FastScanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewFastScanner() *FastScanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1024)
	return &FastScanner{r: rdr}
}
func (s *FastScanner) 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 *FastScanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *FastScanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *FastScanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

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

package main

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

var N, M int

func main() {
	fsc := NewFastScanner()
	N, M = fsc.NextInt(), fsc.NextInt()
	var left, right int
	left = M - 1
	right = N - M
	if right >= left {
		fmt.Println(M + 1)
	} else if right < left {
		fmt.Println(M - 1)
	}

}

//template
type FastScanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewFastScanner() *FastScanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1024)
	return &FastScanner{r: rdr}
}
func (s *FastScanner) 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 *FastScanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *FastScanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *FastScanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

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

package main

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

var N, M int

func main() {
	fsc := NewFastScanner()
	N, M = fsc.NextInt(), fsc.NextInt()
	var left, right int
	left = M - 1
	right = N - M
	if right > left {
		fmt.Println(M + 1)
	} else if right < left {
		fmt.Println(M - 1)
	} else {
		fmt.Println(M)
	}

}

//template
type FastScanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewFastScanner() *FastScanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1024)
	return &FastScanner{r: rdr}
}
func (s *FastScanner) 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 *FastScanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *FastScanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}
func (s *FastScanner) NextInt64() int64 {
	v, _ := strconv.ParseInt(s.Next(), 10, 64)
	return v
}

func (s *FastScanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *FastScanner) 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 n,m int;
	_,_ = fmt.Scanf("%d %d",&n,&m)
	var u = n-m;
	var l = m-1;
	if n == m{
		fmt.Println(m)
	}else if(u > l){
		fmt.Println(m+1)
	}else{
		fmt.Println(m-1)
	}
}

package main

import "fmt"

func main() {
	var n,m int;
	_,_ = fmt.Scanf("%d %d",&n,&m)
	var u = n-m;
	var l = m-1;

	if(u > l){
		fmt.Println(m+1)
	}else{
		fmt.Println(m-1)
	}
}


package main

import "fmt"

func main() {
	var adr, dmt, mcl int
	fmt.Scan(&adr, &dmt, &mcl)

	var g, p, b int
	fmt.Scan(&g, &p, &b)

	g -= adr
	p = p + g - dmt
	b = b + p - mcl

	if g < 0 || p < 0 || b < 0 {
		fmt.Println("NO")
		return
	}
	fmt.Println("YES")

}

package main

import (
	"fmt"
)

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

	fmt.Scanln(&x, &y, &z)
	fmt.Scanln(&a, &b, &c)

	if a >= x {
		a = a - x
		if a+b >= y {
			a = a - y
			if a+b+c >= z {
				res = 1
			} else {
				res = 2
			}
		} else {
			res = 2
		}
	} else {
		res = 2
	}
	if res == 1 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}

package main

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

func main() {
	var x, y, z, a, b, c int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &x, &y, &z, &a, &b, &c)
	ans := findAns(x, y, z, a, b, c)
	fmt.Println(ans)
}

func findAns(x, y, z, a, b, c int) string {
	if x > a {
		return "NO"
	}
	a = a - x
	if y > a+b {
		return "NO"
	}
	if y+z > a+b+c {
		return "NO"
	}
	return "YES"
}

package main

import "fmt"

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

package main

import (
 "fmt"
)

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

package main

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

func main() {
	defer out.Flush()
	var x, y, z, g, p, b int
	for hasNext() {
		scan(&x, &y, &z, &g, &p, &b)
		if x > g || y > g+p-x || z > g+p+b-x-y {
			println("NO")
		} else {
			println("YES")
		}
	}
}

// Fast IO Template
var in, out = bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)

func print(a ...interface{})            { fmt.Fprint(out, a...) }
func printf(f string, a ...interface{}) { fmt.Fprintf(out, f, a...) }
func println(a ...interface{})          { fmt.Fprintln(out, a...) }
func scan(a ...interface{})             { fmt.Fscan(in, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(in, f, a...) }
func scanln(a ...interface{})           { fmt.Fscanln(in, a...) }
func hasNext() bool {
	for b, _ := in.Peek(1); len(b) > 0 && (b[0] == 10 || b[0] == 13); b, _ = in.Peek(1) {
		in.Discard(1)
	}
	b, _ := in.Peek(1)
	return len(b) == 1
}

package main

import (
	"fmt"
	"io"
)

func main() {
	var x, y, z, g, p, b int
	for {
		if _, err := fmt.Scan(&x, &y, &z, &g, &p, &b); err == io.EOF {
			break
		}
		if x > g || y > g+p-x || z > g+p+b-x-y {
			fmt.Println("NO")
		} else {
			fmt.Println("YES")
		}
	}
}

package main

import "fmt"

func main() {
	var x, y, z int32 = 0, 0, 0
	var a, b, c int32 = 0, 0, 0
	fmt.Scanf("%d %d %d\n", &x, &y, &z)
	fmt.Scanf("%d %d %d", &a, &b, &c)
	if x <= a && y <= a-x+b && z <= a+b+c-x-y {
		fmt.Printf("YES")
	} else {
		fmt.Printf("NO")
	}
}

package main

import "fmt"

func main() {
	var x, y, z, a, b, c int32
	fmt.Scanf("%d %d %d\n", &x, &y, &z)
	fmt.Scanf("%d %d %d", &a, &b, &c)

	if (a < x) || (a+b < x+y) || (a+b+c < x+y+z) {
		fmt.Printf("NO\n")
		return
	}
	fmt.Printf("YES\n")
	return
}

package main

import "fmt"

func eval(a, d, m, g, p, b int) bool {
	if a > g {
		return false
	}
	g -= a
	if d > (g + p) {
		return false
	}
	rest := g + p - d
	if m > (rest + b) {
		return false
	}
	return true
}

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

	var g, p, b int
	fmt.Scanf("%d %d %d\n", &g, &p, &b)

	if eval(a, d, m, g, p, b) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

package main

import (
    "fmt"
)

func check(x, y, z, a, b, c int) bool {
    if a < x {
        return false
    }
    if c > z {
        return x+y <= a+b
    }
    return x+y+z <= a+b+c
}

func main() {
    var x, y, z, a, b, c int
    for {
        _, err := fmt.Scanf("%d %d %d\n%d %d %d", &x, &y, &z, &a, &b, &c)
        if err != nil {
            return
        }
        if check(x, y, z, a, b, c) {
            fmt.Println("YES")
        } else {
            fmt.Println("NO")
        }
    }
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	tmp := readInt64Slice(reader, 3)
	x, y, z := tmp[0], tmp[1], tmp[2]
	tmp = readInt64Slice(reader, 3)
	a, b, c := tmp[0], tmp[1], tmp[2]
	a -= x
	if a < 0 {
		fmt.Println("NO")
		os.Exit(0)
	}
	b += a
	b -= y
	if b < 0 {
		fmt.Println("NO")
		os.Exit(0)
	}
	c += b
	c -= z
	if c < 0 {
		fmt.Println("NO")
		os.Exit(0)
	}
	fmt.Println("YES")
}

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

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

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

package main

import "fmt"

func main() {
	var x, y, z, a, b, c int32
	fmt.Scan(&x, &y, &z, &a, &b, &c)
	var answer string = "YES"
	if a -= x; a < 0 {
		answer = "NO"
	}
	if b = a + b - y; b < 0 {
		answer = "NO"
	}
	if c = b + c - z; c < 0 {
		answer = "NO"
	}
	fmt.Printf("%v", answer)
}

package main

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

func main() {
	sc := NewScanner()
	A, B, C := sc.NextInt(), sc.NextInt(), sc.NextInt()
	X, Y, Z := sc.NextInt(), sc.NextInt(), sc.NextInt()

	X -= A
	if X < 0 {
		fmt.Println("NO")
		return
	}

	if B < X {
		X -= B
		B = 0
	} else {
		B -= X
		X = 0
	}
	if B < Y {
		Y -= B
		B = 0
	} else {
		B -= Y
		Y = 0
	}
	if B > 0 {
		fmt.Println("NO")
		return
	}

	if C > X+Y+Z {
		fmt.Println("NO")
		return
	}
	fmt.Println("YES")

}

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

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

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

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

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

	return mp
}

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

package main

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

var scanner = bufio.NewScanner(os.Stdin)

func init() {
	scanner.Split(bufio.ScanWords)
}

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

func scanBytes() []byte {
	scanner.Scan()
	return scanner.Bytes()
}

func scanInt64() int64 {
	scanner.Scan()
	v, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return v
}

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

func scanInts(n int) []int {
	l := make([]int, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		l[i], _ = strconv.Atoi(scanner.Text())
	}

	return l
}

func scanInts64(n int64) []int64 {
	l := make([]int64, n)
	for i := int64(0); i < n; i++ {
		scanner.Scan()
		l[i], _ = strconv.ParseInt(scanner.Text(), 10, 64)
	}

	return l
}

func scanBool() bool {
	scanner.Scan()
	v, _ := strconv.ParseInt(scanner.Text(), 10, 64)
	return v == 1
}

func scanBools(n int64) []bool {
	l := make([]bool, n)
	for i := int64(0); i < n; i++ {
		scanner.Scan()
		v, _ := strconv.ParseInt(scanner.Text(), 10, 64)
		l[i] = v == 1
	}

	return l
}

func scanUint64() uint64 {
	scanner.Scan()
	v, _ := strconv.ParseUint(scanner.Text(), 10, 64)
	return v
}

type ByAge []int

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

var glasn = map[byte]bool{
	'a': true,
	'e': true,
	'i': true,
	'o': true,
	'u': true,
}

func main() {
	x, y, z := scanInt(), scanInt(), scanInt()
	a, b, c := scanInt(), scanInt(), scanInt()

	if a < x {
		fmt.Println("NO")
		return
	}

	a -= x

	if a+b < y {
		fmt.Println("NO")
		return
	}

	left := (a + b - y) + c

	if left < z {
		fmt.Println("NO")
		return
	}

	fmt.Println("YES")
}

func skipZero(a []uint64) []uint64 {
	for len(a) > 0 && a[0] == 0 {
		a = a[1:]
	}

	return a
}

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

	return -a
}

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

	return b
}

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

	return b
}

package main

import "fmt"

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

func main() {
	var x, y, z, a, b, c int
	fmt.Scan(&x, &y, &z, &a, &b, &c)
	var ans int
	ans = solve(x, y, z, a, b, c)
	fmt.Println([]string{"YES", "NO"}[ans])
}

package main

import "fmt"

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

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

package main

import "fmt"

func main() {
	var x, y, z, a, b, c int32
	fmt.Scanf("%d %d %d\n", x, y, z)
	fmt.Scanf("%d %d %d", a, b, c)
	if (a < x) || (a+b < x+y) || (a+b+c < x+y+z) {
		fmt.Printf("NO")
		return
	}
	fmt.Printf("YES")
	return
}

package main

import (
    "fmt"
)

func check(x, y, z, a, b, c int) bool {
    if a < x {
        return false
    }
    if c < z {
        return x+y <= a+b
    }
    return x+y+z <= a+b+c
}

func main() {
    var x, y, z, a, b, c int
    for {
        _, err := fmt.Scanf("%d %d %d\n%d %d %d", &x, &y, &z, &a, &b, &c)
        if err != nil {
            return
        }
        if check(x, y, z, a, b, c) {
            fmt.Println("YES")
        } else {
            fmt.Println("NO")
        }
    }
}

package main

import "fmt"

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

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

package main

import "fmt"

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

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

package main

import "fmt"

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

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

package main

import "fmt"

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

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