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() {
	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 (
	"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 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, 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 "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"
)

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 (
	"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 "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 (
	"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, 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 "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 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() {
    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 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 (
    "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.")
}


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


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 println(a ...interface{})          { fmt.Fprintln(writer, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func scanString(s *string) { fmt.Fscanln(reader, s) }

var arr [200007]int

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

// return 1 + ... + x
func pa(x int) int64 {
	return int64(x) * (int64(x) + 1)/2
}

func test_case() {
	var n int
	var str string

	scanf("%d\n", &n)
	scanString(&str)

	cnt := 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			cnt++
		}
	}

	pos := -1
	cur := 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			cur++
			if 2 * cur >= cnt {
				pos = i
				break
			}
		}
	}

	if pos == -1 {
		println(0)
		return
	}

	var tot int64 = 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			tot += int64(abs(pos - i))
		}
	}

	if cnt%2 == 1 {
		tot -= 2 * pa(cnt/2)
	} else {
		tot -= pa(cnt/2) + pa(cnt/2 - 1)
	}

	println(tot)
}

func main() {
	defer writer.Flush()
	var t int

	scanf("%d\n", &t)
	for t > 0 {
		test_case()
		t--
	}

}

package main

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

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

	var t, n int
	var s string
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		sheepCnt := 0
		for i := 0; i < n; i++ {
			if s[i] == '*' {
				sheepCnt++
			}
		}
		if sheepCnt == 0 || sheepCnt == n {
			fmt.Println(0)
		} else {
			cnt := calc(s, (sheepCnt+1)/2)
			if sheepCnt%2 == 0 {
				cnt2 := calc(s, sheepCnt/2+1)
				if cnt2 < cnt {
					cnt = cnt2
				}
			}
			fmt.Println(cnt)
		}
	}
}

func calc(s string, centerSheep int) int64 {
	var center int
	for i, j := 0, 0; i < len(s) && j < centerSheep; i++ {
		if s[i] == '*' {
			j++
			center = i
		}
	}
	var cnt int64
	for i, j := 0, 0; i < len(s); i++ {
		if s[i] == '*' {
			j++
			cnt += abs(center + (j - centerSheep) - i)
		}
	}
	return cnt
}

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

package main

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

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

	var t int
	fmt.Fscanln(in, &t)

	for k := 0; k < t; k++ {
		var n int
		var cc string
		fmt.Fscanln(in, &n)
		fmt.Fscanf(in, "%s\n", &cc)

		arr := make([]bool, n)

		for i, c := range cc {
			if c == '*' {
				arr[i] = true
			}
		}

		prefixCnt := make([]int64, n)
		prefixSum := make([]int64, n)

		if arr[0] == true {
			prefixCnt[0] = 1
		}

		for i := 1; i < n; i++ {
			prefixCnt[i] = prefixCnt[i-1]
			prefixSum[i] = prefixSum[i-1]
			if arr[i] == true {
				prefixCnt[i]++
			} else {
				prefixSum[i] += prefixCnt[i-1]
			}
		}

		suffixCnt := make([]int64, n)
		suffixSum := make([]int64, n)

		if arr[n-1] == true {
			suffixCnt[n-1] = 1
		}

		for i := n - 2; i >= 0; i-- {
			suffixCnt[i] = suffixCnt[i+1]
			suffixSum[i] = suffixSum[i+1]
			if arr[i] == true {
				suffixCnt[i]++
			} else {
				suffixSum[i] += suffixCnt[i+1]
			}
		}

		ans := float64(suffixSum[0])

		for i := 1; i < n; i++ {
			version := prefixSum[i-1] + suffixSum[i]
			ans = math.Min(ans, float64(version))
		}

		ans = math.Min(ans, float64(prefixSum[n-1]))

		fmt.Println(int64(ans))
	}
}

package main

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

func run(r io.Reader, w io.Writer) {
	in := bufio.NewReader(r)
	out := bufio.NewWriter(w)
	defer out.Flush()

	var t int
	for	Fscan(in, &t); t > 0; t-- {
		var n int
		Fscan(in, &n)
		var s string
		Fscan(in, &s)

		var positions []int
		for i, c := range s {
			if c == '*' {
				positions = append(positions, i)
			}
		}

		mid := len(positions) / 2
		ans := int64(0)
		for i, val := range positions {
			ans += int64(abs(positions[mid] - val) - abs(mid - i))
		}
		Fprintln(out, ans)
	}
}

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

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

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
}

