There is a game called "I Wanna Be the Guy", consisting of n levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game.Little X can pass only p levels of the game. And Little Y can pass only q levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?

The first line contains a single integer n (1 ≤  n ≤ 100).  The next line contains an integer p (0 ≤ p ≤ n) at first, then follows p distinct integers a1, a2, ..., ap (1 ≤ ai ≤ n). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to n.

If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).

NoteIn the first sample, Little X can pass levels [1 2 3], and Little Y can pass level [2 4], so they can pass all the levels both.In the second sample, no one can pass level 4.

package main

import (
    "fmt"
)

func main() {
    var n int

    fmt.Scan(&n)

    a := make([]bool, n)

    for k := 0; k < 2; k++ {
        var m int
        fmt.Scan(&m)
        for j := 0; j < m; j++ {
            var x int
            fmt.Scan(&x)
            a[x - 1] = true
        }
    }

    for i := 0; i < n; i++ {
        if !a[i] {
            fmt.Print("Oh, my keyboard!")
            return
        }
    }

    fmt.Print("I become the guy.")
}

//  URL: http://codeforces.com/problemset/problem/469/A
//  ~ Basic Implementation Problem

package main

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

func solve(n int, x []int, y []int) string {
	completedLevels := make([]int, n)
	for i := 0; i < len(x); i++ {
		completedLevels[x[i]-1] = 1
	}
	for i := 0; i < len(y); i++ {
		completedLevels[y[i]-1] = 1
	}
	for i := 0; i < len(completedLevels); i++ {
		if completedLevels[i] == 0 {
			return "Oh, my keyboard!"
		}
	}
	return "I become the guy."
}

func readLevels(reader io.Reader) []int {
	var length int
	fmt.Fscanf(reader, "%d ", &length)
	levels := make([]int, length)
	for i := 0; i < length; i++ {
		fmt.Fscanf(reader, "%d", &levels[i])
	}
	fmt.Fscanf(reader, "\n")
	return levels
}

func main() {
	reader, writer := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var n int
	fmt.Fscanf(reader, "%d\n", &n)
	x := readLevels(reader)
	y := readLevels(reader)
	fmt.Fprintf(writer, "%s\n", solve(n, x, y))
}

package main

import "fmt"

