Monocarp and Bicarp live in Berland, where every bus ticket consists of $n$ digits ($n$ is an even number). During the evening walk Monocarp and Bicarp found a ticket where some of the digits have been erased. The number of digits that have been erased is even.

Monocarp and Bicarp have decided to play a game with this ticket. Monocarp hates happy tickets, while Bicarp collects them. A ticket is considered happy if the sum of the first $\frac{n}{2}$ digits of this ticket is equal to the sum of the last $\frac{n}{2}$ digits.

Monocarp and Bicarp take turns (and Monocarp performs the first of them). During each turn, the current player must replace any erased digit with any digit from $0$ to $9$. The game ends when there are no erased digits in the ticket.

If the ticket is happy after all erased digits are replaced with decimal digits, then Bicarp wins. Otherwise, Monocarp wins. You have to determine who will win if both players play optimally.


-----Input-----

The first line contains one even integer $n$ $(2 \le n \le 2 \cdot 10^{5})$ — the number of digits in the ticket.

The second line contains a string of $n$ digits and "?" characters — the ticket which Monocarp and Bicarp have found. If the $i$-th character is "?", then the $i$-th digit is erased. Note that there may be leading zeroes. The number of "?" characters is even.


-----Output-----

If Monocarp wins, print "Monocarp" (without quotes). Otherwise print "Bicarp" (without quotes).


-----Examples-----
Input
4
0523

Output
Bicarp

Input
2
??

Output
Bicarp

Input
8
?054??0?

Output
Bicarp

Input
6
???00?

Output
Monocarp



-----Note-----

Since there is no question mark in the ticket in the first example, the winner is determined before the game even starts, and it is Bicarp.

In the second example, Bicarp also wins. After Monocarp chooses an erased digit and replaces it with a new one, Bicap can choose another position with an erased digit and replace it with the same digit, so the ticket is happy.

Difficulty: interview

Starter code:

Solutions:
n=int(input())
s=input()
left=0
right=0
left_ques=0
right_ques=0
for i in range(n):
    if i<n//2:
        if s[i]=='?':
            left_ques+=1
        else :
            left+=int(s[i])
    else :
        if s[i]=='?':
            right_ques+=1
        else :
            right+=int(s[i])
x=min(left_ques,right_ques)
left_ques-=x
right_ques-=x
if left_ques==0 and right_ques==0:
    if left==right:
        print("Bicarp")
    else :
        print("Monocarp")