package main

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

func run(r io.Reader, w io.Writer) {
	in := bufio.NewReader(r)
	out := bufio.NewWriter(w)
	defer out.Flush()

	var t int
	for	Fscan(in, &t); t > 0; t-- {
		var n int
		Fscan(in, &n)
		var s string
		Fscan(in, &s)

		empty, vec := 0, []int{}
		for _, c := range s {
			if c == '.' {
				empty++
			} else {
				vec = append(vec, empty)
			}
		}

		mid := (len(vec)  - 1) / 2
		var ans int64
		for _, val := range vec {
			ans += int64(abs(val - vec[mid]))
		}
		Fprintln(out, ans)
	}
}

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

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

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
}

package main

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

const (
	MOD int = int(1e9 + 7)
)

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

	var t int
	fmt.Fscan(_r, &t)

	for q := 0; q < t; q++ {
		var l int
		fmt.Fscan(_r, &l)
		var line []byte
		var sheep []int
		var numSheep int = 0
		fmt.Fscan(_r, &line)
		for i := 0; i < l; i++ {
			if line[i] == '*' {
				sheep = append(sheep, i-numSheep)
				numSheep++
			}
		}

		var ans int64 = 0

		if numSheep != 0 {
			mean := sheep[numSheep/2]
			for i := 0; i < numSheep; i++ {
				ans += int64(AbsInt(sheep[i] - mean))
			}
		}

		fmt.Fprintf(_w, "%d\n", ans)
	}
}

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

package main

import (
    "fmt"
    "bufio"
    "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 scan(a ...interface{}) { fmt.Fscan(reader, a...) }

func min64(x, y int64) int64 {
    if (x < y) {
        return x
    } else {
        return y
    }
}

func min_moves(str string) int64 {
    var sheep_num int64 = 0
    for _, c := range str {
        if c == '*' {
            sheep_num++
        }
    }
    var sheeps_num_left int64 = 0
    var ans int64 = 0
    for _, c := range str {
        if c == '*' {
            sheeps_num_left++
        } else {
            ans += min64(sheeps_num_left, sheep_num - sheeps_num_left)
        }
    }
    return ans
}

func main() {
    defer writer.Flush()

    var n_tasks int
    scan(&n_tasks)
    for i := 0; i < n_tasks; i++ {
        var strlen int
        scan(&strlen)
        var str string
        scan(&str)
        printf("%d\n", min_moves(str))
    }
}

package main

import (
	"bufio"
	"fmt"
	"math"

	//"math"
	"os"
	"strconv"
	//"strings"
)

func Readln(r *bufio.Reader) (string, error) {
	var (
		isPrefix bool  = true
		err      error = nil
		line, ln []byte
	)
	for isPrefix && err == nil {
		line, isPrefix, err = r.ReadLine()
		ln = append(ln, line...)
	}
	return string(ln), err
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	pk, _ := Readln(reader)
	k, _ := strconv.Atoi(pk)
	for oi := 0; oi < k; oi++ {
		_, err := Readln(reader)
		if err != nil {
			return
		}
		//n, _ := strconv.Atoi(pfl)
		psl,_ :=Readln(reader)
		sheep := make([] int, 0)
		for i:= range psl {
			if psl[i] == '*' {
				sheep = append(sheep, i)
			}
		}
		if len(sheep) < 2 {
			fmt.Println(0)
			continue
		}
		// The median sheep would not make moves?

		median := int(math.Floor(float64(len(sheep))/float64(2)))
		//fmt.Println(median)
		//fmt.Println(sheep)
		res := int64(0)
		for i,v:= range sheep {
			t := int64(v - sheep[median] + median - i)
			if t>0{

				res+=t
			} else  {
				res-=t
			}
		}
		fmt.Println(res)

	}

}

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 println(a ...interface{})          { fmt.Fprintln(writer, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func scanString(s *string)              { fmt.Fscanln(reader, s) }

func abs(x int) int {
	if x >= 0 {
		return x
	}
	return -x
}
func pa(x int) int64 {
	return int64(x) * (int64(x) + 1) / 2
}
func test_case() {
	var n int
	var str string
	scanf("%d\n", &n)
	scanf("%s\n", &str)
	cnt := 0
	for _, x := range str {
		if x == '*' {
			cnt++
		}
	}
	pos := -1
	cur := 0
	for i, x := range str {
		if x == '*' {
			cur++
			if 2*cur >= cnt {
				pos = i
				break
			}
		}
	}
	if pos == -1 {
		println(0)
		return
	}

	var ans int64 = 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			ans += int64(abs(i - pos))
		}
	}
	if cnt%2 == 1 {
		ans -= 2 * pa(cnt/2)
	} else {
		ans -= pa(cnt/2) + pa(cnt/2-1)
	}
	println(ans)
}
func main() {
	defer writer.Flush()
	var t int
	scanf("%d\n", &t)
	for t > 0 {
		test_case()
		t--
	}
}

package main

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

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

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

	var t int

	fmt.Fscanf(reader, "%d\n", &t)
	for ; t > 0; t-- {
		var n int
		var s string
		fmt.Fscanf(reader, "%d\n%s\n", &n, &s)

		var ans, cur, sum int64

		for i := 0; i < n; i++ {
			if s[i] == '*' {
				sum++
			}
		}

		for i := 0; i < n; i++ {
			if s[i] == '*' {
				cur++
			} else {
				ans += min(cur, sum-cur)
			}
		}

		fmt.Println(ans)
	}
}