func main() {
	var N int
	fmt.Scan(&N)
	L := make([]bool, N + 1)
	for i := 0; i < 2; i++ {
		var p int
		fmt.Scan(&p)
		for k := 0; k < p; k++ {
			var x int
			fmt.Scan(&x)
			L[x] = true
		}
	}

	var ret bool = true
	for i := 1; i <= N; i++ {
		if(!L[i]) {
			ret = false
			break
		}
	}

	if ret {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"

func main() {
	var n, len1, len2, a int
	var arr []int
	var flag bool
	fmt.Scanf("%d\n", &n)
	fmt.Scanf("%d", &len1)
	for i := 0; i < len1; i++ {
		fmt.Scanf("%d", &a)
		arr = append(arr, a)
	}
	fmt.Scanf("\n")
	fmt.Scanf("%d", &len2)
	for i := 0; i < len2; i++ {
		fmt.Scanf("%d", &a)
		arr = append(arr, a)
	}
	for i := 1; i <= n; i++ {
		flag = false
		for j := 0; j < len(arr); j++ {
			if arr[j] == i {
				flag = true
				break
			}
		}
		if flag {
			continue
		} else {
			break
		}
	}
	if flag {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"

func main() {
	var n, l byte
	fmt.Scan(&n)
	var arr = make(map[byte]uint, n)
	for i := 0; i < 2; i++ {
		fmt.Scan(&l)
		for j := byte(0); j < l; j++ {
			var tmp byte
			fmt.Scan(&tmp)
			arr[tmp]++
		}
	}
	if len(arr) == int(n) {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

// https://codeforces.com/problemset/problem/469/A
// A. I Wanna Be the Guy
// time limit per test
// 1 second
// memory limit per test
// 256 megabytes
// input
// standard input
// output
// standard output

// There is a game called "I Wanna Be the Guy", consisting of n levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game.

// Little X can pass only p levels of the game. And Little Y can pass only q levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?
// Input

// The first line contains a single integer n (1 ≤  n ≤ 100).

// The next line contains an integer p (0 ≤ p ≤ n) at first, then follows p distinct integers a1, a2, ..., ap (1 ≤ ai ≤ n). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to n.
// Output

// If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).

func main() {
	solveTheProblem()
}

func solveTheProblem() {
	bufStdin := bufio.NewReader(os.Stdin)

	var n int // level we need to pass
	_, _ = fmt.Fscan(bufStdin, &n)

	var p int // number of levels Little X can pass
	_, _ = fmt.Fscan(bufStdin, &p)
	xLevels := make([]int, p)
	for i := 0; i < p; i++ {
		_, _ = fmt.Fscan(bufStdin, &xLevels[i])
	}

	var q int // number of levels Little Y can pass
	_, _ = fmt.Fscan(bufStdin, &q)
	yLevels := make([]int, q)
	for i := 0; i < q; i++ {
		_, _ = fmt.Fscan(bufStdin, &yLevels[i])
	}

	var solveFunc func(xLevels, yLevels []int, n int) bool
	if true {
		solveFunc = canPassLevelsSet
	} else {
		solveFunc = canPassLevelsNoSet
	}

	if solveFunc(xLevels, yLevels, n) {
		fmt.Print("I become the guy.")
	} else {
		fmt.Print("Oh, my keyboard!")
	}
}

// this is the simplest solution, use map as a set to record which levels we can pass, and then check each level
func canPassLevelsSet(xLevels, yLevels []int, n int) bool {
	levelsWeCanPass := make(map[int]struct{}, len(xLevels)+len(yLevels))

	for _, v := range xLevels {
		levelsWeCanPass[v] = struct{}{}
	}
	for _, v := range yLevels {
		levelsWeCanPass[v] = struct{}{}
	}

	for i := 1; i <= n; i++ {
		if _, canPass := levelsWeCanPass[i]; !canPass {
			return false
		}
	}

	return true
}

// this solution is a bit more clever and only uses constant extra memory
// we take advantage of the fact that the levels as read in are sorted
func canPassLevelsNoSet(xLevels, yLevels []int, n int) bool {
	// since xLevels and yLevels are sorted, we can keep an index into each
	// and only check the the ones we need to
	xIdx, yIdx := 0, 0
	for i := 1; i <= n; i++ {
		for xIdx < len(xLevels) && xLevels[xIdx] < i {
			xIdx++
		}
		for yIdx < len(yLevels) && yLevels[yIdx] < i {
			yIdx++
		}

		if xIdx < len(xLevels) && xLevels[xIdx] == i {
			xIdx++
		} else if yIdx < len(yLevels) && yLevels[yIdx] == i {
			yIdx++
		} else {
			return false
		}
	}

	return true
}

package main

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

// https://codeforces.com/problemset/problem/469/A
// A. I Wanna Be the Guy
// time limit per test
// 1 second
// memory limit per test
// 256 megabytes
// input
// standard input
// output
// standard output

// There is a game called "I Wanna Be the Guy", consisting of n levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game.

// Little X can pass only p levels of the game. And Little Y can pass only q levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?
// Input

// The first line contains a single integer n (1 ≤  n ≤ 100).

// The next line contains an integer p (0 ≤ p ≤ n) at first, then follows p distinct integers a1, a2, ..., ap (1 ≤ ai ≤ n). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to n.
// Output

// If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).

func main() {
	solveTheProblem()
}

func solveTheProblem() {
	bufStdin := bufio.NewReader(os.Stdin)

	var n int // level we need to pass
	_, _ = fmt.Fscan(bufStdin, &n)

	var p int // number of levels Little X can pass
	_, _ = fmt.Fscan(bufStdin, &p)
	xLevels := make([]int, p)
	for i := 0; i < p; i++ {
		_, _ = fmt.Fscan(bufStdin, &xLevels[i])
	}

	var q int // number of levels Little Y can pass
	_, _ = fmt.Fscan(bufStdin, &q)
	yLevels := make([]int, q)
	for i := 0; i < q; i++ {
		_, _ = fmt.Fscan(bufStdin, &yLevels[i])
	}

	if canPassLevels(xLevels, yLevels, n) {
		fmt.Print("I become the guy.")
	} else {
		fmt.Print("Oh, my keyboard!")
	}
}

// this is the simplest solution, use map as a set to record which levels we can pass, and then check each level
func canPassLevels(xLevels, yLevels []int, n int) bool {
	levelsWeCanPass := make(map[int]struct{}, len(xLevels)+len(yLevels))

	for _, v := range xLevels {
		levelsWeCanPass[v] = struct{}{}
	}
	for _, v := range yLevels {
		levelsWeCanPass[v] = struct{}{}
	}

	for i := 1; i <= n; i++ {
		if _, canPass := levelsWeCanPass[i]; !canPass {
			return false
		}
	}

	return true
}

package main

import "fmt"

func main()  {
	var n, q, tmp int
	fmt.Scanf("%d\n", &n)
	var a []int
	for i := 0; i < n; i++ {
		a = append(a, 0)
	}

	fmt.Scanf("%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d", &tmp)
		a[tmp-1] = 1
	}

	fmt.Scanf("\n%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d", &tmp)
		a[tmp-1] = 1
	}

	res := true
	for i := 0; i < n; i++ {
		if a[i] == 0 {
			res = false
		}
	}

	if res {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}

}

package main

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

import "fmt"

func taskSolution(n int, a []int, b []int) string {
	type s struct{}
	exists := s{}
	levels := map[int]s{}
	for _, ai := range a {
		levels[ai] = exists
	}
	for _, bi := range b {
		levels[bi] = exists
	}
	if len(levels) == n {
		return "I become the guy."
	}
	return "Oh, my keyboard!"
}

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

	a := []int{}
	var alen int
	if _, err := fmt.Scan(&alen); err != nil {
		panic(err)
	}
	for i := 0; i < alen; i += 1 {
		var ai int
		if _, err := fmt.Scan(&ai); err != nil {
			panic(err)
		}
		a = append(a, ai)
	}

	b := []int{}
	var blen int
	if _, err := fmt.Scan(&blen); err != nil {
		panic(err)
	}
	for i := 0; i < blen; i += 1 {
		var bi int
		if _, err := fmt.Scan(&bi); err != nil {
			panic(err)
		}
		b = append(b, bi)
	}

	fmt.Println(taskSolution(n, a, b))
}

package main

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

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

var v []bool

func main() {
	defer out.Flush()
	in.Split(bufio.ScanWords)

	var n int = nextInt()
	v = make([]bool, n)

	for i := 0; i < 2; i++ {
		var k int = nextInt()
		for j := k; j > 0; j-- {
			v[nextInt() - 1] = true
		}
	}

	for _, i := range v {
		if !i {
			fmt.Println("Oh, my keyboard!")
			return
		}
	}
	fmt.Println("I become the guy.")
}

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

package main

import "fmt"

func ReadPlayerData(set map[int]struct{}) {
	var p int
	fmt.Scan(&p)
	for i := 0; i < p; i++ {
		var tmp int
		fmt.Scan(&tmp)
		set[tmp] = struct{}{}
	}
}

func main() {
	var n int
	fmt.Scan(&n)
	set := make(map[int]struct{})
	ReadPlayerData(set)
	ReadPlayerData(set)
	if len(set) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import (
	"fmt"
)

func main() {
	var n, n1, n2, z int

	fmt.Scanln(&n)
	res := make(map[int]bool)

	fmt.Scanf("%d", &n1)
	y := make([]int, n1)
	for i := 0; i < n1; i++ {
		if i == (n1 - 1) {
			fmt.Scanf("%d\n", &y[i])
		} else {
			fmt.Scanf("%d", &y[i])
		}
		if !res[y[i]] {
			res[y[i]] = true
		}
	}

	if n1 == 0 {
		fmt.Scanf("%d", &z)
	}

	fmt.Scanf("%d", &n2)
	x := make([]int, n2)
	for i := 0; i < n2; i++ {
		if i == (n2 - 1) {
			fmt.Scanf("%d\n", &x[i])
		} else {
			fmt.Scanf("%d", &x[i])
		}
		if !res[x[i]] {
			res[x[i]] = true
		}
	}

	if len(res) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

func main() {
	var n, xn, yn, p int
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &n)
	q := make([]bool, n+1)
	fmt.Fscan(in, &xn)
	for i := 0; i < xn; i++ {
		fmt.Fscan(in, &p)
		q[p] = true
	}
	fmt.Fscan(in, &yn)
	for i := 0; i < yn; i++ {
		fmt.Fscan(in, &p)
		q[p] = true
	}
	ans := true
	for i := 1; i <= n; i++ {
		ans = ans && q[i]
	}
	if ans {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"

func main() {
    var n int
    fmt.Scan(&n)
    a := make([]bool, n)
    for k := 0; k < 2; k++ {
        var p int
        fmt.Scan(&p)
        for j := 0; j < p; j++ {
            var i int
            fmt.Scan(&i);
            a[i-1] = true
        }
    }
    for _, v := range a {
        if !v {
            fmt.Println("Oh, my keyboard!")
            return
        }
    }
    fmt.Println("I become the guy.")
}

package main
import "fmt"

func main() {
	var(
		n int
		px, py int
		a int
		level [100]int
		flg bool
	)
	fmt.Scanln(&n)
	fmt.Scanf("%d", &px)
	for i := 0; i < px; i ++ {
		fmt.Scanf("%d", &a)
		level[a-1] = 1
	}
	fmt.Scanln()
	fmt.Scanf("%d", &py)
	for i := 0; i < py; i ++ {
		fmt.Scanf("%d", &a)
		level[a-1] = 1
	}
	for i := 0; i < n; i ++ {
		if(level[i] != 1){
			flg = true
			break;
		}
	}

	if flg {
		fmt.Println("Oh, my keyboard!")
	}else {
		fmt.Println("I become the guy.")
	}
}

package main

import(
    "fmt"
)

func main(){
    var(
        n,p1,p2,temp,f int
    )
    fmt.Scan(&n)
    arr:=make([]int,n+1)
    fmt.Scan(&p1)
    for i:=0;i<p1;i++{
        fmt.Scan(&temp)
        arr[temp]=1
    }
    fmt.Scan(&p2)
    for i:=0;i<p2;i++{
        fmt.Scan(&temp)
        arr[temp]=1
    }
    for i:=1;i<=n;i++{
        if arr[i]==0{
            f=1
            break
        }
    }
    if f==1{
        fmt.Println("Oh, my keyboard!")
    }else{
        fmt.Println("I become the guy.")
    }
}

package main

import (
  "fmt"
)

func main() {
  var n, p, q, a int
  fmt.Scan(&n)
  arr := make([]int, n)
  fmt.Scan(&p)
  for i := 0; i < p; i++ {
    fmt.Scan(&a)
    arr[a-1]++
  }
  fmt.Scan(&q)
  for i := 0; i < q; i++ {
    fmt.Scan(&a)
    arr[a-1]++
  }
  x := true
  j := 0
  for x && j < len(arr) {
    if arr[j] == 0 {
      x = false
    }
    j++
  }
  if x {
    fmt.Print("I become the guy.")
  } else {
    fmt.Print("Oh, my keyboard!")
  }
}

package main

import "fmt"

func main() {
	var n, p, temp int
	fmt.Scanf("%d \n", &n)
	var check [100]int
	for i := 0; i < n; i++ {
		check[i] = 0
	}

	fmt.Scanf("%d", &p)
	for i := 0; i < p; i++ {
		fmt.Scanf("%d", &temp)
		check[temp-1] = 1
	}
	fmt.Scanf("\n", &p)

	fmt.Scanf("%d", &p)
	for i := 0; i < p; i++ {
		fmt.Scanf("%d", &temp)
		check[temp-1] = 1
	}
	fmt.Scanf("\n", &p)

	x := 1
	for i := 0; i < n; i++ {
		x *= check[i]
	}

	if x == 0 {
		fmt.Println("Oh, my keyboard!")
	} else {
		fmt.Println("I become the guy.")
	}
}

package main

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

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

	var n int
	fmt.Sscanf(line, "%d", &n)

	line, _ = reader.ReadString('\n')

	firstLine := strings.Fields(line)
	p, _ := strconv.Atoi(firstLine[0])

	line, _ = reader.ReadString('\n')
	secondLine := strings.Fields(line)
	q, _ := strconv.Atoi(secondLine[0])

	available := make(map[string]bool)

	for i := 1; i <= p; i++ {
		available[firstLine[i]] = true
	}

	for i := 1; i <= q; i++ {
		available[secondLine[i]] = true
	}

	for i := 1; i <= n; i++ {
		check := strconv.Itoa(i)
		if !available[check] {
			fmt.Println("Oh, my keyboard!")
			return
		}
	}
	fmt.Println("I become the guy.")
}

package main

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

var reader = bufio.NewReader(os.Stdin)

func scan(f string, v ...interface{}) { fmt.Fscanf(reader, f, v...) }

func main() {
	var n int
	scan("%d\n", &n)
	level := make([]int, n)
	_ = level
	var xn int
	scan("%d", &xn)
	for i := 0; i < xn; i++ {
		var temp int
		scan("%d", &temp)
		level[temp-1] = -1
	}
	scan("\n")
	var yn int
	scan("%d", &yn)
	for i := 0; i < yn; i++ {
		var temp int
		scan("%d", &temp)
		level[temp-1] = -1
	}
	for _, v := range level {
		if v == 0 {
			fmt.Print("Oh, my keyboard!")
			return
		}
	}
	fmt.Print("I become the guy.")
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	levels := make([]int, n)
	for i := 0; i < 2; i++ {
		var m int
		fmt.Scan(&m)
		for j := 0; j < m; j++ {
			var v int
			fmt.Scan(&v)
			v--
			levels[v]++
		}
	}
	cnt := 0
	for i := 0; i < n; i++ {
		if levels[i] > 0 {
			cnt++
		}
	}
	if n == cnt {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)

	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("\n%d", &x)

	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"

const (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	level := make([]bool, number+1)

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}

	for i := 0; i < 2; i++ {
		var x, a int
		fmt.Scan(&x)
		for y := 0; y < x; y++ {
			fmt.Scan(&a)
			level[a] = true
		}
	}

	for i := 1; i <= number; i++ {
		if !level[i] {
			fmt.Println(bad)
			return
		}
	}
	fmt.Println(good)

}

package main

import (
	"fmt"
)

func main() {
	var a [101]bool
	var n, m int
	fmt.Scan(&n)

	readLevels := func() {
		fmt.Scan(&m)
		var x int
		for i := 0; i < m; i++ {
			fmt.Scan(&x)
			a[x] = true
		}
	}

	readLevels()
	readLevels()
	z := true
	for i := 1; i <= n; i++ {
		z = z && a[i]
	}
	res := "Oh, my keyboard!"
	if z {
		res = "I become the guy."
	}
	fmt.Println(res)
}

package main

import "fmt"

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

	pass := make([]bool, n+1)
	sum := 0
	for i := 0; i < 2; i++ {
		fmt.Scan(&m)
		for j := 0; j < m; j++ {
			fmt.Scan(&v)
			if !pass[v] {
				pass[v] = true
				sum += v
			}
		}
	}

	if sum == (1+n)*n/2 {
		fmt.Print("I become the guy.")
	} else {
		fmt.Print("Oh, my keyboard!")
	}
}

package main

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

var n int

func main() {
	stdin := os.Stdin
	// stdin, _ = os.Open("1.in")
	reader := bufio.NewReaderSize(stdin, 1<<20)
	fmt.Fscanf(reader, "%d\n", &n)
	m := make(map[int]int)
	var p, q, x int
	fmt.Fscanf(reader, "%d", &p)
	for ; p != 0; p-- {
		fmt.Fscanf(reader, "%d", &x)
		m[x] = 1
	}
	fmt.Fscanf(reader, "\n%d", &q)
	for ; q != 0; q-- {
		fmt.Fscanf(reader, "%d", &x)
		m[x] = 1
	}

	if len(m) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	if x == 0 {
		fmt.Fscanf(in, "%d\n", &l)
	}
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}
	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			if i == y-1 {
				fmt.Fscanf(in, "%d\n", &l)
				ym[l] = i
			} else {
				fmt.Fscanf(in, "%d", &l)
				ym[l] = i
			}
		}
		for k, v := range xm {
			ym[k] = v
		}
		for k, v := range ym {
			xm[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x == 0 && y == 0 {
			fmt.Println("Oh, my keyboard!")
		} else if x != 0 || y != 0 {
			fmt.Println("Oh, my keyboard!")
		}
	}
}

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	a := make([]int, n+1)
	var p, q int
	fmt.Scan(&p)
	for i := 0; i < p; i++ {
		var j int
		fmt.Scan(&j)
		a[j]++
	}
	fmt.Scan(&q)
	for i := 0; i < q; i++ {
		var j int
		fmt.Scan(&j)
		a[j]++
	}
	for i := 1; i <= n; i++ {
		if a[i] == 0 {
			fmt.Print("Oh, my keyboard!")
			return
		}
	}
	fmt.Print("I become the guy.")
}

package main

import (
	"fmt"
)

func main() {
	var l int
	fmt.Scanln(&l)
	var x, y int
	fmt.Scan(&x)
	var levels map[int]bool = make(map[int]bool)

	for i := 0; i < x; i++ {
		var z int
		fmt.Scan(&z)
		levels[z] = true
	}
	fmt.Scan(&y)
	for i := 0; i < y; i++ {
		var z int
		fmt.Scan(&z)
		levels[z] = true
	}
	// fmt.Println(levels)
	if len(levels) == l {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"
import "sort"

func main() {
	var n int
	var p int
	var q int
	var num int
	var levels []int

	fmt.Scan(&n)
	fmt.Scan(&p)

	for i := 0; i < p; i++ {
		fmt.Scan(&num)
		levels = append(levels,num)
	}

	fmt.Scan(&q)

	for i := 0; i < q; i++ {
		fmt.Scan(&num)
		levels = append(levels,num)
	}

	sort.Ints(levels)

	flag := true

	if len(levels) < 1 || levels[len(levels)-1] != n || levels[0] != 1 {
		flag = false
	}

	for i := 1; i < len(levels) && flag; i++ {
		if levels[i] - levels[i-1] > 1 {
			flag = false
		}
	}

	if flag {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")

	}
}

package main

import (
    "fmt"
)

func main() {
    var n, z, a int
    fmt.Scan(&n)
    ans := make([]bool, n)

    for j := 0; j < 2; j++ {
        fmt.Scan(&z)
        for i := 0; i < z; i++ {
            fmt.Scan(&a)
            ans[a-1] = true
        }
    }

    for i := 0; i < n; i++ {
        if !ans[i] {
            fmt.Println("Oh, my keyboard!")
            return
        }
    }
    fmt.Println("I become the guy.")
}

package main

import (
    "fmt"
)

func main() {
    var n, z, a int
    fmt.Scanf("%d\n", &n)
    ans := make([]bool, n)
    fmt.Scanf("%d", &z)

    for i := 0; i < z-1; i++ {
        fmt.Scanf("%d", &a)
        ans[a-1] = true
    }

    if z > 0 {
        fmt.Scanf("%d\n", &a)
        ans[a-1] = true
    }

    fmt.Scanf("%d", &z)
    for i := 0; i < z; i++ {
        fmt.Scanf("%d", &a)
        ans[a-1] = true
    }

    for i := 0; i < n; i++ {
        if !ans[i] {
            fmt.Println("Oh, my keyboard!")
            return
        }
    }
    fmt.Println("I become the guy.")
}

package main

import (
    "fmt"
)

func main() {
    var n, z, a int
    fmt.Scanf("%d", &n)
    ans := make([]bool, n)
    fmt.Scanf("%d", &z)
    for i := 0; i < z; i++ {
        fmt.Scanf("%d", &a)
        ans[a-1] = true
    }
    fmt.Scanf("%d", &z)
    for i := 0; i < z; i++ {
        fmt.Scanf("%d", &a)
        ans[a-1] = true
    }
    for i := 0; i < n; i++ {
        if !ans[i] {
            fmt.Println("Oh, my keyboard!")
            return
        }
    }
    fmt.Println("I become the guy.")
}

//  URL: http://codeforces.com/problemset/problem/469/A
//  ~ Basic Implementation Problem

package main

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

func solve(n int, x []int, y []int) string {
	completedLevels := make([]int, n)
	for i := 0; i < len(x); i++ {
		completedLevels[x[i]-1] = 1
	}
	for i := 0; i < len(y); i++ {
		completedLevels[y[i]-1] = 1
	}
	for i := 0; i < len(completedLevels); i++ {
		if completedLevels[i] == 0 {
			return "Oh, my keyboard!"
		}
	}
	return "I become the guy."
}

func readLevels(reader io.Reader) []int {
	var length int
	fmt.Fscanf(reader, "%d ", &length)
	levels := make([]int, length)
	for i := 0; i < length; i++ {
		fmt.Fscanf(reader, "%d ", &levels[i])
	}
	return levels
}

func main() {
	reader, writer := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var n int
	fmt.Fscanf(reader, "%d\n", &n)
	x := readLevels(reader)
	y := readLevels(reader)
	fmt.Fprintf(writer, "%s\n", solve(n, x, y))
}

package main

import "fmt"

func main() {
	var n, len1, len2, a int
	var arr []int
	var flag bool
	fmt.Scanf("%d\n", &n)
	fmt.Scanf("%d", &len1)
	for i := 0; i < len1; i++ {
		fmt.Scanf("%d", &a)
		arr = append(arr, a)
	}
	fmt.Scanf("%d", &len2)
	for i := 0; i < len2; i++ {
		fmt.Scanf("%d", &a)
		arr = append(arr, a)
	}
	for i := 1; i <= n; i++ {
		flag = false
		for j := 0; j < len(arr); j++ {
			if arr[j] == i {
				flag = true
				break
			}
		}
		if flag {
			continue
		} else {
			break
		}
	}
	if flag {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

// https://codeforces.com/problemset/problem/469/A
// A. I Wanna Be the Guy
// time limit per test
// 1 second
// memory limit per test
// 256 megabytes
// input
// standard input
// output
// standard output

// There is a game called "I Wanna Be the Guy", consisting of n levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game.

// Little X can pass only p levels of the game. And Little Y can pass only q levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?
// Input

// The first line contains a single integer n (1 ≤  n ≤ 100).

// The next line contains an integer p (0 ≤ p ≤ n) at first, then follows p distinct integers a1, a2, ..., ap (1 ≤ ai ≤ n). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to n.
// Output

// If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).

func main() {
	solveTheProblem()
}

func solveTheProblem() {
	bufStdin := bufio.NewReader(os.Stdin)

	var n int // level we need to pass
	_, _ = fmt.Fscan(bufStdin, &n)

	var p int // number of levels Little X can pass
	_, _ = fmt.Fscan(bufStdin, &p)
	xLevels := make([]int, p)
	for i := 0; i < p; i++ {
		_, _ = fmt.Fscan(bufStdin, &xLevels[i])
	}

	var q int // number of levels Little Y can pass
	_, _ = fmt.Fscan(bufStdin, &q)
	yLevels := make([]int, q)
	for i := 0; i < q; i++ {
		_, _ = fmt.Fscan(bufStdin, &yLevels[i])
	}

	var solveFunc func(xLevels, yLevels []int, n int) bool
	if false {
		solveFunc = canPassLevelsSet
	} else {
		solveFunc = canPassLevelsNoSet
	}

	if solveFunc(xLevels, yLevels, n) {
		fmt.Print("I become the guy.")
	} else {
		fmt.Print("Oh, my keyboard!")
	}
}

// this is the simplest solution, use map as a set to record which levels we can pass, and then check each level
func canPassLevelsSet(xLevels, yLevels []int, n int) bool {
	levelsWeCanPass := make(map[int]struct{}, len(xLevels)+len(yLevels))

	for _, v := range xLevels {
		levelsWeCanPass[v] = struct{}{}
	}
	for _, v := range yLevels {
		levelsWeCanPass[v] = struct{}{}
	}

	for i := 1; i <= n; i++ {
		if _, canPass := levelsWeCanPass[i]; !canPass {
			return false
		}
	}

	return true
}

// this solution is a bit more clever and only uses constant extra memory
// we take advantage of the fact that the levels as read in are sorted
func canPassLevelsNoSet(xLevels, yLevels []int, n int) bool {
	// since xLevels and yLevels are sorted, we can keep an index into each
	// and only check the the ones we need to
	xIdx, yIdx := 0, 0
	for i := 1; i <= n; i++ {
		for xIdx < len(xLevels) && xLevels[xIdx] < i {
			xIdx++
		}
		for yIdx < len(yLevels) && yLevels[yIdx] < i {
			yIdx++
		}

		if xIdx < len(xLevels) && xLevels[xIdx] == i {
			xIdx++
		} else if yIdx < len(yLevels) && yLevels[yIdx] == i {
			yIdx++
		} else {
			return false
		}
	}

	return true
}

package main

import "fmt"

func main()  {
	var n, q, tmp int
	fmt.Scanf("%d\n", &n)
	var a []int
	for i := 0; i < n; i++ {
		a = append(a, 0)
	}

	fmt.Scanf("%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d", &tmp)
		a[tmp-1] = 1
	}

	fmt.Scanf("%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d", &tmp)
		a[tmp-1] = 1
	}

	res := true
	for i := 0; i < n; i++ {
		if a[i] == 0 {
			res = false
		}
	}

	if res {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}

}

package main

import "fmt"

func main()  {
	var n, q, tmp int
	fmt.Scanf("%d\n", &n)
	var a []int
	for i := 0; i < n; i++ {
		a = append(a, 0)
	}

	fmt.Scanf("%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d\n", &tmp)
		a[tmp-1] = 1
	}

	fmt.Scanf("%d", &q)
	for i := 0; i < q; i++ {
		fmt.Scanf("%d", &tmp)
		a[tmp-1] = 1
	}

	res := true
	for i := 0; i < n; i++ {
		if a[i] == 0 {
			res = false
		}
	}

	if res {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}

}

package main

import (
	"fmt"
)

func main() {
	var n, n1, n2 int

	fmt.Scanln(&n)
	res := make(map[int]bool)

	fmt.Scanf("%d", &n1)
	y := make([]int, n1)
	for i := 0; i < n1; i++ {
		if i == (n1 - 1) {
			fmt.Scanf("%d\n", &y[i])
		} else {
			fmt.Scanf("%d", &y[i])
		}
		if !res[y[i]] {
			res[y[i]] = true
		}
	}

	fmt.Scanf("%d", &n2)
	x := make([]int, n2)
	for i := 0; i < n2; i++ {
		if i == (n1 - 1) {
			fmt.Scanf("%d\n", &x[i])
		} else {
			fmt.Scanf("%d", &x[i])
		}
		if !res[x[i]] {
			res[x[i]] = true
		}
	}

	if len(res) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import (
	"fmt"
)

func main() {
	var n, n1, n2, z int

	fmt.Scanln(&n)
	res := make(map[int]bool)

	fmt.Scanf("%d", &n1)
	y := make([]int, n1)
	for i := 0; i < n1; i++ {
		if i == (n1 - 1) {
			fmt.Scanf("%d\n", &y[i])
		} else {
			fmt.Scanf("%d", &y[i])
		}
		if !res[y[i]] {
			res[y[i]] = true
		}
	}

	if n1 == 0 {
		fmt.Scanf("%d", &z)
	}

	fmt.Scanf("%d", &n2)
	x := make([]int, n2)
	for i := 0; i < n2; i++ {
		if i == (n1 - 1) {
			fmt.Scanf("%d\n", &x[i])
		} else {
			fmt.Scanf("%d", &x[i])
		}
		if !res[x[i]] {
			res[x[i]] = true
		}
	}

	if len(res) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"

func main() {
	var n, p, temp int
	fmt.Scanf("%d \n", &n)
	var check [100]int
	for i := 0; i < n; i++ {
		check[i] = 0
	}

	fmt.Scanf("%d", &p)
	for i := 0; i < p; i++ {
		fmt.Scanf("%d", &temp)
		check[temp] = 1
	}
	fmt.Scanf("\n", &p)

	fmt.Scanf("%d", &p)
	for i := 0; i < p; i++ {
		fmt.Scanf("%d", &temp)
		check[temp] = 1
	}
	fmt.Scanf("\n", &p)

	x := 1
	for i := 0; i < n; i++ {
		x *= check[i]
	}

	if x == 0 {
		fmt.Println("Oh, my keyboard!")
	} else {
		fmt.Println("I become the guy.")
	}
}

package main

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

var reader = bufio.NewReader(os.Stdin)

func scan(f string, v ...interface{}) { fmt.Fscanf(reader, f, v...) }

func main() {
	var n int
	scan("%d\n", &n)
	level := make([]int, n)
	 _ = level
	var xn int
	scan("%d ",&xn)
	for i:=0;i<xn;i++{
		var temp int
		if i== xn-1{
			scan("%d\n",&temp)
		} else {
		scan("%d ",&temp)}
		level[temp-1]=-1
	}
	var yn int
	scan("%d ",&yn)
	for i:=0;i<yn;i++{
		var temp int
		if i== yn-1{
			scan("%d\n",&temp)
		} else {
		scan("%d ",&temp)}
		level[temp-1]=-1
	}
	for _, v := range level{
		if v==0{
			fmt.Print("Oh, my keyboard!")
			return
		}
	}
	fmt.Print("I become the guy.")
}

package main

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

var reader = bufio.NewReader(os.Stdin)

func scan(f string, v ...interface{}) { fmt.Fscanf(reader, f, v...) }

func main() {
	var n int
	scan("%d\n", &n)
	level := make([]int, n)
	 _ = level
	var xn int
	scan("%d ",&xn)
	for i:=0;i<xn;i++{
		var temp int
		if i== xn-1{
			scan("%d\n",&temp)
		} else {
		scan("%d ",&temp)}
		level[temp-1]=-1
	}
	var yn int
	scan("%d ",&xn)
	for i:=0;i<yn;i++{
		var temp int
		if i== yn-1{
			scan("%d\n",&temp)
		} else {
		scan("%d ",&temp)}
		level[temp-1]=-1
	}
	for _, v := range level{
		if v==0{
			fmt.Print("Oh, my keyboard!")
			return
		}
	}
	fmt.Print("I become the guy.")
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		fmt.Println(arr[i])
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d\n", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d ", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d\n", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d ", &y)
	fmt.Println(y)
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	var y int
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d ", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf(" %d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	fmt.Println(x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d\n", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	fmt.Println(tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("\n%d", &x)
	fmt.Println(x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("\n%d", &x)
	fmt.Println(x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d\n", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Println(y)
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d ", &x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true

	cnt := 0
	for i := 0; i <n; i++ {
		fmt.Println(arr[i])
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		fmt.Println(arr[i])
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	fmt.Println(n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", y)
	fmt.Println(y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d ", &x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
	fmt.Println(y)
	fmt.Println(x)
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)
	fmt.Println(y)
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	fmt.Println(y)
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	tmp := 0
	fmt.Scanf("%d", &y)

	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("\n%d", &x)

	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		fmt.Println(tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d", &y)
	tmp := 0
	for i := 0; i < y; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	x := 0
	fmt.Scanf("%d", &x)
	for i := 0; i < x; i++ {
		fmt.Scanf("%d", &tmp)
		arr[tmp-1] = true
	}

	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d ", &x)
	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true

	cnt := 0
	for i := 0; i <n; i++ {
		fmt.Println(arr[i])
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import(
	"fmt"
)

func main() {
	n := 0
	fmt.Scanf("%d\n", &n)
	arr := make([]bool, n)
	y := 0
	fmt.Scanf("%d ", &y)
	tmp := 0
	for i := 0; i < y-1; i++ {
		fmt.Scanf("%d ", &tmp)

		arr[tmp-1] = true
	}
	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	x := 0
	fmt.Scanf("%d\n", &x)

	for i := 0; i < x-1; i++ {
		fmt.Scanf("%d ", &tmp)
		arr[tmp-1] = true
	}

	fmt.Scanf("%d\n", &tmp)
	arr[tmp-1] = true
	cnt := 0
	for i := 0; i <n; i++ {
		if arr[i] == true {
			cnt += 1
		}
	}

	if cnt == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//
	fullArr := make([]int, 0)

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

	arrX := strings.Split(strconv.Itoa(no), "")
	pNo, _ := strconv.Atoi(arrX[0])

	if pNo < 1 || pNo > number {
		fmt.Println(bad)
		return
	}

	arr := arrX[1:]

	if len(arr) != pNo {
		fmt.Println(bad)
		return
	}

	for _, val := range arr {
		valNo, _ := strconv.Atoi(val)
		if valNo < 1 || valNo > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, valNo)
	}

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

	arrY := strings.Split(strconv.Itoa(yNumbers), "")
	if len(arrY) != pNo {
		fmt.Println(bad)
		return
	}

	for _, val := range arrY {
		valNo, _ := strconv.Atoi(val)
		if valNo < 1 || valNo > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, valNo)
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}
	fmt.Println(good)
	return

}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

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

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//
	var pNo int
	_, err = fmt.Scanf("%d", &pNo)
	if err != nil {
		fmt.Println(bad)
		return
	}

	if pNo < 1 || pNo > number {
		fmt.Println(bad)
		return
	}

	fullArr := make([]int, 0)

	var list string
	fmt.Scanf("%s", &list)

	arrX := strings.Split(list, ",")

	if len(arrX) != pNo {
		fmt.Println(bad)
		return
	}

	for _, x := range arrX {
		xVal, _ := strconv.Atoi(x)
		if xVal < 1 || xVal > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, xVal)
	}

	fmt.Scanf("%s", &list)

	arrY := strings.Split(list, ",")

	if len(arrY) != pNo {
		fmt.Println(bad)
		return
	}

	for _, x := range arrY {
		yVal, _ := strconv.Atoi(x)
		if yVal < 1 || yVal > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, yVal)
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}

	fmt.Println(good)

	return
}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

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

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//
	var pNo int
	_, err = fmt.Scanf("%d", &pNo)
	if err != nil {
		fmt.Println(bad)
		return
	}

	if pNo < 1 || pNo > number {
		fmt.Println(bad)
		return
	}

	fullArr := make([]int, 0)

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

	arr := strings.Split(strconv.Itoa(no), "")
	if len(arr) != pNo {
		fmt.Println(bad)
		return
	}

	for _, val := range arr {
		valNo, _ := strconv.Atoi(val)
		if valNo < 1 || valNo > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, valNo)
	}

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

	arrY := strings.Split(strconv.Itoa(yNumbers), "")
	if len(arrY) != pNo {
		fmt.Println(bad)
		return
	}

	for _, val := range arrY {
		valNo, _ := strconv.Atoi(val)
		if valNo < 1 || valNo > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, valNo)
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}
	fmt.Println(good)
	return

}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

import "fmt"

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//
	var pNo int
	_, err = fmt.Scanf("%d", &pNo)
	if err != nil {
		fmt.Println(bad)
		return
	}

	if pNo < 1 || pNo > number {
		fmt.Println(bad)
		return
	}

	fullArr := make([]int, 0)

	var no int
	for i := 0; i < pNo; i++ {
		_, err = fmt.Scanf("%d", &no)
		if err != nil {
			fmt.Println(bad)
			return
		}
		if no < 1 || no > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, no)
	}

	for i := 0; i < pNo; i++ {
		_, err = fmt.Scanf("%d", &no)
		if err != nil {
			fmt.Println(bad)
			return
		}
		if no < 1 || no > number {
			fmt.Println(bad)
			return
		}

		fullArr = append(fullArr, no)
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}
	fmt.Println(good)
	return

}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

import "fmt"

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//

	fullArr := make([]int, 0)

	for i := 0; i < 2; i++ {
		var no int
		_, err := fmt.Scanf("%d", &no)
		if err != nil {
			fmt.Println(bad)
			return
		}

		if no < 1 || no > number {
			fmt.Println(bad)
			return
		}

		for i := 0; i < no; i++ {
			var nums int
			_, err = fmt.Scanf("%d", &nums)
			if err != nil {
				fmt.Println(bad)
				return
			}
			if nums < 1 || nums > number {
				fmt.Println(bad)
				return
			}

			fullArr = append(fullArr, nums)
		}
	}

	fmt.Println(good)

	return
}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

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

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

func setLevels(s string, levels []bool) []bool {
	s = strings.Replace(s, "\r\n", "", -1)
	for _, v := range strings.Split(s, " ") {
		i, _ := strconv.ParseInt(v, 10, 32)
		if i > 0 {
			levels[i-1] = true
		}
	}
	return levels
}

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}

	fullArr := make([]int, 0)

	// get inputs and append to array
	for i := 0; i < 2; i++ {

		reader := bufio.NewReader(os.Stdin)
		a, _ := reader.ReadString('\n')
		a = strings.TrimSpace(a)

		s := strings.Replace(a, "\r\n", "", -1)
		arr := strings.Split(s, " ")

		for _, v := range arr[1:] {
			i, _ := strconv.Atoi(v)
			if i > 0 && i <= number {
				fullArr = append(fullArr, i)
			}
		}
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}

	fmt.Println(good)
	return
}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