else :
    if left_ques==0:
        if right_ques%2==0:
            x=9*(right_ques//2)+right
            if x==left:
                print("Bicarp")
            else :
                print("Monocarp")
        else :
            print("Monocarp")
    else :
        if left_ques%2==0:
            x=9*(left_ques//2)+left
            if x==right:
                print("Bicarp")
            else :
                print("Monocarp")
        else :
            print("Monocarp")

n = int(input())
a = input()
if a.count('?') % 2 == 1:
    print('Monocarp')
else:
    x = y = k = m = 0
    for q in range(n):
        if q*2 < n:
            if a[q] == '?':
                k += 1
            else:
                x += int(a[q])
        else:
            if a[q] == '?':
                m += 1
            else:
                y += int(a[q])
    if (y - x) % 9 == 0 and (y - x) // 9 == (k-m)//2:
        print('Bicarp')
    else:
        print('Monocarp')


import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
def lis():return [int(i) for i in input().split()]
def value():return int(input())


n=value()
a=input().strip('\n')
l1,l2=a[:(n//2)].count('?'),a[(n//2):].count('?')
s1 = s2 = 0
for i in range(len(a)):
    if i<n//2:
        s1+=int(a[i]) if a[i]!='?' else 0
    else:
        s2+=int(a[i]) if a[i]!='?' else 0
no = 1
for i in range(l1):
    if s1>s2:
        if no:
            s1+=9
        else:s1+=0
    else:
        if no:
            s1+=0
        else:s1+=9
    no = 1 - no
for i in range(l2):
    if s1>s2:
        if no:
            s2+=0
        else:s2+=9
    else:
        if no:
            s2+=9
        else:s2+=0
    no = 1 - no
if s1!=s2:print('Monocarp')
else:print('Bicarp')
            


import sys

n = int(sys.stdin.readline().strip())
m = n // 2
s = sys.stdin.readline().strip()
s1 = 0
s2 = 0
x1 = 0
x2 = 0
for i in range (0, m):
    if s[i] == "?":
        x1 = x1 + 1
    else:
        s1 = s1 + int(str(s[i]))
    if s[m+i] == "?":
        x2 = x2 + 1
    else:
        s2 = s2 + int(str(s[m+i]))
if s1 + (x1 // 2) * 9 == s2 + (x2 // 2) * 9:
    print("Bicarp")
else:
    print("Monocarp")
    


import sys 
from collections import defaultdict
input = lambda : sys.stdin.readline().rstrip()

n = int(input())
s = input()

sa = 0
sb = 0
a = 0
b = 0


for i in range(n):
  if s[i] == '?':
    if i < n // 2:
      a += 1
    else:
      b += 1
  else:
    if i < n // 2:
      sa += int(s[i])
    else:
      sb += int(s[i])

M = "Monocarp"
B = "Bicarp"


if sa == sb:
  if a == b:
    print(B)
    return
  else:
    print(M)
    return

if sa <= sb:
  sa, sb = sb, sa
  a, b = b, a

if a == b:
  print(M)
  return

elif a > b:
  print(M)
  return

else:
  diff = sa - sb
  x = (b - a) // 2
  #print("debug", diff, x)
  if diff == 9*x:
    print(B)
    return
  else:
    print(M)
    return



def f(q1, q2, k1, k2):
    res1 = res2 = 0
    res1 += ((q1 + 1) // 2) * k1
    res1 += (q1 // 2) * k2
    res2 += (q2 // 2) * k2
    res2 += ((q2 + 1) // 2) * k1
    return [res1, res2]


n = int(input())
s = input()
sum_l = sum_r = 0
ql = qr = 0
for i in range(n // 2):
    if s[i] == '?':
        ql += 1
    else:
        sum_l += int(s[i])
for i in range(n // 2, n):
    if s[i] == '?':
        qr += 1
    else:
        sum_r += int(s[i])
mn = float('inf')
mx = float('inf')
kek = [f(ql, qr, 0, 9), f(ql, qr, 9, 0), f(qr, ql, 9, 0)[::-1], f(qr, ql, 0, 9)[::-1]]
lol = []
for x in kek:
    lol.append(x[0] + sum_l - x[1] - sum_r)
lol.sort()
if lol[0] <= 0 <= lol[-1]:
    print('Bicarp')
else:
    print('Monocarp')


n = int(input())
s = input()
r, delta = 0, 0

for i in range(n // 2):
    if s[i] == '?':
        r += 1
    else:
        delta += int(s[i])
for i in range(n // 2, n):
    if s[i] == '?':
        r -= 1
    else:
        delta -= int(s[i])

if r < 0:
    r = -r
    delta = -delta

if delta + 9 * r // 2 == 0:
    print('Bicarp')
else:
    print('Monocarp')

n = int(input())
s = input()
s1 = s[:n//2]
s2 = s[n//2:]
sum1 = sum(map(int, filter(str.isdigit, s1)))
sum2 = sum(map(int, filter(str.isdigit, s2)))
free1 = s1.count("?")
free2 = s2.count("?")
ans = ""
if free1 == free2:
    if sum1 == sum2:
        ans = "Bicarp"
    else:
        ans = "Monocarp"
else:
    if sum1 > sum2:
        free1, free2 = free2, free1
        sum1, sum2 = sum2, sum1
    if free1 <= free2:
        ans = "Monocarp"
    else:
        if (free1 - free2) // 2 * 9 == sum2 - sum1:
            ans = "Bicarp"
        else:
            ans = "Monocarp"
print(ans)

 

n=int(input())
inp=input()
sl,sr,qr,ql=0,0,0,0


for i in range(len(inp)//2):
    if inp[i]=='?':
        ql+=1
    else:
        sl+=int(inp[i])

for i in range(n//2, n):
    if inp[i]=='?':
        qr+=1
    else:
        sr+=int(inp[i])



if(sl-sr==9*(qr-ql)/2):
    print('Bicarp')
else:
    print('Monocarp')


n=int(input())
ticket=input()
left=right=diff=0
for i in range(n//2):
    if ticket[i] == '?':
        left += 1
    else:
        diff += int(ticket[i])
for i in range(n//2,n):
    if ticket[i] == '?':
        right += 1
    else:
        diff -= int(ticket[i])

if left > right:
    temp = left
    left = right
    right = temp
    diff = -diff

bad = ((right-left)//2)*9
if diff == bad:
    print("Bicarp")
else:
    print("Monocarp")


import math
import sys
import collections


# imgur.com/Pkt7iIf.png

def getdict(n):
    d = {}
    if type(n) is list:
        for i in n:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
    else:
        for i in range(n):
            t = ii()
            if t in d:
                d[t] += 1
            else:
                d[t] = 1
    return d
def sieve(n):
    prime = [True for i in range(n + 1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 1
    prime[0] = prime[1] = False
    r = [p for p in range(n + 1) if prime[p]]
    return r
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep = ' '): print(sep.join(map(str, a)))

n = ii()
s = input()
l = r = tl = tr = 0
for i in s[:n//2]:
    if i == '?':
        tl+=1
    else:
        l += int(i)
for i in s[n//2:]:
    if i == '?':
        tr+=1
    else:
        r += int(i)

if tl == tr == 0:
    print('Bicarp') if l == r else print('Monocarp')
    return

if l + cdiv(tl, 2)*9 - r > cdiv(tr, 2)*9 or r + cdiv(tr, 2)*9 - l > cdiv(tl, 2)*9:
    print('Monocarp')
else:
    print('Bicarp')

n = int(input())
x = input()

def f(x):
    q, s = 0, 0
    for c in x:
        if c == '?':
            q += 1
        else:
            s += int(c)
    return q, s

lq, ls = f(x[:n//2])
rq, rs = f(x[n//2:])

lmin = ls
lmax = ls + 9*lq

rmin = rs
rmax = rs + 9*rq

lc = lmin+lmax
rc = rmin+rmax

if lc == rc and (lq+rq)%2 == 0:
    print("Bicarp")
else:
    print("Monocarp")


''' CODED WITH LOVE BY SATYAM KUMAR '''

from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys

sys.setrecursionlimit(10 ** 6)  # max depth of recursion
threading.stack_size(2 ** 27)  # new thread will get stack of such size
fac_warm_up = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7


class MergeFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n
        self.lista = [[_] for _ in range(n)]

    def find(self, a):
        to_update = []
        while a != self.parent[a]:
            to_update.append(a)
            a = self.parent[a]
        for b in to_update:
            self.parent[b] = a
        return self.parent[a]

    def merge(self, a, b):
        a = self.find(a)
        b = self.find(b)
        if a == b:
            return
        if self.size[a] < self.size[b]:
            a, b = b, a
        self.num_sets -= 1
        self.parent[b] = a
        self.size[a] += self.size[b]
        self.lista[a] += self.lista[b]

    def set_size(self, a):
        return self.size[self.find(a)]

    def __len__(self):
        return self.num_sets


def display(string_to_print):
    stdout.write(str(string_to_print) + "\n")


def prime_factors(n):  # n**0.5 complex
    factors = dict()
    for i in range(2, math.ceil(math.sqrt(n)) + 1):
        while n % i == 0:
            if i in factors:
                factors[i] += 1
            else:
                factors[i] = 1
            n = n // i
    if n > 2:
        factors[n] = 1
    return (factors)


def all_factors(n):
    return set(reduce(list.__add__,
                      ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))


def fibonacci_modP(n, MOD):
    if n < 2: return 1
    return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(
        fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD


def factorial_modP_Wilson(n, p):
    if (p <= n):
        return 0
    res = (p - 1)
    for i in range(n + 1, p):
        res = (res * cached_fn(InverseEuler, i, p)) % p
    return res


def binary(n, digits=20):
    b = bin(n)[2:]
    b = '0' * (digits - len(b)) + b
    return b


def is_prime(n):
    """Returns True if n is prime."""
    if n < 4:
        return True
    if n % 2 == 0:
        return False
    if n % 3 == 0:
        return False
    i = 5
    w = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += w
        w = 6 - w
    return True


def generate_primes(n):
    prime = [True for i in range(n + 1)]
    p = 2
    while p * p <= n:
        if prime[p]:
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 1
    return prime


factorial_modP = []


def warm_up_fac(MOD):
    nonlocal factorial_modP, fac_warm_up
    if fac_warm_up: return
    factorial_modP = [1 for _ in range(fac_warm_up_size + 1)]
    for i in range(2, fac_warm_up_size):
        factorial_modP[i] = (factorial_modP[i - 1] * i) % MOD
    fac_warm_up = True


def InverseEuler(n, MOD):
    return pow(n, MOD - 2, MOD)


def nCr(n, r, MOD):
    nonlocal fac_warm_up, factorial_modP
    if not fac_warm_up:
        warm_up_fac(MOD)
        fac_warm_up = True
    return (factorial_modP[n] * (
                (pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD)) % MOD)) % MOD


def test_print(*args):
    if testingMode:
        print(args)


def display_list(list1, sep=" "):
    stdout.write(sep.join(map(str, list1)) + "\n")


def display_2D_list(li):
    for i in li:
        print(i)


def prefix_sum(li):
    sm = 0
    res = []
    for i in li:
        sm += i
        res.append(sm)
    return res


def get_int():
    return int(stdin.readline().strip())


def get_tuple():
    return map(int, stdin.readline().split())


def get_list():
    return list(map(int, stdin.readline().split()))


memory = dict()


def clear_cache():
    nonlocal memory
    memory = dict()


def cached_fn(fn, *args):
    nonlocal memory
    if args in memory:
        return memory[args]
    else:
        result = fn(*args)
        memory[args] = result
        return result


def ncr(n, r):
    return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))


def binary_search(i, li):
    fn = lambda x: li[x] - x // i
    x = -1
    b = len(li)
    while b >= 1:
        while b + x < len(li) and fn(b + x) > 0:  # Change this condition 2 to whatever you like
            x += b
        b = b // 2
    return x


# -------------------------------------------------------------- MAIN PROGRAM


TestCases = False
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False  # Can not be used clubbed with TestCases WHen using recursive functions, use Python 3


def main():
    n = get_int()
    st = list(stdin.readline().strip())
    ls,rs,lq,rq=0,0,0,0
    for i in range(n//2):
        if st[i]=='?':
            lq+=1
        else:
            ls+=int(st[i])
    for i in range(n//2,n):
        if st[i]=='?':
            rq+=1
        else:
            rs+=int(st[i])
    if (lq+rq)%2==0 and ((lq-rq)//2)*9 + ls == rs:
        print("Bicarp")
    else:
        print("Monocarp")

# --------------------------------------------------------------------- END=


if TestCases:
    for i in range(get_int()):
        main()
else:
    main() if not optimise_for_recursion else threading.Thread(target=main).start()

N = int(input())
L = 0
R = 0
lq = 0
rq = 0
TK = input()

for i in range(N//2):
    if TK[i] == '?':
        lq += 1
    else:
        L += int(TK[i])

for i in range(N//2, N):
    if TK[i] == '?':
        rq += 1
    else:
        R += int(TK[i])

if lq == rq:
    if L == R:
        print('Bicarp')
    else:
        print('Monocarp')

t = abs(lq - rq)

if lq > rq:
    R -= L
    if R < 0:
        print('Monocarp')
    else:
        if (t//2) * 9 == R:
            print('Bicarp')
        else:
            print('Monocarp')

if lq < rq:
    L -= R
    if L < 0:
        print('Monocarp')
    else:
        if (t // 2) * 9 == L:
            print('Bicarp')
        else:
            print('Monocarp')

n = int(input())
s = input()

lsum = lcount = rsum = rcount = 0
for ch in s[:n//2]:
    if ch == '?':
        lcount += 1
    else:
        lsum += int(ch)

for ch in s[n//2:]:
    if ch == '?':
        rcount += 1
    else:
        rsum += int(ch)

if lcount > rcount:
    delta = rsum - lsum
    count = lcount - rcount
else:
    delta = lsum - rsum
    count = rcount - lcount
if delta == (count//2)*9:
    print('Bicarp')
else:
    print('Monocarp')

n = int(input())
s = input()
fer = 0
f = 0
l = 0
ler = 0
for i in range(int(n/2)):
    if s[i] == '?':
        fer += 1
    else:
        f += int(s[i])
for i in range(int(n/2),n):
    if s[i] == '?':
        ler += 1
    else:
        l += int(s[i])
if (fer + ler) %2:
    print('Monocarp')
else:
    if f < l:
        if l-f == 9*((fer-ler)/2):
            print('Bicarp')
        else:
            print('Monocarp')
    else:
        if f-l == 9*((ler-fer)/2):
            print('Bicarp')
        else:
            print('Monocarp')

n = int(input())
s = input()
p1 = 0
p2 = 0
s1 = 0
s2 = 0
for i in s[:n // 2]:
    if i == '?':
        p1 += 1
    else:
        s1 += int(i)
        
for i in s[n // 2:]:
    if i == '?':
        p2 += 1
    else:
        s2 += int(i)
if s1 < s2:
    buf = p1
    p1 = p2
    p2 = buf
    buf = s1
    s1 = s2
    s2 = buf
if p1 > p2:
    print('Monocarp')
else:
    p = abs(p1 - p2)
    ss = abs(s1 - s2)
    if ss == (p // 2) * 9:
        print('Bicarp')
    else:
        print('Monocarp')


I = lambda : int(input())
SI = lambda : input()
M = "Monocarp"; B = "Bicarp"
def solve(n,s):
	lsum = 0
	cl = 0
	rsum = 0
	cr = 0

	for i in range(n//2):
		if(s[i]=='?'):
			cl+=1
		else:
			lsum+=int(s[i])

	for i in range(n//2,n):
		if(s[i]=='?'):
			cr+=1
		else:
			rsum+=int(s[i])

	dif = lsum-rsum
	if(dif==0):
		if(cl==cr):print(B)
		else: print(M)
		return
	if(cl==cr):
		print(M)
		return
	if((dif>0 and cl>cr) or (dif<0 and cl<cr)):
		print(M)
		return

	#Casos dif<0 y cl>cr
	if(dif>0):
		dif= -dif
		cl,cr = cr,cl
	difc = cl-cr 
	if(dif+difc//2*9==0):
		print(B)
	else:
		print(M)








	










n = I()
s = SI()
solve(n,s)

n=int(input())
arr=input()
lsum=0
rsum=0
lq=0
rq=0
for i in range(n//2):
    if(arr[i]=='?'):
        lq+=1
    else:
        lsum+=int(arr[i])

for i in range(n//2,n):
    if(arr[i]=='?'):
        rq+=1
    else:
        rsum+=int(arr[i])
#if(lsum==rsum and lq==rq):
#    print("Bicarp")
if((lq+rq)%2==1):
    print("Monocarp")
elif((lsum-rsum)//9==(rq-lq)//2 and (lsum-rsum)%9==0):
    print("Bicarp")
elif((rsum-lsum)//9==(lq-rq)//2 and (rsum-lsum)%9==0):
    print("Bicarp")
else:
    print("Monocarp")
    
    
    


n = int(input())
a, b1, b2 = [], [], []

for i, j in enumerate(input()):
	if j == '?':
		if i < n // 2:
			b1.append(i)
		else:
			b2.append(i)
		a.append(0)
	else:
		a.append(int(j))


s1 = sum(a[:n // 2])
s2 = sum(a[n // 2:])


print('Bicarp' if s1 + 9 * (len(b1) + 1) // 2 == s2 + 9 * (len(b2) + 1) // 2 else 'Monocarp')

def winner(s, n):
    s1 = s[:n//2]
    s2 = s[n//2:]
    turns = s.count('?') // 2
    l1 = r1 = l2 = r2 = 0
    for c in s1:
        if c == '?':
            r1 += 9
        else:
            l1 += int(c)
            r1 += int(c)
    for c in s2:
        if c == '?':
            r2 += 9
        else:
            l2 += int(c)
            r2 += int(c)
    if r1 < l2 or r2 < l1:
        return 'True'
    minDif = min(r1 - l2, r2 - l1)
    return minDif < turns * 9


n = int(input())
s = input()
print('Monocarp' if winner(s, n) else 'Bicarp')


o = input()
inp = input()
count_1 = 0
sum_1 = 0
count_2 = 0
sum_2 = 0
for i in range(len(inp)//2):
    if inp[i] == '?':
        count_1 += 1
    else:
        sum_1 += int(inp[i])
        
for j in range(len(inp)//2):
    i = len(inp) // 2 + j
    if inp[i] == '?':
        count_2 += 1
    else:
        sum_2 += int(inp[i])

# print(count_1, sum_1, count_2, sum_2)
if sum_2-sum_1 == 9*(count_1-count_2)//2:
    print('Bicarp')
else:
    print('Monocarp')


n=int(input())

s=input()

sum1=0
kol1=0
sum2=0
kol2=0

for i in range(n//2):
    if s[i]=='?':
        kol1+=1
    else:
        sum1+=int(s[i])

for i in range(n//2,n):
    if s[i]=='?':
        kol2+=1
    else:
        sum2+=int(s[i])

if sum1>sum2:
    sum1,sum2,kol1,kol2=sum2,sum1,kol2,kol1



if sum1==sum2 and kol1==kol2:
    print('Bicarp')
elif sum1==sum2 and kol1!=kol2:
    print('Monocarp')
elif (sum2-sum1)%9!=0:
    print('Monocarp')
elif kol1==kol2==0:
    print('Monocarp')
elif (sum2-sum1)//9==(kol1-kol2)//2:
    print('Bicarp')
else:
    print('Monocarp')


#585_D

n = int(input())

ln = list(input())

sm1 = 0
sm2 = 0
qs1 = 0
qs2 = 0

for i in range(0, n // 2):
    if ln[i] != "?":
        qs1 += 1
        sm1 += int(ln[i])
    if ln[n // 2 + i] != "?":
        qs2 += 1
        sm2 += int(ln[n // 2 + i])

qs1 = n // 2 - qs1
qs2 = n // 2 - qs2
qs = qs1 + qs2

m = False

if not qs:
    if sm1 != sm2:
        m = True

mx = sm1 + min(qs1, qs // 2) * 9
lft = min(qs2, qs2 - ((qs // 2) - qs1))
if mx > lft * 9 + sm2:
    m = True

mx = sm2 + min(qs2, qs // 2) * 9
lft = min(qs1, qs1 - ((qs // 2) - qs2))
if mx > lft * 9 + sm1:
    m = True

if m:
    print("Monocarp")
else:
    print("Bicarp")


n = int(input())
s = input()

sd = 0
qd = 0

for i in range(n // 2):
    if s[i] == '?':
        qd += 1
    else:
        sd += int(s[i])

    if s[n // 2 + i] == '?':
        qd -= 1
    else:
        sd -= int(s[n // 2 + i])

if abs(sd) % 9 > 0:
    print("Monocarp")
    return

if sd >= 0:
    qd += 2 * (sd // 9 + (1 if sd % 9 > 0 else 0))
else:
    sd = -1 * sd
    qd -= 2 * (sd // 9 + (1 if sd % 9 > 0 else 0))

print("Bicarp" if qd == 0 else "Monocarp")