package main

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

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

	solve := func(Case int) {
		var n int
		var s []byte
		Fscan(in, &n, &s)
		c := bytes.Count(s, []byte{'*'})
		if c <= 1 {
			Fprintln(out, 0)
			return
		}
		mid := 0
		tmp := 0
		for i, b := range s {
			if b == '*' {
				tmp++
				if tmp == (c+1)/2 {
					mid = i
					break
				}
			}
		}
		cc := 0
		ans := int64(0)
		for i := mid-1; i >= 0; i-- {
			if s[i] == '.' {
				cc++
			} else {
				ans+=int64(cc)
			}
		}
		cc=0
		for i := mid+1; i <n; i++ {
			if s[i] == '.' {
				cc++
			} else {
				ans+=int64(cc)
			}
		}
		Fprintln(out, ans)
	}

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

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

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

package main

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

func ReadInt() int {
	var i int
	_, err := fmt.Scanf("%d", &i)
	if err != nil {
		panic(err)
	}
	return i
}

func ReadByte() byte {
	return ReadBytes(1)[0]
}

func ReadNL() byte {
	var nl byte
	for nl != 0x0a {
		nl = ReadByte()
	}
	return nl
}

func ReadBytes(n int) []byte {
	p := make([]byte, n)
	_, err := io.ReadFull(os.Stdin, p)
	if err != nil {
		panic(err)
	}
	return p
}

func main() {
	total := ReadInt()
	for i := 0; i < total; i++ {
		ReadNL()
		l := ReadInt()
		ReadNL()
		line := ReadBytes(l)
		var sheeps int
		for _, s := range line {
			if s == 42 {
				sheeps += 1
			}
		}
		var sum int
		var median int
		for i, s := range line {
			if s == 42 {
				if sum >= sheeps/2 {
					median = i
					break
				} else {
					sum++
				}
			}
		}

		var total int64

		var beg int
		var end int

		for i, s := range line {
			if s == 42 {
				if i < median {
					total += int64(median - i)
					total -= int64(sum - beg)
					beg++
				} else if i > median {
					total += int64(i - median)
					total -= int64(end + 1)
					end++
				}
			}
		}

		fmt.Println(total)

	}
}

package main

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

func ReadInt() int {
	var i int
	_, err := fmt.Scanf("%d", &i)
	if err != nil {
		panic(err)
	}
	return i
}

func ReadByte() byte {
	return ReadBytes(1)[0]
}

func ReadNL() byte {
	var nl byte
	for nl != 0x0a {
		nl = ReadByte()
	}
	return nl
}

func ReadBytes(n int) []byte {
	p := make([]byte, n)
	_, err := io.ReadFull(os.Stdin, p)
	if err != nil {
		panic(err)
	}
	return p
}