/*
package main

import "fmt"

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//

	fullArr := make([]int, 0)

	for i := 0; i < 2; i++ {
		var no int
		_, err := fmt.Scanf("%d", &no)
		if err != nil {
			fmt.Println(bad)
			return
		}

		if no < 1 || no > number {
			fmt.Println(bad)
			return
		}

		for i := 0; i < no; i++ {
			var nums int
			_, err = fmt.Scanf("%d", &nums)
			if err != nil {
				fmt.Println(bad)
				return
			}
			if nums < 1 || nums > number {
				fmt.Println(bad)
				return
			}

			fullArr = append(fullArr, nums)
		}
	}

	fmt.Println(good)

	return
}
*/

package main

import "fmt"

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//

	fullArr := make([]int, 0)

	for i := 0; i < 2; i++ {
		var no int
		_, err := fmt.Scanf("%d", &no)
		if err != nil {
			fmt.Println(bad)
			return
		}

		if no < 1 || no > number {
			fmt.Println(bad)
			return
		}

		for i := 0; i < no; i++ {
			var nums int
			_, err = fmt.Scanf("%d", &nums)
			if err != nil {
				fmt.Println(bad)
				return
			}
			if nums < 1 || nums > number {
				fmt.Println(bad)
				return
			}

			fullArr = append(fullArr, nums)
		}
	}

	fmt.Println(good)

	return
}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

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

var (
	good = "I become the guy."
	bad  = "Oh, my keyboard!"
)

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

	if number < 1 || number > 100 {
		fmt.Println(bad)
		return
	}
	//
	//

	fullArr := make([]int, 0)

	for i := 0; i < 2; i++ {
		var xNumbers string
		reader := bufio.NewReader(os.Stdin)
		xNumbers, err = reader.ReadString('\n')
		if err != nil {
			fmt.Println(bad)
			return
		}

		xNumbers = strings.TrimSpace(xNumbers)

		arrX := strings.Split(xNumbers, " ")

		pNo, _ := strconv.Atoi(arrX[0])
		if pNo < 1 || pNo > number {
			fmt.Println(bad)
			return
		}

		arr := arrX[1:]

		for _, val := range arr {
			xVal, _ := strconv.Atoi(val)
			if xVal < 1 || xVal > number {
				fmt.Println(bad)
				return
			}

			fullArr = append(fullArr, xVal)
		}
	}

	for i := 1; i <= number; i++ {
		if !isIn(i, fullArr) {
			fmt.Println(bad)
			return
		}
	}

	fmt.Println(good)

	return
}

func isIn(val int, arr []int) bool {
	for _, a := range arr {
		if a == val {
			return true
		}
	}

	return false
}

package main