func main() {
	total := ReadInt()
	for i := 0; i < total; i++ {
		ReadNL()
		l := ReadInt()
		ReadNL()
		line := ReadBytes(l)
		var sheeps int
		for _, s := range line {
			if s == 42 {
				sheeps += 1
			}
		}
		var sum int
		var median int
		for i, s := range line {
			if s == 42 {
				if sum >= sheeps/2 {
					median = i
					break
				} else {
					sum++
				}
			}
		}

		var total int

		var beg int
		var end int

		for i, s := range line {
			if s == 42 {
				if i < median {
					total += median - i
					total -= sum - beg
					beg++
				} else if i > median {
					total += i - median
					total -= end + 1
					end++
				}
			}
		}

		fmt.Println(total)

	}
}

package main

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

func ReadInt() int {
	var i int
	_, err := fmt.Scanf("%d", &i)
	if err != nil {
		panic(err)
	}
	return i
}

func ReadByte() byte {
	return ReadBytes(1)[0]
}

func ReadNL() byte {
	var nl byte
	for nl != 0x0a {
		nl = ReadByte()
	}
	return nl
}

func ReadBytes(n int) []byte {
	p := make([]byte, n)
	_, err := io.ReadFull(os.Stdin, p)
	if err != nil {
		panic(err)
	}
	return p
}

func main() {
	total := ReadInt()
	for i := 0; i < total; i++ {
		ReadNL()
		l := ReadInt()
		ReadNL()
		line := ReadBytes(l)
		var sheeps int
		for _, s := range line {
			if s == 42 {
				sheeps += 1
			}
		}
		var sum int
		var median int
		for i, s := range line {
			if s == 42 {
				if sum >= sheeps/2 {
					median = i
					break
				} else {
					sum++
				}
			}
		}

		var total int

		for i, s := range line {
			if s == 42 {
				if i < median {
					total += median - i
				} else if i > median {
					total += i - median
				}
			}
		}

		total -= (sum)*(sum+1)/2 + (sheeps-sum-1)*(sheeps-sum)/2

		fmt.Println(total)

	}
}

package main

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

func ReadInt() int {
	var i int
	_, err := fmt.Scanf("%d", &i)
	if err != nil {
		panic(err)
	}
	return i
}

func ReadByte() byte {
	return ReadBytes(1)[0]
}

func ReadNL() byte {
	var nl byte
	for nl != 0x0a {
		nl = ReadByte()
	}
	return nl
}

func ReadBytes(n int) []byte {
	p := make([]byte, n)
	_, err := io.ReadFull(os.Stdin, p)
	if err != nil {
		panic(err)
	}
	return p
}

func main() {
	total := ReadInt()
	for i := 0; i < total; i++ {
		ReadNL()
		l := ReadInt()
		ReadNL()
		line := ReadBytes(l)
		var sheeps int
		for _, s := range line {
			if s == 42 {
				sheeps += 1
			}
		}
		var sum int
		var median int
		for i, s := range line {
			if s == 42 {
				if sum >= sheeps/2 {
					median = i
					break
				} else {
					sum++
				}
			}
		}

		var total int

		for i, s := range line {
			if s == 42 {
				if i < median {
					total += median - i
				} else if i > median {
					total += i - median
				}
			}

			if i < median && i >= median-sum {
				total += median - i
			} else if i > median && i <= median+(sheeps-sum-1) {
				total -= i - median
			}
		}

		fmt.Println(total)

	}
}

package main

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

func ReadInt() int {
	var i int
	_, err := fmt.Scanf("%d", &i)
	if err != nil {
		panic(err)
	}
	return i
}

func ReadByte() byte {
	return ReadBytes(1)[0]
}

func ReadNL() byte {
	var nl byte
	for nl != 0x0a {
		nl = ReadByte()
	}
	return nl
}

func ReadBytes(n int) []byte {
	p := make([]byte, n)
	_, err := io.ReadFull(os.Stdin, p)
	if err != nil {
		panic(err)
	}
	return p
}

func main() {
	total := ReadInt()
	for i := 0; i < total; i++ {
		ReadNL()
		l := ReadInt()
		ReadNL()
		line := ReadBytes(l)
		var sheeps int
		for _, s := range line {
			if s == 42 {
				sheeps += 1
			}
		}
		var sum int
		var median int
		for i, s := range line {
			if s == 42 {
				if sum >= sheeps/2 {
					median = i
					break
				} else {
					sum++
				}
			}
		}

		var total int

		for i, s := range line {
			if s == 42 {
				if i < median {
					total += median - i
				} else if i > median {
					total += i - median
				}
			}

			if i < median && i >= median-sum {
				total -= median - i
			} else if i > median && i <= median+(sheeps-sum-1) {
				total -= i - median
			}
		}

		fmt.Println(total)

	}
}

package main

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

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

	var t, n int
	var s string
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		sheepCnt := 0
		for i := 0; i < n; i++ {
			if s[i] == '*' {
				sheepCnt++
			}
		}
		if sheepCnt == 0 || sheepCnt == n {
			fmt.Println(0)
		} else {
			cnt := calc(s, (sheepCnt+1)/2)
			if sheepCnt%2 == 0 {
				cnt2 := calc(s, sheepCnt/2+1)
				if cnt2 < cnt {
					cnt = cnt2
				}
			}
			fmt.Println(cnt)
		}
	}
}

func calc(s string, centerSheep int) int {
	var center int
	for i, j := 0, 0; i < len(s) && j < centerSheep; i++ {
		if s[i] == '*' {
			j++
			center = i
		}
	}
	cnt := 0
	for i, j := 0, 0; i < len(s); i++ {
		if s[i] == '*' {
			j++
			cnt += abs(center + (j - centerSheep) - i)
		}
	}
	return cnt
}

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

package main

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

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

	var t, n int
	var s string
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		sheepCnt := 0
		for i := 0; i < n; i++ {
			if s[i] == '*' {
				sheepCnt++
			}
		}
		if sheepCnt == 1 || sheepCnt == n {
			fmt.Println(0)
		} else {
			cnt := calc(s, (sheepCnt+1)/2)
			if sheepCnt%2 == 0 {
				cnt2 := calc(s, sheepCnt/2+1)
				if cnt2 < cnt {
					cnt = cnt2
				}
			}
			fmt.Println(cnt)
		}
	}
}

func calc(s string, centerSheep int) int {
	var center int
	for i, j := 0, 0; i < len(s) && j < centerSheep; i++ {
		if s[i] == '*' {
			j++
			center = i
		}
	}
	cnt := 0
	for i, j := 0, 0; i < len(s); i++ {
		if s[i] == '*' {
			j++
			cnt += abs(center + (j - centerSheep) - i)
		}
	}
	return cnt
}

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

package main

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

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

	var t, n int
	var s string
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		fmt.Fscan(in, &n)
		fmt.Fscan(in, &s)
		sheepCnt := 0
		for i := 0; i < n; i++ {
			if s[i] == '*' {
				sheepCnt++
			}
		}
		if sheepCnt == 1 || sheepCnt == n {
			fmt.Println(0)
		} else {
			cnt := calc(s, (sheepCnt+1)/2)
			if sheepCnt%2 == 0 {
				cnt2 := calc(s, sheepCnt/2+1)
				if cnt2 > cnt {
					cnt = cnt2
				}
			}
			fmt.Println(cnt)
		}
	}
}

func calc(s string, centerSheep int) int {
	var center int
	for i, j := 0, 0; i < len(s) && j < centerSheep; i++ {
		if s[i] == '*' {
			j++
			center = i
		}
	}
	cnt := 0
	for i, j := 0, 0; i < len(s); i++ {
		if s[i] == '*' {
			j++
			cnt += abs(center + (j - centerSheep) - i)
		}
	}
	return cnt
}

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