import (
	"fmt"
)

func main() {
	var n int64
	fmt.Scan(&n)
	var res int64
	if n%2 == 0 {
		res = n / 2
	} else {
		res = (n-1)/2 - n
	}
	fmt.Println(res)
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}

	}
	fmt.Fscanf(in, "%d", &y)
	for i := uint8(0); i < y; i++ {
		if i == y-1 {
			fmt.Fscanf(in, "%d\n", &l)
			ym[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			ym[l] = i
		}
	}
	for k, v := range xm {
		ym[k] = v
	}
	if uint8(len(ym)) == n {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}

	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			if i == y-1 {
				fmt.Fscanf(in, "%d\n", &l)
				ym[l] = i
			} else {
				fmt.Fscanf(in, "%d", &l)
				ym[l] = i
			}
		}
		for k, v := range xm {
			ym[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x != 0 || y != 0 {
			fmt.Println("Oh, my keyboard!")
		}
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	if x == 0 {
		fmt.Fscanf(in, "%d\n", &l)
	}
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}
	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			if i == y-1 {
				fmt.Fscanf(in, "%d\n", &l)
				ym[l] = i
			} else {
				fmt.Fscanf(in, "%d", &l)
				ym[l] = i
			}
		}
		for k, v := range xm {
			ym[k] = v
		}
		for k, v := range ym {
			xm[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x == 0 && y == 0 {
			fmt.Println("bottom Oh, my keyboard!")
		} else if x != 0 || y != 0 {
			fmt.Println("bottom Oh, my keyboard!")
		}
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d\n", &x)
	for i := uint8(0); i < x; i++ {
		fmt.Fscanf(in, "%d\n", &l)
		xm[l] = i

	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			fmt.Fscanf(in, "%d\n", &l)
			ym[l] = i
		}
		for k, v := range xm {
			ym[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x != 0 || y != 0 {
			fmt.Println("Oh, my keyboard!")
		}
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	if x == 0 {
		fmt.Fscanf(in, "%d\n", &l)
	}
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}
	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			if i == x-1 {
				fmt.Fscanf(in, "%d\n", &l)
				ym[l] = i
			} else {
				fmt.Fscanf(in, "%d", &l)
				ym[l] = i
			}

		}
		for k, v := range xm {
			ym[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x == 0 && y == 0 {
			fmt.Println("Oh, my keyboard!")
		} else if x != 0 || y != 0 {
			fmt.Println("Oh, my keyboard!")
		}
	}
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, x, y, l uint8
	xm := make(map[uint8]uint8)
	ym := make(map[uint8]uint8)
	fmt.Fscanf(in, "%d\n", &n)
	fmt.Fscanf(in, "%d", &x)
	if x == 0 {
		fmt.Fscanf(in, "%d\n", &l)
	}
	for i := uint8(0); i < x; i++ {
		if i == x-1 {
			fmt.Fscanf(in, "%d\n", &l)
			xm[l] = i
		} else {
			fmt.Fscanf(in, "%d", &l)
			xm[l] = i
		}
	}
	fmt.Fscanf(in, "%d", &y)
	if y != 0 || x != 0 {
		for i := uint8(0); i < y; i++ {
			if i == x-1 {
				fmt.Fscanf(in, "%d\n", &l)
				ym[l] = i
			} else {
				fmt.Fscanf(in, "%d", &l)
				ym[l] = i
			}

		}
		for k, v := range xm {
			ym[k] = v
		}
		if uint8(len(ym)) == n {
			fmt.Println("I become the guy.")
		} else {
			fmt.Println("Oh, my keyboard!")
		}
	} else {
		if x != 0 || y != 0 {
			fmt.Println("Oh, my keyboard!")
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	var l int
	fmt.Scanln(&l)
	var x, y int
	fmt.Scan(&x)
	var levels map[int]bool = make(map[int]bool)

	for i := 0; i < x; i++ {
		var z int
		fmt.Scan(&z)
		levels[z] = true
	}
	fmt.Scan(&y)
	for i := 0; i < y; i++ {
		var z int
		fmt.Scan(&z)
		levels[z] = true
	}
	fmt.Println(levels)
	if len(levels) == l {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")
	}
}

package main

import "fmt"
import "sort"

func main() {
	var n int
	var p int
	var q int
	var num int
	var levels []int

	fmt.Scan(&n)
	fmt.Scan(&p)

	for i := 0; i < p; i++ {
		fmt.Scan(&num)
		levels = append(levels,num)
	}

	fmt.Scan(&q)

	for i := 0; i < q; i++ {
		fmt.Scan(&num)
		levels = append(levels,num)
	}

	sort.Ints(levels)

	flag := true

	if len(levels) < 1 || levels[len(levels)-1] != n {
		flag = false
	}

	for i := 1; i < len(levels) && flag; i++ {
		if levels[i] - levels[i-1] > 1 {
			flag = false
		}
	}

	if flag {
		fmt.Println("I become the guy.")
	} else {
		fmt.Println("Oh, my keyboard!")

	}
}

package main

import (
	"fmt"
)

func main() {
	var n, z, a int
	fmt.Scanf("%d\n", &n)
	ans := make([]bool, n)
	fmt.Scanf("%d", &z)
	for i := 0; i < z; i++ {
		fmt.Scanf("%d", &a)
		ans[a-1] = true
	}
	fmt.Scanf("%d", &z)
	for i := 0; i < z; i++ {
		fmt.Scanf("%d", &a)
		ans[a-1] = true
	}
	for i := 0; i < n; i++ {
		if !ans[i] {
			fmt.Println("Oh, my keyboard!")
			return
		}
	}
	fmt.Println("I become the guy.")
}


PolandBall lives in a forest with his family. There are some trees in the forest. Trees are undirected acyclic graphs with k vertices and k - 1 edges, where k is some integer. Note that one vertex is a valid tree.There is exactly one relative living in each vertex of each tree, they have unique ids from 1 to n. For each Ball i we know the id of its most distant relative living on the same tree. If there are several such vertices, we only know the value of the one with smallest id among those.How many trees are there in the forest?

The first line contains single integer n (1 ≤ n ≤ 104) — the number of Balls living in the forest. The second line contains a sequence p1, p2, ..., pn of length n, where (1 ≤ pi ≤ n) holds and pi denotes the most distant from Ball i relative living on the same tree. If there are several most distant relatives living on the same tree, pi is the id of one with the smallest id. It's guaranteed that the sequence p corresponds to some valid forest. Hacking: To hack someone, you should provide a correct forest as a test. The sequence p will be calculated according to the forest and given to the solution you try to hack as input. Use the following format: In the first line, output the integer n (1 ≤ n ≤ 104) — the number of Balls and the integer m (0 ≤ m < n) — the total number of edges in the forest. Then m lines should follow. The i-th of them should contain two integers ai and bi and represent an edge between vertices in which relatives ai and bi live. For example, the first sample is written as follows: 5 31 23 44 5

You should output the number of trees in the forest where PolandBall lives.

NoteIn the first sample testcase, possible forest is: 1-2 3-4-5. There are 2 trees overall.In the second sample testcase, the only possible graph is one vertex and no edges. Therefore, there is only one tree.

package main

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

func main() {
	n := readi()
	set := make([]int, n)
	for i := range set {
		set[i] = -1
	}
	for i := 0; i < n; i++ {
		b := readi() - 1
		join(set, i, b)
	}
	ans := 0
	for _, val := range set {
		if val < 0 {
			ans++
		}
	}
	fmt.Fprintln(writer, ans)
	writer.Flush()
}

func find(set []int, a int) int {
	if set[a] < 0 {
		return a
	}
	set[a] = find(set, set[a])
	return set[a]
}

func join(set []int, a, b int) {
	a = find(set, a)
	b = find(set, b)
	if a != b {
		if set[a] < set[b] {
			set[a] += set[b]
			set[b] = a
		} else {
			set[b] += set[a]
			set[a] = b
		}
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

package main

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

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

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

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

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

func main() {
	defer w.Flush()
	var n int
	I(&n, "\n")
	var p, a int
	var aa []int
	for i := 1; i <= n; i++ {
		I(&p, " ")
		if p == i {
			a++
		} else {
			flag := true
			for j := 0; j < len(aa); j++ {
				if aa[j] == p {
					flag = false
					break
				}
			}
			if flag {
				aa = append(aa, p)
			}
		}
	}
	a += len(aa) / 2
	O(a, "\n")
}

package main

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

func solve() {
	n := readInt()

	djset := NewDJSet(n)
	for i := 0; i < n; i++ {
		v := readInt() - 1
		if !djset.Equiv(i, v) {
			djset.Union(i, v)
		}
	}

	fmt.Println(djset.Count())
}

type DJSet struct {
	upper []int
}

func NewDJSet(n int) *DJSet {
	s := DJSet{upper: make([]int, n)}
	for i := 0; i < n; i++ {
		s.upper[i] = -1
	}
	return &s
}

func (s *DJSet) Root(x int) int {
	if s.upper[x] < 0 {
		return x
	} else {
		s.upper[x] = s.Root(s.upper[x])
	}
	return s.upper[x]
}

func (s *DJSet) Union(x, y int) bool {
	x = s.Root(x)
	y = s.Root(y)
	if x != y {
		if s.upper[y] < s.upper[x] {
			x, y = y, x
		}
		s.upper[x] += s.upper[y]
		s.upper[y] = x
	}
	return x == y
}

func (s *DJSet) Equiv(x, y int) bool {
	return s.Root(x) == s.Root(y)
}

func (s *DJSet) Upper(y int) int {
	return s.upper[y]
}

func (s *DJSet) Count() int {
	ct := 0
	for _, u := range s.upper {
		if u < 0 {
			ct++
		}
	}
	return ct
}

var scanner *bufio.Scanner

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

// IO

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

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

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

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

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

package main

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

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

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

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

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

func main() {
	defer w.Flush()
	var n int
	I(&n, "\n")
	var p, a int
	s := ""
	aa := 0
	for i := 1; i <= n; i++ {
		I(&p, " ")
		if p == i {
			a++
		} else {
			ss := "~" + strconv.Itoa(p)
			if !strings.Contains(s, ss) {
				s += ss
				aa++
			}
		}
	}
	a += aa / 2
	O(a, "\n")
}

package main

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

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

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

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

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

func main() {
	defer w.Flush()
	var n int
	I(&n, "\n")
	var p, a int
	s := ""
	for i := 1; i <= n; i++ {
		I(&p, " ")
		if p == i {
			a++
		} else {
			ss := "~" + strconv.Itoa(p)
			if !strings.Contains(s, ss) {
				s += ss
			}
		}
	}
	if len(s) > 0 {
		a += len(strings.Split(s[1:], "~")) / 2
	}
	O(a, "\n")
}


There are n students in a class working on group projects. The students will divide into groups (some students may be in groups alone), work on their independent pieces, and then discuss the results together. It takes the i-th student ai minutes to finish his/her independent piece.If students work at different paces, it can be frustrating for the faster students and stressful for the slower ones. In particular, the imbalance of a group is defined as the maximum ai in the group minus the minimum ai in the group. Note that a group containing a single student has an imbalance of 0. How many ways are there for the students to divide into groups so that the total imbalance of all groups is at most k?Two divisions are considered distinct if there exists a pair of students who work in the same group in one division but different groups in the other.

The first line contains two space-separated integers n and k (1 ≤ n ≤ 200, 0 ≤ k ≤ 1000) — the number of students and the maximum total imbalance allowed, respectively. The second line contains n space-separated integers ai (1 ≤ ai ≤ 500) — the time it takes the i-th student to complete his/her independent piece of work.

Print a single integer, the number of ways the students can form groups. As the answer may be large, print its value modulo 109 + 7.

NoteIn the first sample, we have three options:   The first and second students form a group, and the third student forms a group. Total imbalance is 2 + 0 = 2.  The first student forms a group, and the second and third students form a group. Total imbalance is 0 + 1 = 1.  All three students form their own groups. Total imbalance is 0. In the third sample, the total imbalance must be 0, so each student must work individually.