package main

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

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

	var t int
	fmt.Fscanln(in, &t)

	for k := 0; k < t; k++ {
		var n int
		var cc string
		fmt.Fscanln(in, &n)
		fmt.Fscanf(in, "%s\n", &cc)

		arr := make([]bool, n)

		for i, c := range cc {
			if c == '*' {
				arr[i] = true
			}
		}

		prefixCnt := make([]int, n)
		prefixSum := make([]int, n)

		if arr[0] == true {
			prefixCnt[0] = 1
		}

		for i := 1; i < n; i++ {
			prefixCnt[i] = prefixCnt[i-1]
			prefixSum[i] = prefixSum[i-1]
			if arr[i] == true {
				prefixCnt[i]++
			} else {
				prefixSum[i] += prefixCnt[i-1]
			}
		}

		suffixCnt := make([]int, n)
		suffixSum := make([]int, n)

		if arr[n-1] == true {
			suffixCnt[n-1] = 1
		}

		for i := n - 2; i >= 0; i-- {
			suffixCnt[i] = suffixCnt[i+1]
			suffixSum[i] = suffixSum[i+1]
			if arr[i] == true {
				suffixCnt[i]++
			} else {
				suffixSum[i] += suffixCnt[i+1]
			}
		}

		ans := float64(suffixSum[0])

		for i := 1; i < n; i++ {
			version := prefixSum[i-1] + suffixSum[i]
			ans = math.Min(ans, float64(version))
		}

		ans = math.Min(ans, float64(prefixSum[n-1]))

		fmt.Println(int64(ans))
	}
}

package main

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

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

	var t int
	fmt.Fscanln(in, &t)

	for k := 0; k < t; k++ {
		var n int
		var cc string
		fmt.Fscanln(in, &n)
		fmt.Fscanf(in, "%s\n", &cc)

		arr := make([]bool, n)

		for i, c := range cc {
			if c == '*' {
				arr[i] = true
			}
		}

		prefixCnt := make([]int, n)
		prefixSum := make([]int, n)

		if arr[0] == true {
			prefixCnt[0] = 1
		}

		for i := 1; i < n; i++ {
			prefixCnt[i] = prefixCnt[i-1]
			prefixSum[i] = prefixSum[i-1]
			if arr[i] == true {
				prefixCnt[i]++
			} else {
				prefixSum[i] += prefixCnt[i-1]
			}
		}

		suffixCnt := make([]int, n)
		suffixSum := make([]int, n)

		if arr[n-1] == true {
			suffixCnt[n-1] = 1
		}

		for i := n - 2; i >= 0; i-- {
			suffixCnt[i] = suffixCnt[i+1]
			suffixSum[i] = suffixSum[i+1]
			if arr[i] == true {
				suffixCnt[i]++
			} else {
				suffixSum[i] += suffixCnt[i+1]
			}
		}

		ans := float64(suffixSum[0])

		for i := 1; i < n; i++ {
			version := prefixSum[i-1] + suffixSum[i]
			ans = math.Min(ans, float64(version))
		}

		fmt.Println(int64(ans))
	}
}

package main

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

const (
	MOD int = int(1e9 + 7)
)

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

	var t int
	fmt.Fscan(_r, &t)

	for q := 0; q < t; q++ {
		var l int
		fmt.Fscan(_r, &l)
		var line []byte
		var sheep []int
		var numSheep int = 0
		fmt.Fscan(_r, &line)
		for i := 0; i < l; i++ {
			if line[i] == '*' {
				sheep = append(sheep, i-numSheep)
				numSheep++
			}
		}

		var ans int = 0

		if numSheep != 0 {
			mean := sheep[numSheep/2]
			for i := 0; i < numSheep; i++ {
				ans += AbsInt(sheep[i] - mean)
			}
		}

		fmt.Fprintf(_w, "%d\n", ans)
	}
}

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

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 println(a ...interface{})          { fmt.Fprintln(writer, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }
func scanString(s *string) { fmt.Fscanln(reader, s) }

var arr [200007]int

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

// return 1 + ... + x
func pa(x int) int64 {
	return int64(x) * (int64(x) + 1)/2
}

func test_case() {
	var n int
	var str string

	scanf("%d\n", &n)
	scanString(&str)

	cnt := 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			cnt++
		}
	}

	pos := -1
	cur := 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			cur++
			if 2 * cur >= cnt {
				pos = i
				break
			}
		}
	}

	if pos == -1 {
		println(0)
		return
	}

	println("pos", pos)

	var tot int64 = 0
	for i := 0; i < n; i++ {
		if str[i] == '*' {
			tot += int64(abs(pos - i))
		}
	}

	if cnt%2 == 1 {
		tot -= 2 * pa(cnt/2)
	} else {
		tot -= pa(cnt/2) + pa(cnt/2 - 1)
	}

	println(tot)
}

func main() {
	defer writer.Flush()
	var t int

	scanf("%d\n", &t)
	for t > 0 {
		test_case()
		t--
	}

}