After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.

An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.

In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.

 [Image] 

The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).

Assume that both players play optimally. Who will win the game?


-----Input-----

The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).


-----Output-----

Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.


-----Examples-----
Input
2 2

Output
Malvika

Input
2 3

Output
Malvika

Input
3 3

Output
Akshat



-----Note-----

Explanation of the first sample:

The grid has four intersection points, numbered from 1 to 4.

 [Image] 

If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.

 [Image] 

Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.

In the empty grid, Akshat cannot make any move, hence he will lose.

Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.

Difficulty: EASY

Solutions:
(n, m) = map(int, input().split())
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


l = input().split()
initArr = [int(x) for x in l]
(n, m) = initArr
intPoints = n * m
akshay = True
while intPoints > 0:
	n -= 1
	m -= 1
	intPoints = n * m
	akshay = not akshay
if akshay:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
count = 0
i = 1
while True:
	if a[0] - i == 0:
		break
	if a[1] - i == 0:
		break
	i = i + 1
	count = count + 1
if count % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
count = 0
while m * n > 0:
	m -= 1
	n -= 1
	count += 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


print(['Akshat', 'Malvika'][~min(map(int, input().split())) % 2])


a = list(map(int, input().split()))
c = min(a)
print('Malvika' if c % 2 == 0 else 'Akshat')


(n, m) = [int(i) for i in input().split()]
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


answer = min(map(int, input().split()))
print('Malvika') if answer % 2 == 0 else print('Akshat')


(n, m) = [int(x) for x in input().split()]
check = 0
while n != 1 and m != 1:
	n -= 1
	m -= 1
	check += 1
if check % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


numbers = [*map(int, input().split())]
minv = min(numbers)
if minv % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(k, n) = map(int, input().split())
hod = min(k, n)
if hod % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
k = 0
while True:
	k += 1
	a -= 1
	b -= 1
	if a == 0 or b == 0:
		break
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


l = list(map(int, input().split(' ')))
k = min(l)
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
mind = False
p = n * m
while p != 0:
	n = n - 1
	m = m - 1
	p = n * m
	if mind == True:
		mind = False
	else:
		mind = True
if mind == True:
	print('Akshat')
else:
	print('Malvika')


def rank(a):
	if a % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
(n, m) = map(int, input().split())
rank(min(n, m))


(n, m) = map(int, input().split())
a = min(n, m)
if a & 1:
	print('Akshat')
else:
	print('Malvika')


(x, y) = input().split()
n = int(x)
m = int(y)
if n > m:
	c = m
else:
	c = n
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def Sticks(l, r):
	return min(l, r) % 2
(l, r) = map(int, input().split())
if Sticks(l, r) == 1:
	print('Akshat')
else:
	print('Malvika')


lado = input()
lados = []
num = ''
for numero in lado:
	if numero != ' ':
		num = num + numero
	else:
		lados.append(int(num))
		num = ''
lados.append(int(num))
x = lados[0]
y = lados[1]
ganadora = 0
while x != 0 and y != 0:
	x -= 1
	y -= 1
	if ganadora == 'Akshat':
		ganadora = 'Malvika'
	else:
		ganadora = 'Akshat'
print(ganadora)


n = input().split()
a = int(n[0])
b = int(n[1])
c = min(a, b)
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = input().split(' ')
a = int(a)
b = int(b)
mn = min(a, b)
if mn % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
count = 0
while a * b > 0:
	a = a - 1
	b = b - 1
	count = count + 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


enter = input()
l = enter.split()
m = int(l[0])
n = int(l[1])
x = min(m, n)
y = x % 2
if y == 0:
	print('Malvika')
if y == 1:
	print('Akshat')


(n, m) = map(int, input().split())
l = ['Malvika', 'Akshat']
print(l[min(n, m) % 2])


(a, b) = map(int, input().split())
ncount = 0
while a != 0 and b != 0:
	a -= 1
	b -= 1
	ncount += 1
if ncount % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split()]
k = n * m
flag = False
if n == 1 or m == 1:
	print('Akshat')
else:
	while k > 0:
		ints = n + m - 1
		k -= ints
		n -= 1
		m -= 1
		if flag == True:
			flag = False
		else:
			flag = True
	if flag == False:
		print('Malvika')
	else:
		print('Akshat')


x = [int(i) for i in input().split()]
m = x[0]
n = x[1]
if m % 2 == n % 2:
	if m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
else:
	x = max(m, n)
	if x % 2 != 0:
		print('Malvika')
	else:
		print('Akshat')


(n, m) = map(int, input().split())
r = min(n, m) % 2
if r == 1:
	print('Akshat')
else:
	print('Malvika')


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())

def par(a):
	return ' '.join(list(map(str, a)))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)

def show2d(a):
	for i in a:
		for j in i:
			print(j, end=' ')
		print()
(n, m) = isp()
x = min(n, m)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
print('Akshat' if min(a, b) % 2 else 'Malvika')


from sys import stdin
firstline = stdin.readline().rstrip().split()
n = int(firstline[0])
m = int(firstline[1])
akshat_turn = True
play_board = [[0 for x in range(n)] for i in range(m)]

def not_empty(play_board):
	rows = len(play_board)
	cols = 0
	if rows > 0:
		cols = len(play_board[0])
	return cols > 0 or rows > 0

def remove_bottom_left_corner_point(play_board):
	del play_board[0]
	for i in range(len(play_board) - 1, -1, -1):
		del play_board[i][0]
		if not len(play_board[i]) > 0:
			del play_board[i]
while not_empty(play_board):
	remove_bottom_left_corner_point(play_board)
	akshat_turn = not akshat_turn
akshat_turn = not akshat_turn
print(('Malvika', 'Akshat')[akshat_turn])


print('Malvika') if min([int(x) for x in input().split()]) % 2 == 0 else print('Akshat')


(n, m) = [int(x) for x in input().split()]
a = min(n, m)
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
a.sort()
if a[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split()]
if n % 2 == 0 and m % 2 == 0 or min(m, n) % 2 == 0:
	print('Malvika')
elif n % 2 != 0 and m % 2 != 0 or min(m, n) % 2 != 0:
	print('Akshat')


import sys
from sys import stdin, stdout
import math
import random
import heapq
from collections import Counter
from functools import lru_cache
try:
	for _ in range(1):
		(n, m) = map(int, input().split())
		ans = min(n, m)
		if ans % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
except EOFError as e:
	print(e)


inp = input().split()
n = int(inp[0])
m = int(inp[1])
min = min(n, m)
if min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = map(int, input().split())
x = min(x, y)
if x % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split())
arr = ['Malvika', 'Akshat']
i = min(a, b) % 2
print(arr[i])


(p1, p2) = ['Akshat', 'Malvika']
(x, y) = [int(i) for i in input().split()]
counter = min(x, y)
print(p2 if counter % 2 == 0 else p1)


(n, m) = list(map(int, input().split()))
aks = False
while n > 0 and m > 0:
	n -= 1
	m -= 1
	if aks == True:
		aks = False
	else:
		aks = True
else:
	if aks == True:
		print('Akshat')
	else:
		print('Malvika')


a = input().split()
n = a[0]
m = a[1]
grid = int(n) * int(m)
sticks = int(n) + int(m)
move = 0
while True:
	if grid != 0 and sticks != 1:
		grid -= 1
		move += 1
		sticks -= 2
	if sticks == 1:
		break
	elif grid == 0:
		break
if move % 2 == 1:
	print('Akshat')
elif move % 2 == 0:
	print('Malvika')


(a, b) = [int(x) for x in input().split()]
total = a * b
chance = True
while total > 0:
	total = a * b
	chance = not chance
	a -= 1
	b -= 1
print('Akshat') if chance == True else print('Malvika')


(n, m) = [int(x) for x in input().split()]
if min(n, m) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


print(['Malvika', 'Akshat'][min(map(int, input().split())) & 1])


(n, m) = map(int, input().split())
(i, j) = (0, 0)
prev = 0
while i < n and j < m:
	if prev == 0:
		i += 1
		j += 1
		prev = 1
	else:
		i += 1
		j += 1
		prev = 0
if prev == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
c = 0
while m != 0 and n != 0 and (m + n > 1):
	c += 1
	m -= 1
	n -= 1
if c % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = tuple(map(int, input().split()))
w = True
while n * m > 0:
	n -= 1
	m -= 1
	w = not w
if w:
	print('Malvika')
else:
	print('Akshat')


string = list(map(int, input().strip().split()))
if string[0] < string[1]:
	minimum = string[0]
else:
	minimum = string[1]
if minimum % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
if n <= m:
	if n % 2 == 0:
		print('Malvika')
	if n % 2 == 1:
		print('Akshat')
if m < n:
	if m % 2 == 0:
		print('Malvika')
	if m % 2 == 1:
		print('Akshat')


(m, n) = map(int, input().split())
temp = m * n
step = 0
while temp != 0:
	m -= 1
	n -= 1
	temp = m * n
	step += 1
print(['Akshat', 'Malvika'][step % 2 == 0])


(x, y) = input().split()
n = min(int(x), int(y))
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
i = 0
if m < n:
	i = m
else:
	i = n
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
if min(a, b) & 1 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().strip().split())
if n <= m:
	min_num = n
else:
	min_num = m
if min_num % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


data = input().split()
n = int(data[0])
m = int(data[1])
x = min(n, m)
if x % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


nm = input().split(' ')
n = int(nm[0])
m = int(nm[1])
s = min(n, m)
print('Akshat' if s % 2 else 'Malvika')


(m, n) = input().split()
n = int(n)
m = int(m)
a = 'Akshat'
b = 'Malvika'
k = min(m, n)
if k % 2 == 0:
	print(b)
else:
	print(a)


print('Akshat' if min(list(map(int, input().split()))) & 1 else 'Malvika')


(n, m) = list(map(int, input().split()))
if n > m:
	if m % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')
elif n <= m:
	if n % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')


a = list(map(int, input().split()))
count = 0
t = 0
while t == 0:
	if a[0] != 0 and a[1] != 0:
		a[0] -= 1
		a[1] -= 1
		count += 1
	else:
		break
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = input().split()
m = int(m)
n = int(n)
if m <= n:
	k = m
elif n <= m:
	k = n
if k % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


n = input().split(' ')
row = int(n[0])
col = int(n[1])
ans = min(row, col)
if ans % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
w = 0
cnt = n * m
while cnt > 0:
	cnt -= n + m - 1
	n -= 1
	m -= 1
	w = 1 - w
if w == 1:
	print('Akshat')
else:
	print('Malvika')


(hor, ver) = input().split()
hor = int(hor)
ver = int(ver)
if min(hor, ver) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


ab = input().split()
ab = [int(i) for i in ab]
if min(ab) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = map(int, input().split())
m = min(x, y)
if m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def par(numero):
	if numero % 2 == 0:
		return True
	return False
(i, j) = input('').split()
(i, j) = (int(i), int(j))
(i, j) = (i if i <= j else j, j if i <= j else i)
if i == j:
	if not par(i):
		print('Akshat')
	else:
		print('Malvika')
elif i < j:
	if par(i):
		print('Malvika')
	elif not par(i):
		print('Akshat')


(n, m) = [int(ip) for ip in input().split()]
if n <= m:
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
flag = True
if n == m:
	if n % 2 != 0:
		flag = False
if abs(m - n) % 2 != 0:
	if max(n, m) % 2 == 0:
		flag = False
elif max(n, m) % 2 != 0:
	flag = False
if flag:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
print(['Malvika', 'Akshat'][min(a, b) % 2])


a = [int(x) for x in input().split()]
if a[0] == a[1] and a[0] % 2 == 0 or min(a) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from sys import *
input = stdin.readline
(a, b) = map(int, input().split())
x = min(a, b)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = map(int, input().split())
if m > n:
	t = n
else:
	t = m
if t % 2:
	print('Akshat')
else:
	print('Malvika')


(n, m) = input().split(' ')
n = int(n)
m = int(m)
mini = min(n, m)
if mini % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


li = [int(i) for i in input().split()]
k = min(li)
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
if n % 2 == 0 and m % 2 == 0:
	print('Malvika')
elif n % 2 == 1 and m % 2 == 1:
	print('Akshat')
else:
	if n > m:
		n -= 1
	else:
		m -= 1
	if n % 2 == 0 and m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


import sys
from random import choice, randint
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, sys.stdin.readline().strip().split())

def LI():
	return list(map(int, sys.stdin.readline().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().strip().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().strip().split()]

def LS():
	return sys.stdin.readline().strip().split()

def I():
	return int(sys.stdin.readline().strip())

def F():
	return float(sys.stdin.readline().strip())

def S():
	return sys.stdin.readline().strip()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	(n, m) = MI()
	if min(n, m) % 2 == 0:
		pf('Malvika')
	else:
		pf('Akshat')
main()


def F(n, m):
	if n == 1 or m == 1:
		return 1
	else:
		return [0, 1][F(n - 1, m - 1) == 0]
(n, m) = map(int, input().split())
if F(n, m) == 1:
	print('Akshat')
else:
	print('Malvika')


winner = {0: 'Malvika', 1: 'Akshat'}
data = str(input())
dimensions = list(map(int, data.split()))
print(winner.get(min(dimensions) % 2))


(n, m) = [int(i) for i in input().split()]
(win, lose) = ('Malvika', 'Akshat')
while n != 0 != m:
	n -= 1
	m -= 1
	(win, lose) = (lose, win)
print(win)


(n, m) = [int(i) for i in input().split()]
w = True
while True:
	s = n * m - (n + m - 1)
	n -= 1
	m -= 1
	if s > 0:
		w = not w
	else:
		break
if w:
	print('Akshat')
else:
	print('Malvika')


(n, m) = input().split()
n = int(n)
m = int(m)
winner = True
count = 0
while n * m > 0:
	n = n - 1
	m = m - 1
	if n * m == 0 and count % 2 == 0:
		winner = True
		break
	if n * m == 0 and count % 2 != 0:
		winner = False
	count += 1
if winner:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
x = min(n, m)
j = 1
for i in range(x + 1):
	if j % 2 != 0 and x - i == 1:
		print('Akshat')
	if j % 2 == 0 and x - i == 1:
		print('Malvika')
	j += 1


(n, m) = map(int, input().split())
count_ = 0
while True:
	if n == 0 or m == 0:
		break
	n -= 1
	m -= 1
	count_ += 1
if count_ % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def get_sorted_numlist():
	list_in = list(input().split())
	list_out = []
	for k in list_in:
		list_out += [int(k)]
	list_out.sort()
	return list_out

def main():
	list1 = get_sorted_numlist()
	if list1[0] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


print(['Malvika', 'Akshat'][min((int(j) for j in input().split())) % 2])


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	(n, m) = Scanner.map_int()
	if min(n, m) % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


(a, b) = list(map(int, input().split()))
if a < b:
	if a % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif b % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


n = list(map(int, input().split()))
s = n[0] + n[1]
m = n[0] * n[1]
v = 0
while True:
	v = v + 1
	m = m - (s - 1)
	if m == 0:
		if v % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
		break
	s = s - 2


(n, m) = input().split()
n = int(n)
m = int(m)
total = n * m
counts = 1
while total:
	total = total - (n + m - 1)
	n -= 1
	m -= 1
	counts += 1
if counts % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split(' '))
a = ['Malvika', 'Akshat']
i = False
while True:
	if n < 1 or m < 1:
		break
	m -= 1
	n -= 1
	i ^= True
print(a[i])


a = input()
a = a.split()
n = int(a[0])
m = int(a[1])
p = 0
r = 0
while True:
	if p % 2 == 0 and n != 1 and (m != 1):
		p += 1
		(n, m) = (n - 1, m - 1)
		r = 1
	if p % 2 != 0 and n != 1 and (m != 1):
		p += 1
		(n, m) = (n - 1, m - 1)
		r = 0
	if n == 1 or m == 1:
		break
if r == 0:
	print('Akshat')
else:
	print('Malvika')


print('MAaklsvhiakta'[min(map(int, input().split())) % 2::2])


(n, m) = list(map(int, input('').strip().split()))
moves = min(n, m)
if moves % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


line = input()
(n, m) = [int(i) for i in line.split()]
MIN = min(n, m) - 1
if MIN & 1:
	print('Malvika')
else:
	print('Akshat')


import sys

def solve():
	(n, m) = map(int, input().split())
	k = min(m, n)
	if k % 2:
		ans = 'Akshat'
	else:
		ans = 'Malvika'
	print(ans)
solve()


(m, n) = list(map(int, input().split()))
b = m + n
c = m * n
if m >= n:
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = input().split()
m = int(m)
n = int(n)
c = 0
while True:
	m = m - 1
	n = n - 1
	if m * n > 0:
		c = c + 1
	else:
		break
if c % 2 != 0:
	print('Malvika')
else:
	print('Akshat')


if int(min(map(int, input().split()))) % 2:
	print('Akshat')
else:
	print('Malvika')


dims = list(map(int, input().split()))
print('Malvika' if min(dims) % 2 == 0 else 'Akshat')


def main(n, m):
	if n == 1 or m == 1:
		return 'Akshat'
	if min(n, m) % 2:
		return 'Akshat'
	return 'Malvika'
(n, m) = [int(x) for x in input().split()]
print(main(n, m))


(a, b) = [int(i) for i in input().split()]
print('Malvika' if min(a, b) % 2 == 0 else 'Akshat')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	a = LI()
	if min(a) % 2 == 0:
		return 'Malvika'
	return 'Akshat'
print(main())


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	(n, m) = vars()
	if min(n, m) % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
t = 1
for _ in range(t):
	main()


R = lambda : map(int, input().split())
(n, m) = list(R())
a = min(n, m) + 1
if a % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
res = n * m
turn = 0
while res > 0:
	res -= n + m - 1
	turn += 1
	n -= 1
	m -= 1
if turn % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


x = input().split()
n = int(x[0])
m = int(x[1])
k = n
if n >= m:
	k = m
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(num_rows, num_cols) = list(map(int, input().split()))
turn = 'Akshat'
while True:
	num_rows -= 1
	num_cols -= 1
	if num_rows == 0 or num_cols == 0:
		print(turn)
		exit(0)
	elif turn == 'Malvika':
		turn = 'Akshat'
	else:
		turn = 'Malvika'


import sys
from math import *
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df
import heapq
infinite = float('inf')
(n, m) = RI()
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(r, c) = map(int, input().split())
product = r * c
sum_ = r + c
for i in range(sum_):
	if r >= 1 and c >= 1:
		r -= 1
		c -= 1
		j = i + 1
if j % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


num = input().split(' ')
n = int(num[0])
m = int(num[1])
min_n = min(n, m)
winer = ''
if min_n > 1:
	if min_n % 2 == 0:
		winer += 'm'
	else:
		winer += 'a'
else:
	winer += 'a'
if winer == 'm':
	print('Malvika')
else:
	print('Akshat')


from sys import stdin, stdout
from math import ceil, floor
from collections import deque
inp = stdin.readline
out = stdout.write
(n, m) = map(int, inp().strip().split())
s = min(n, m)
if s % 2:
	out('Akshat')
else:
	out('Malvika')


(a, b) = [int(x) for x in input().split()]
k = 0
while True:
	k = k + 1
	a = a - 1
	b = b - 1
	if a == 0 or b == 0:
		break
if k % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
f = False
while n != 0 and m != 0:
	n -= 1
	m -= 1
	if not f:
		f = True
	else:
		f = False
if not f:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
x = n + m if max(n, m) - min(n, m) < 2 else 2 * min(n, m) + 1
print(['Malvika', 'Akshat'][x % 4 >= 2])


(a, b) = input().split()
(a, b) = (int(a), int(b))
counter = 0
while a > 0 and b > 0:
	a -= 1
	b -= 1
	counter += 1
if counter % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import sys, os.path
sys.setrecursionlimit(10 ** 5)

def mod():
	return 10 ** 9 + 7

def i():
	return sys.stdin.readline().strip()

def ii():
	return int(sys.stdin.readline())

def li():
	return list(sys.stdin.readline().strip())

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

def lii():
	return list(map(int, sys.stdin.readline().strip().split()))

def solve():
	(a, b) = mii()
	if min(a, b) % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
for _ in range(1):
	solve()


import math
(n, m) = map(int, input().split())
b = min(n, m)
if b % 2:
	print('Akshat')
else:
	print('Malvika')


user = [int(s) for s in input().split()]
countY = user[0]
countX = user[1]
count = 1
while countY > 1 and countX > 1:
	countX -= 1
	countY -= 1
	count += 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def interSection(a, b):
	cnt = 0
	while a > 0 and b > 0:
		a -= 1
		b -= 1
		cnt += 1
	if cnt % 2 == 0:
		return 'Malvika'
	return 'Akshat'
(a, b) = map(int, input().rstrip().split())
print(interSection(a, b))


a = input().split(' ')
min = 0
for i in range(2):
	a[i] = int(a[i])
if a[0] < a[1]:
	min = a[0]
else:
	min = a[1]
if min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = [int(x) for x in input().split(' ')]
p = min(a, b)
if p % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(h, v) = list(map(int, input().split()))
if min(h, v) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = [int(i) for i in input().split()]
m = a[0]
n = a[1]
check = min(m, n)
if check % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
(int_points, player, i) = (m * n, 0, 1)
while int_points >= 1:
	int_points -= n + m - i
	player += 1
	i += 2
if player % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


n = list(input().split())
n[0] = int(n[0])
n[1] = int(n[1])
if min(n[0], n[1]) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(m, n) = [int(i) for i in input().split()]
times = 0
points = m * n
while True:
	try:
		times += 1
		points -= m + n - 1
		m -= 1
		n -= 1
		if points == 0:
			break
	except EOFError:
		break
if times % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
a = 1
points = n * m
move = 1
while points >= 1:
	if move == 1:
		a = 1
		points = (n - 1) * (m - 1)
		move = 2
	else:
		a = 0
		points = (n - 1) * (m - 1)
		move = 1
	n -= 1
	m -= 1
if a == 1:
	print('Akshat')
else:
	print('Malvika')


n = list(map(int, input().rstrip().split()))
a = min(n[0], n[1])
if a & 1:
	print('Akshat')
else:
	print('Malvika')


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import nsmallest, nlargest, heapify, heappop, heappush, heapreplace
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd, log10, atan, tan

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(a, b) = get_ints()
if min(a, b) & 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = list(map(int, input().split()))
intersections = n * m
removes = n + m - 1
timesRemoved = 0
moves = 0
while intersections > 0:
	intersections -= removes - timesRemoved * 2
	timesRemoved += 1
	moves += 1
if moves % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


num_input = input()
num_input = num_input.split(' ')
choose = min(int(num_input[0]), int(num_input[1]))
if choose % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
move = 0
while n != 0 and m != 0:
	n -= 1
	m -= 1
	move = 1 if move == 0 else 0
if move == 0:
	print('Malvika')
else:
	print('Akshat')


l = list(map(int, input().split()))
h = l[0]
v = l[1]
while True:
	if h == v:
		if h % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
		break
	elif h > v:
		h = h - 1
	elif v > h:
		v = v - 1


t = [int(i) for i in input().split(' ')]
n = t[0]
m = t[1]
if n > m:
	if m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
r = 0
while n * m > 0:
	a = n * m
	n -= 1
	m -= 1
	r += 1
if r % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split()]
c = 0
for i in range(n):
	t = n * m
	x = n + m - 1
	y = t - x
	c += 1
	n = n - 1
	m = m - 1
	if y == 1:
		break
	elif y == 0:
		c = c - 1
		break
	else:
		continue
if c == 1:
	print('Malvika')
elif c % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = list(map(int, input().rstrip().split()))
minm = m
if n < m:
	minm = n
if minm % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
(n, m) = mi()
m = min(n, m)
if m % 2:
	print('Akshat')
else:
	print('Malvika')


z = input().split()
(n, m) = (int(z[0]), int(z[1]))
c = min(n, m)
if c % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(x) for x in input().split()]
if n <= m and n % 2 == 1 or (m <= n and m % 2 == 1):
	print('Akshat')
else:
	print('Malvika')


(nInput, mInput) = map(int, input().split())
minInput = nInput if nInput < mInput else mInput
if minInput % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split())
res = 'Malvika'
while a * b > 0:
	a -= 1
	b -= 1
	if res == 'Akshat':
		res = 'Malvika'
	else:
		res = 'Akshat'
print(res)


(x, y) = map(int, input().split(' '))
if x >= y and y % 2 == 0:
	print('Malvika')
elif x <= y and x % 2 == 0:
	print('Malvika')
if x >= y and y % 2 != 0:
	print('Akshat')
elif x <= y and x % 2 != 0:
	print('Akshat')


(sticksG, sticksV) = map(int, input().split())
if sticksG % 2 == 1 == sticksV % 2:
	print('Akshat')
elif sticksG > sticksV and sticksG % 2 == 0 or (sticksG < sticksV and sticksV % 2 == 0):
	if sticksG % 2 == 0 and sticksV % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif sticksG == 1 or sticksV == 1:
	print('Malvika')
else:
	print('Malvika')


x = input().split()
(m, n) = map(int, x)
if m == 1 or n == 1:
	print('Akshat')
else:
	counter = 0
	while 1:
		if m == 1 or n == 1:
			break
		m -= 1
		n -= 1
		counter += 1
	if counter % 2 == 0:
		print('Akshat')
	else:
		print('Malvika')


(n, m) = map(int, input().split())
Min = min(n, m)
if n == 1 or m == 1:
	print('Akshat')
elif n == 2 and m == 2:
	print('Malvika')
elif Min % 2 == 0:
	if Min % 2 == 0:
		print('Malvika')
else:
	print('Akshat')


a = [int(x) for x in input().split()]
temp1 = a[0]
temp2 = a[1]
x = min(temp1, temp2)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


s = ['Malvika', 'Akshat']
(n, m) = map(int, input().split())
print(s[min([n, m]) % 2])


l = input().split()
a = int(l[0])
b = int(l[1])
p = a * b
s = 0
while p > 0:
	a = a - 1
	b = b - 1
	p = a * b
	s = s + 1
if s % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
x = list(map(int, input().split()))
n = min(x[0], x[1])
if n % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
sticks = n + m - 1
dots = n * m
step = True
while dots > 0:
	dots = dots - sticks
	sticks -= 2
	step = not step
if step == 1:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
total = n * m
flag = True
while total != 0:
	if flag:
		total = total - (n + m - 1)
		n = n - 1
		m = m - 1
		flag = False
	else:
		total = total - (n + m - 1)
		n = n - 1
		m = m - 1
		flag = True
if flag:
	print('Malvika')
else:
	print('Akshat')


a = 0
z = list(map(int, input().split()))
for i in range(1, z[0] * z[1] + 1, z[1]):
	if a >= z[1]:
		break
	a += 1
print(['Akshat', 'Malvika'][a % 2 == 0])


arr = list(map(int, input().split()))
n = arr[0]
m = arr[1]
c = 0
while n != 0 and m != 0:
	n -= 1
	m -= 1
	if c == 0:
		c = 1
	else:
		c = 0
if c == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(i) for i in input().split()]
a = 0
while n != 0 and m != 0:
	n -= 1
	m -= 1
	a += 1
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


global h
(n, m) = map(int, input().split())
if m > n:
	if n % 2 == 0:
		h = 2
	else:
		h = 1
elif n > m:
	if m % 2 == 0:
		h = 2
	else:
		h = 1
elif m == n:
	if m % 2 == 0:
		h = 2
	else:
		h = 1
if h == 2:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
i = 0
x = ['Akshat', 'Malvika'] * (n * m)
while n * m > 0:
	y = x[i]
	n -= 1
	m -= 1
	i += 1
print(y)


(n, m) = map(int, input().split())
tot = n + m
while 1:
	n -= 1
	m -= 1
	if n == 0 or m == 0:
		print('Akshat')
		break
	n -= 1
	m -= 1
	if n == 0 or m == 0:
		print('Malvika')
		break


X = list(map(int, input().split()))
h = X[0]
v = X[1]
t = 0
while h != 0 and v != 0:
	if t == 0:
		h -= 1
		v -= 1
		t = 1
	else:
		h -= 1
		v -= 1
		t = 0
if t == 0:
	print('Malvika')
else:
	print('Akshat')


l = list(map(int, input().split()))
(n, m) = (l[0], l[1])
if min(m, n) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
a = []
i = 1
while n > 0 and m > 0:
	if i % 2:
		a.append('Akshat')
	else:
		a.append('Malvika')
	i += 1
	n -= 1
	m -= 1
print(a[-1])


class Player:

	def __init__(self):
		self.turn = False
inputString = input().split()
n = int(inputString[0])
m = int(inputString[1])
gameMap = []
for i in range(0, n):
	mList = []
	for j in range(0, m):
		mList.append(1)
	gameMap.append(mList)
Malvika = Player()
Akshat = Player()
Akshat.turn = True
isAkshatWin = False
while True:
	indexN = -1
	indexM = -1
	isNotEnd = False
	for i in range(0, n):
		for j in range(0, m):
			if gameMap[i][j] == 1:
				indexN = i
				indexM = j
				isNotEnd = True
	if isNotEnd == False:
		if Akshat.turn == True:
			isAkshatWin = False
		else:
			isAkshatWin = True
		break
	else:
		for i in range(0, n):
			gameMap[i][indexM] = 0
		for j in range(0, m):
			gameMap[indexN][j] = 0
		if Akshat.turn == False:
			Akshat.turn = True
			Malvika.turn = False
		else:
			Akshat.turn = False
			Malvika.turn = True
if isAkshatWin == True:
	print('Akshat')
else:
	print('Malvika')


line = [int(i) for i in str(input()).split()]
if min(line) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = input().split()
m = int(m)
n = int(n)
p = n * m
s = True
if min(m, n) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def div(a, b):
	if a == 1 and b == 1:
		return 'Akshat'
	c = min(a, b)
	if c % 2 == 0:
		return 'Malvika'
	return 'Akshat'
(a, b) = map(int, input().split())
print(div(a, b))


(n, m) = [int(x) for x in input().split()]
i = 1
while True:
	m -= 1
	n -= 1
	if m * n == 0:
		break
	i += 1
print('Akshat' if i % 2 != 0 else 'Malvika')


print(['Malvika', 'Akshat'][min([int(i) for i in input().split()]) % 2])


(a, b) = (int(i) for i in input().split())
x = a * b
w = False
while True:
	if w:
		break
	for i in range(1, 3):
		x = x - (a - 1) - (b - 1) - 1
		a -= 1
		b -= 1
		if x == 0 and i == 1:
			print('Akshat')
			w = True
			break
		elif x == 0 and i == 2:
			print('Malvika')
			w = True
			break


(r, c) = map(int, input().split())
a = 0
m = 0
x = 0
while r * c > 0:
	if x % 2 == 0:
		a = a + 1
		r = r - 1
		c = c - 1
	else:
		m = m + 1
		r = r - 1
		c = c - 1
	x = x + 1
if m == a:
	print('Malvika')
else:
	print('Akshat')


(h, v) = input().split()
h = int(h)
v = int(v)
moves = min(v, h)
if moves % 2 == 0:
	print('Malvika')
elif moves % 2 == 1:
	print('Akshat')


a = list(map(int, input().split()))
if a[0] > a[1]:
	if a[1] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif a[0] == 1 or a[1] == 1:
	print('Akshat')
elif a[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve(m, n):
	c = 0
	while m != 0 and n != 0:
		m -= 1
		n -= 1
		if c == 0:
			c = 1
		else:
			c = 0
	return 'Malvika' if c == 0 else 'Akshat'
(n, m) = map(int, input().split(' '))
print(solve(m, n))


def stick(a, b):
	if a == 0 or b == 0:
		return 1
	else:
		return (1 + stick(a - 1, b - 1)) % 2
inf = list(map(int, input().split()))
x = inf[0] + inf[1]
t = stick(inf[0], inf[1])
if t == 0:
	print('Akshat')
else:
	print('Malvika')


m = min(map(int, input().rstrip().split()))
print(['Malvika', 'Akshat'][m % 2 == 1])


def stick_game(n, m):
	if n == 1 and m == 1:
		intersections = n + m
	else:
		intersections = n * m
	ash = 1
	while intersections > 1:
		n -= 1
		m -= 1
		if n == 1 and m == 1:
			intersections = n + m
		else:
			intersections = n * m
		ash ^= 1
	ash ^= 1
	if ash:
		return 'Akshat'
	else:
		return 'Malvika'
(n, m) = input().split()
(n, m) = (int(n), int(m))
print(stick_game(n, m))


(n, m) = [int(x) for x in input().split()]
a = True
while n > 0 and m > 0:
	n -= 1
	m -= 1
	a = not a
print('Malvika') if a else print('Akshat')


l = list(map(int, input().split()))
n = 0
while l[0] > 0 and l[1] > 0:
	l[0] -= 1
	l[1] -= 1
	n += 1
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


p = input().split(' ')
(m, n) = (int(p[0]), int(p[1]))
if n < m:
	m = n
print('Akshat' if m % 2 == 1 else 'Malvika')


o = min(map(int, input().split()))
if o & 1:
	print('Akshat')
else:
	print('Malvika')


entry = list(map(int, input().split()))
min_entry = min(entry[0], entry[1])
if min_entry % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
for i in range(max(a, b)):
	a -= 1
	b -= 1
	if a * b == 0:
		break
if i % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


x = str(input()).split(' ')
new_x = [int(i) for i in x]
new_x.sort()
k = int(new_x[0])
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = [int(i) for i in input().split()]
m = min(x, y) / 2
if int(m) == m:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
a.sort()
for i in range(1, max(a) + 1):
	if i % 2 != 0:
		a[1] -= 1
		a[0] -= 1
		if a[1] <= 0 or a[0] <= 0:
			print('Akshat')
			break
	elif i % 2 == 0:
		a[1] -= 1
		a[0] -= 1
		if a[1] <= 0 or a[0] <= 0:
			print('Malvika')
			break


arr = [int(x) for x in input().split()]
n = arr[0]
m = arr[1]
min_stick = min(n, m)
if min_stick % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
if n >= m:
	d = m
elif m > n:
	d = n
if d % 2 == 0:
	print('Malvika')
elif d % 2 != 0:
	print('Akshat')


(n, m) = map(int, input().split())
arr = []
digit = 1
for i in range(1, n + 1):
	small_arr = []
	j = digit
	loop_length = digit + m
	while j < loop_length:
		small_arr.append(j)
		digit += 1
		j += 1
	arr.append(small_arr)
output = 0
k = 0
while k < n:
	if len(arr[0]) == 1:
		output += 1
		break
	else:
		x = [row[1:] for row in arr]
		x = x[1:]
		arr = x
		output += 1
	k += 1
print('Akshat' if output % 2 == 1 else 'Malvika')


from sys import stdin as inp
from sys import stdout as out
from sys import maxsize as max
(n, m) = list(map(int, inp.readline().strip().split()))
if min(n, m) % 2 == 0:
	out.write('Malvika')
else:
	out.write('Akshat')


(n, m) = [int(a) for a in input().strip().split()]
sticks = n + m
if n == m:
	num_moves = sticks // 2
	if num_moves % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
else:
	lower = min(n, m)
	if lower % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


(n, m) = map(int, input().split())
ins = n * m
c = 0
if n == m:
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
else:
	x = min(n, m)
	if x % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


i = str(input()).split(' ')
rows = int(i[0])
cols = int(i[1])
if rows < cols:
	x = rows
else:
	x = cols
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


s = input()
s = s.split()
print('MAaklsvhiakta'[min(int(s[1]), int(s[0])) % 2 != 0::2])


(n, m) = map(int, input().split())
c = 0
for i in range(1, n + m):
	if n - i == 0:
		break
	if m - i == 0:
		break
	c += 1
if c % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


p = map(int, input().split())
q = min(p)
if q / 2 == q // 2:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
k = 1
nm = n + m
while n > 0 and m > 0:
	k = k * -1
	n = n - 1
	m = m - 1
if k > 0:
	print('Malvika')
else:
	print('Akshat')


from sys import stdin
(n, m) = (int(x) for x in stdin.readline().strip().split(' '))
print('Malvika') if min(n, m) % 2 == 0 else print('Akshat')


(x, y) = input().split()
(x, y) = (int(x), int(y))
if x > y:
	k = y
elif x < y:
	k = x
else:
	k = y
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve(n, m):
	return 'Malvika' if min(n, m) % 2 == 0 else 'Akshat'

def main():
	(n, m) = list(map(int, input().split()))
	print(solve(n, m))
main()


def single_integer():
	return int(input())

def multi_integer():
	return map(int, input().split())

def string():
	return input()

def multi_string():
	return input().split()
(n, m) = multi_integer()
if m <= n:
	temp = m
else:
	temp = n
if temp % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(__) for __ in input().strip().split()]
print('Akshat' if min(n, m) % 2 == 1 else 'Malvika')


p = [int(i) for i in input().split()]
if min([p[0], p[1]]) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = list(map(int, input().split()))
a = min(x, y)
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


inp = list(map(int, input().split()))
n = inp[0]
m = inp[1]
k = 0
i = 1
while n * m >= 1:
	k += 1
	n -= 1
	m -= 1
if k % 2 == 0:
	result = 'Malvika'
else:
	result = 'Akshat'
print(result)


def Main():
	(n, m) = map(int, input().split())
	x = min(n, m)
	if x % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
Main()


a = list(input().split())
n = int(a[0])
m = int(a[1])
k = 0
if n >= m:
	k = m
else:
	k = n
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


inside = input()
(n, m) = list(map(int, inside.split()))
turns_amount = min(n, m)
if turns_amount % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


l_ = list(map(int, input().split(' ')))
a = min(l_[0], l_[1])
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(row, col) = map(int, input().split())
player = 0
while row > 0 and col > 0:
	row -= 1
	col -= 1
	player += 1
if player % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


in0 = min([int(x) for x in input().split()])
if in0 % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = list(map(int, input().split()))
turns = min(m, n)
if turns % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(x, y) = map(int, input().split())
if x > y:
	result = y
else:
	result = x
if result % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
x = min(m, n)
move = x - 1
if move % 2 == 1:
	print('Malvika')
else:
	print('Akshat')


(m, n) = map(int, input().split())
t = 0
mn = n + m
k = n * m
if m + n == 2:
	print('Akshat')
else:
	while True:
		t += 1
		k -= mn - 1
		mn -= 2
		if k == 0:
			break
	if t % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


(n, m) = map(int, input().split(' '))
res = 0
while n * m > 0:
	n -= 1
	m -= 1
	res ^= 1
print('Malvika' if not res else 'Akshat')


moves = 0
(x, y) = input().split()
x = int(x)
y = int(y)
intersections = x * y
while intersections != 0:
	moves += 1
	x -= 1
	y -= 1
	intersections = x * y
if moves % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(i) for i in input().split()]
total_point = n * m
count = 0
while total_point > 0:
	total_point -= n + m - 1
	n -= 1
	m -= 1
	count += 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = (int(t) for t in input().split())
print('Akshat' if min(n, m) % 2 else 'Malvika')


(input_n, input_m) = list(map(int, input().split()))
if input_n > input_m:
	if input_m % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')
elif input_n <= input_m:
	if input_n % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')


import math
from sys import stdin, stdout, maxsize
(n, m) = map(int, stdin.readline().split())
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
p = min(n, m)
if p % 2 == 0 and n != 1 and (m != 1):
	print('Malvika')
else:
	print('Akshat')


def main():
	inp = input().split()
	print('Akshat' if min(int(inp[0]), int(inp[1])) % 2 != 0 else 'Malvika')
main()


(n, m) = [int(i) for i in input().split()]
inter = n * m
ncount = 0
while inter > 0:
	inter -= m + n - 1
	m -= 1
	n -= 1
	ncount += 1
if ncount % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = input().split()
x = min(int(a[0]), int(a[1]))
if x % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


try:
	print(['Malvika', 'Akshat'][min(map(int, input().split())) % 2])
except:
	pass


(n, m) = input().split()
n = int(n)
m = int(m)
k = min(m, n)
if k % 2 == 1:
	print('Akshat')
elif k % 2 == 0:
	print('Malvika')


(h, v) = map(int, input().split())
k = h * v
c = 0
while k > 0:
	k = k - (h - 1 + v - 1 + 1)
	h = h - 1
	v = v - 1
	c = c + 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def get_winner(n, m):
	moves = min(n, m)
	if moves % 2 == 0:
		return 'Malvika'
	else:
		return 'Akshat'
(n, m) = tuple(map(int, input().strip().split()))
print(get_winner(n, m))


(a, b) = [int(x) for x in input().split(' ')]
print(['Malvika', 'Akshat'][min(a, b) & 1])


(x, y) = [int(a) for a in input().split()]
i = 0
if x > y:
	i = y
else:
	i = x
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
a = n % 2
b = m % 2
if a == 0:
	if b != 0 and n > m:
		print('Akshat')
	else:
		print('Malvika')
elif b == 0 and n > m:
	print('Malvika')
else:
	print('Akshat')


(r, c) = map(int, input().split())
n = r * c
f = True
for i in range(n // 2):
	p = n - (r + c - 1)
	r -= 1
	c -= 1
	if p <= 0 or r == 0 or c == 0:
		break
	elif f:
		f = False
	else:
		f = True
if f:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
t = m + n
p = m * n
ans = ''
c = 0
while True:
	if p > 0:
		n -= 1
		m -= 1
		t = m + n
		p = m * n
		if c % 2 == 0:
			ans = 'Akshat'
		else:
			ans = 'Malvika'
		c += 1
	else:
		break
print(ans)


str = input().split(' ')
n = int(str[0])
m = int(str[1])
i = 0
while n > 0 and m > 0:
	n -= 1
	m -= 1
	i = i + 1
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import sys

def play(n, m):
	if m == 0 or n == 0:
		return 1
	return play(n - 1, m - 1) ^ 1
(n, m) = map(int, sys.stdin.readline().split())
if play(n, m) % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
tmp = min(n, m)
print(['Akshat', 'Malvika'][tmp % 2 == 0])


l = input().split(' ')
(n, m) = (int(l[0]), int(l[1]))
a = n * m
c = 0
while 1:
	z = a - m - n + 1
	c += 1
	if z == 0:
		break
	a = z
	m -= 1
	n -= 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(r, c) = map(int, input().split())
mini = min(r, c)
f = 0
while mini > 0:
	mini -= 1
	if f == 0:
		f = 1
	else:
		f = 0
if f == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
intersectionPoint = n * m
count = 0
player1 = 'Akshat'
player2 = 'Malvika'
winner = player1
while intersectionPoint > 0:
	intersectionPoint = intersectionPoint - n - (m - 1)
	n = n - 1
	m = m - 1
	intersectionPoint = n * m
	count = count + 1
	if count % 2 == 1:
		winner = player1
	elif count % 2 == 0:
		winner = player2
print(winner)


a = list(map(int, input().rstrip().split()))
b = min(a)
if b % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = map(int, input().split())
akshat = False
while m and n:
	m -= 1
	n -= 1
	akshat = not akshat
if akshat:
	print('Akshat')
else:
	print('Malvika')


parametrs = list(map(int, input().split()))
n = parametrs[0]
m = parametrs[1]
count_lines = n + m
count_points = n * m
motion = 'Akshat'
while count_points > 0:
	if count_points > 0:
		n = n - 1
		m = m - 1
		count_points = n * m
	if motion == 'Akshat':
		motion = 'Malvika'
	else:
		motion = 'Akshat'
if motion == 'Akshat':
	win = 'Malvika'
else:
	win = 'Akshat'
print(win)


(n, m) = map(int, input().split())
arr = [False for i in range(n * m)]
str1 = 'Akshat'
str2 = 'Malvika'
temp = min(n, m)
if temp % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().strip().split())
k = m * n
t = 0
cn = n
cm = m
while k > 0:
	k -= cn + cm - 1
	t ^= 1
	cn -= 1
	cm -= 1
if t == 1:
	print('Akshat')
else:
	print('Malvika')


nm = [int(e) for e in input().split()]
n = nm[0]
m = nm[1]
c = 0
while n > 0 and m > 0:
	c += 1
	n -= 1
	m -= 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
import os
import sys
import re
import itertools
import functools
import operator
(a, b) = map(int, input().split())
print('Akshat' if min(a, b) % 2 == 1 else 'Malvika')


(n, m) = map(int, input().split())
x = min(n, m)
if x % 2 == 0:
	print('Malvika')
elif x % 2 == 1:
	print('Akshat')


(n, m) = map(int, input().split())
output = 'Akshat'
i = 0
while n * m > 0:
	n -= 1
	m -= 1
	i += 1
if i % 2 == 0:
	output = 'Malvika'
print(output)


inp = map(int, input().split())
x = min(inp)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = map(int, input().split())
a = x * y
c = 0
while a > 0:
	x -= 1
	y -= 1
	a = x * y
	c += 1
print('Malvika' if c % 2 == 0 else 'Akshat')


(horizontal, vertical) = map(int, input().split())
n = min([horizontal, vertical])
time = n
if time % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


line = input().split()
a = int(line[0])
b = int(line[1])
Min = min(a, b)
if Min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


grid = list(map(int, input().split()))
x = min(grid)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def main():
	arr = input().split()
	arr = [int(i) for i in arr]
	if min(arr[0], arr[1]) % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


import sys
input = sys.stdin.readline

def int_array():
	return list(map(int, input().split()))
a = int_array()
win = min(a)
if win % 2 == 0:
	winner = 'Malvika'
else:
	winner = 'Akshat'
print(winner)


(n, m) = map(int, input().split())
num = min(m, n)
print(('Malvika', 'Akshat')[num % 2])


n = list(map(int, input().split()))
i = 1
c = 0
for j in n:
	i = i * j
while i > 0:
	n[0] = n[0] - 1
	n[1] = n[1] - 1
	i = n[0] * n[1]
	c = c + 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
(x, y) = [int(a) for a in input().split()]
if min(x, y) & 1:
	print('Akshat')
else:
	print('Malvika')


def main():
	a = input().split()
	n = int(a[0])
	m = int(a[1])
	n = int(min(n, m))
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


def intersections(m, n):
	return (m + n) * (m + n - 1) // 2 - m * (m - 1) // 2 - n * (n - 1) // 2
(m, n) = list(map(int, input().split()))
i = 0
while intersections(m, n) != 0:
	m -= 1
	n -= 1
	i += 1
if i % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


lineArr = input().split(' ')
for i in range(len(lineArr)):
	lineArr[i] = int(lineArr[i])
n = lineArr[0]
m = lineArr[1]
numMoves = 0
while n * m > 0:
	n -= 1
	m -= 1
	numMoves += 1
if numMoves % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


x = list(map(int, input().split()))
if x[0] == x[1]:
	if x[0] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif min(x) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
tot = n + m
cnt = 0
while tot > max(m, n) - min(m, n):
	cnt += 1
	tot -= 2
if cnt % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


i = list(map(int, input().split()))
j = min(i)
if j % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


sticks_num = input().split()
N = int(sticks_num[0])
M = int(sticks_num[1])
if min([N, M]) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


measures = input()
measures = list(map(int, measures.split()))
horizontal = measures[0]
vertical = measures[1]
smallest = vertical
if horizontal < vertical:
	smallest = horizontal
if smallest % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from sys import stdin, stdout
(n, m) = map(int, input().split())
flag = 0
count = 0
while n > 0 and m > 0:
	if count % 2 == 0:
		flag = 1
	else:
		flag = 2
	count += 1
	n -= 1
	m -= 1
if flag == 1:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().strip().split())
t = min((a, b))
if t % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve_the_problem():
	(n, m) = [int(x) for x in input().split(' ')]
	min_sticks = min(n, m)
	if min_sticks % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')
solve_the_problem()


(n, m) = input().split()
(n, m) = (int(n), int(m))
if n > m:
	temp = m
	m = n
	n = temp
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


print('Akshat' if min(map(int, str.split(input()))) & 1 else 'Malvika')


print('MAaklsvhiakta'[sorted(map(int, input().split()))[0] % 2::2])


(m, n) = map(int, input().split())
m = int(m)
n = int(n)
x = m * n
i = 0
while x > 0:
	x = x - (m + n - 1)
	i = i + 1
	m = m - 1
	n = n - 1
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split(' '))
A = n * m
moves = 0
while A > 0:
	n = n - 1
	m = m - 1
	A = n * m
	moves += 1
if moves % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


x = input().split()
newx = [int(item) for item in x]
a = min(newx)
if a % 2 == 0:
	print('Malvika')
elif a == 0:
	print('Malvika')
else:
	print('Akshat')


x = list(map(int, input().split()))
j = x[0] * x[1]
k = 0
while j > 0:
	j -= x[0] + x[1] - 1
	x[0] -= 1
	x[1] -= 1
	k += 1
	if x[0] == 0 or x[1] == 0:
		break
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
a = True
i = 0
while min(m, n) != 1:
	i = i + 1
	m = m - 1
	n = n - 1
if i % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
a = ['Malvika', 'Akshat']
print(a[min(n, m) % 2])


n = list(map(int, input().split()))
c = 0
for i in range(1, n[0] + 1):
	for j in range(1, n[-1] + 1):
		if i == j:
			c += 1
if c % 2 == 0:
	s = ''
	for i in range(c, 0, -1):
		if i == 0:
			break
		elif i % 2 == 0:
			s = 'Akshat'
		elif i % 2 == 1:
			s = 'Malvika'
if c % 2 == 1:
	s = ''
	for i in range(c, 0, -1):
		if i == 0:
			break
		elif i % 2 == 1:
			s = 'Akshat'
		elif i % 2 == 0:
			s = 'Malvika'
print(s)


print(['Akshat', 'Malvika'][min(list(map(int, input().split()))) % 2 == 0])


(a, m) = map(int, input().split())
numberOfGames = min(a, m)
if numberOfGames % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split())
if a < b:
	p = a
else:
	p = b
if p % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split()]
num = min(n, m)
if num % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(r, c) = map(int, input().split())
if r < c:
	min = r
else:
	min = c
if min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


values = input().split()
(x, y) = (int(values[0]), int(values[1]))
which = min(x, y)
if which % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


y = [int(i) for i in input().split()]
if y[0] > y[1]:
	if y[1] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif y[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


x = min(list(map(int, input().split())))
print(['Malvika', 'Akshat'][x % 2])


import re
pattern = '\\d{1,3}'
input_string = input()
input_letters = re.findall(pattern, input_string)
m = int(input_letters[0])
n = int(input_letters[1])
if m < n:
	turns = m
else:
	turns = n
if turns % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())

def who_wins(x):
	if x % 2 == 0:
		return 'Malvika'
	else:
		return 'Akshat'
if n < m:
	print(who_wins(n))
else:
	print(who_wins(m))


s = input()
(n, m) = s.split(' ')
n = int(n)
m = int(m)
t = n * m
if n < m:
	l = n
else:
	l = m
p = 0
while l > 0:
	p = p + 1
	n = n - 1
	m = m - 1
	l = l - 1
if p % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def isWinnerFirst(sticks):
	return min(int(sticks[0]), int(sticks[1])) % 2 == 1
print('Akshat' if isWinnerFirst(input().split(' ')) else 'Malvika')


first_player = 'Akshat'
second_player = 'Malvika'
str = input().split()
(n, m) = (int(str[0]), int(str[1]))
if min(n, m) % 2 != 0:
	print(first_player)
else:
	print(second_player)


field = input()
spazio = field.find(' ')
m = int(field[:spazio])
n = int(field[spazio + 1:])
winning = min(m, n)
if winning / 2 == winning // 2:
	print('Malvika')
else:
	print('Akshat')


lst = list(map(int, input().split()))
n = lst[0]
m = lst[1]
small = n if n < m else m
if small % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split()]
count = 0
for i in range(0, n):
	n -= 1
	m -= 1
	count += 1
	if m == 0:
		break
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split()]
k = [[1 for p in range(n)] for q in range(m)]
(x, y) = (0, 0)
count = 0
number = 0
while True:
	(x, y) = (-1, -1)
	for a in range(m):
		for b in range(n):
			if k[a][b] != 0:
				(x, y) = (a, b)
				break
	if x == -1 and y == -1:
		break
	else:
		for c in range(n):
			k[x][c] = 0
		for d in range(m):
			k[d][y] = 0
		number += 1
if number % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


n1 = [0] * 2
n1 = list(map(int, input().split()))
a = int(n1[0])
b = int(n1[1])
j = 0
sum = a + b
i = 0
while a > 1 and b > 1:
	a = a - 1
	b = b - 1
	j = j + 1
if j % 2 != 0:
	print('Malvika')
else:
	print('Akshat')


def main():
	(n, m) = map(int, input().split())
	k = 0
	while n * m != 0:
		n -= 1
		m -= 1
		k += 1
	if k & 1 == 1:
		print('Akshat')
	else:
		print('Malvika')
main()


def empty(graph, n, m, l):
	for x in range(n):
		for y in range(m):
			if graph[x][y] == 1:
				l[0] = x
				l[1] = y
				return True
	return False
(n, m) = map(int, input().split())
graph = [[1 for x in range(m)] for y in range(n)]
t = True
l = [0, 0]
winner = 'Malvika'
while t:
	for x in range(m):
		graph[l[0]][x] = 0
	for x in range(n):
		graph[x][l[1]] = 0
	if winner == 'Malvika':
		winner = 'Akshat'
	else:
		winner = 'Malvika'
	t = empty(graph, n, m, l)
print(winner)


l = [int(k) for k in input().split(' ')]
(n, m) = (l[0], l[1])
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def _451A(m, n):
	return 'Akshat' if min(m, n) % 2 == 1 else 'Malvika'
(m, n) = list(map(lambda x: int(x), input().split()))
print(_451A(m, n))


class Solution(object):

	def __init__(self):
		self.get_data()
		self.solve()
		self.print_ans()
	pass

	def get_data(self):
		(self.n, self.m) = map(int, input().split())
		pass

	def solve(self):
		mn = min(self.n, self.m)
		if mn & 1:
			self.ans = 'Akshat'
		else:
			self.ans = 'Malvika'
		pass

	def print_ans(self):
		print(self.ans)
		pass

def main():
	Solution()
	pass
main()


def main():
	(n, m) = list(map(int, input().split()))
	if m > n:
		(n, m) = (m, n)
	if n % 2 == 0 and m % 2 == 0:
		print('Malvika')
	elif n % 2 == 1 and m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
print('Malvika' if min(zz()) & 1 == 0 else 'Akshat')


grid = input().split(' ')
min_stick = min(int(grid[0]), int(grid[1]))
if min_stick % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


x = list(map(int, input().split()))
x.sort()
x = x[0]
players_ordered = ['Malvika', 'Akshat']
if x > 1:
	print(players_ordered[x % 2])
elif x == 1:
	print(players_ordered[1])


(n, m) = map(int, input().split())

def interPoint(n, m):
	return n * m

def totalSticks(n, m):
	return n + m
step = 0
while n * m > 0:
	step += 1
	n -= 1
	m -= 1
	if n * m == 0:
		if step % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')


m = input()
n = list(m.split())
s = int(n[0]) + int(n[1])
c = int(n[0])
r = int(n[1])
while True:
	s = s - 2
	c = c - 1
	r = r - 1
	if c == 0 or r == 0:
		print('Akshat')
		break
	if s < 2:
		print('Akshat')
		break
	s = s - 2
	c = c - 1
	r = r - 1
	if c == 0 or r == 0:
		print('Malvika')
		break
	if s < 2:
		print('Malvika')
		break


s = input().split()
n = int(s[0])
m = int(s[1])
Awin = False
while m != 0 and n != 0:
	n -= 1
	m -= 1
	Awin = not Awin
if Awin:
	print('Akshat')
else:
	print('Malvika')


read = lambda : map(int, input().split())
(n, m) = read()
a = n * m
c = 0
while a > 0:
	a -= n + m - 1
	n -= 1
	m -= 1
	c += 1
print('Malvika' if c % 2 == 0 else 'Akshat')


import sys

def data():
	return sys.stdin.readline().strip()

def sp():
	return map(int, data().split())

def l():
	return list(sp())
(n, m) = l()
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


n = list(map(int, input().split()))
if n[0] > n[1]:
	x = n[1]
else:
	x = n[0]
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
re = n * m
c = 0
while re > 0:
	m -= 1
	n -= 1
	c += 1
	if m < 0 or n < 0:
		break
if c % 2:
	print('Malvika')
else:
	print('Akshat')


jogadorB = 'Akshat'
jogadorA = 'Malvika'
stri = input()
stri = stri.split(' ')
n = int(stri[0])
m = int(stri[1])
if n > m:
	if m % 2 == 0:
		print(jogadorA)
	else:
		print(jogadorB)
elif m > n:
	if n % 2 == 0:
		print(jogadorA)
	else:
		print(jogadorB)
elif n == m:
	if n % 2 == 0:
		print(jogadorA)
	else:
		print(jogadorB)


def check_points(hor, ver):
	value = min(hor, ver)
	if value % 2 == 0:
		return 'Malvika'
	else:
		return 'Akshat'
(hor, ver) = list(map(int, input().split()))
print(check_points(hor, ver))


(x, y) = input().split()
x = int(x)
y = int(y)
z = x + y
w = x * y
m = 0
if min(x, y) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


def palki(n, m):
	if not min(n, m) & 1:
		return 'Malvika'
	return 'Akshat'
(N, M) = [int(i) for i in input().split()]
print(palki(N, M))


a = input().split()
a = list(map(int, a))
C = int(a[0])
L = int(a[1])
if C != L:
	mini = min(C, L)
	if mini % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif C % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


arr = [int(i) for i in input().split()]
count = 0
(x, y) = (arr[0], arr[1])
while x > 0 and y > 0:
	x = x - 1
	y = y - 1
	count = count + 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


nm = input().split(' ')
n = int(nm[0])
m = int(nm[1])
winner = 1
while n > 0 and m > 0:
	winner = 0 if winner == 1 else 1
	n -= 1
	m -= 1
print('Akshat' if winner == 0 else 'Malvika')


from sys import stdin
(n, m) = [int(x) for x in stdin.readline().rstrip().split()]
print(('Malvika', 'Akshat')[min(n, m) % 2])


mn = [int(i) for i in input().split()]
move = min(mn)
if move % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


coordinates = list(map(int, input().split()))
x = coordinates[0]
y = coordinates[1]
turn = 0
while x != 0 and y != 0:
	turn += 1
	x -= 1
	y -= 1
if turn % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


y = list(map(int, input().split()))
low = min(y)
if low % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


s = input('')
n_m = list(s.split(' '))
inte = []
for i in n_m:
	inte.append(int(i))
res = all((el == inte[0] for el in inte))
if res == True:
	if inte[0] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif min(inte) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
t = max(n, m)
c = 1
for i in range(t):
	if n == 1 or m == 1:
		break
	n = n - 1
	m = m - 1
	c = c + 1
if c % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


k = list(map(int, input().strip().split(' ')))
if min(k[0], k[1]) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


[n, m] = [int(i) for i in input().split(' ')]
point = n * m
turns = 0
while point != 0:
	n -= 1
	m -= 1
	point = n * m
	turns += 1
if turns % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = tuple(map(int, input().split()))
smaller = min(n, m)
if smaller % 2:
	print('Akshat')
else:
	print('Malvika')


print(['Malvika', 'Akshat'][int(sorted(map(int, input().split()))[0]) % 2])


L = input()
L = L.split()
n = int(L[0])
m = int(L[1])
if n < m:
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def main():
	(n, m) = [int(x) for x in input().split()]
	while True:
		(m, n) = jogada(n, m)
		if not m * n:
			print('Akshat')
			break
		(m, n) = jogada(n, m)
		if not m * n:
			print('Malvika')
			break

def jogada(n, m):
	m -= 1
	n -= 1
	return (m, n)
main()


def inputMatrix(rows):
	return [list(map(int, input().split())) for _ in range(rows)]
(N, M) = map(int, input().split())
t = N * M
AkshTurn = False
while N * M:
	N -= 1
	M -= 1
	AkshTurn = not AkshTurn
print('Malvika' if not AkshTurn else 'Akshat')


import sys
import collections
import math
input = sys.stdin.readline

def printnl(val):
	sys.stdout.write(str(val) + '\n')
(n, m) = map(int, input().split())
print(['Akshat', 'Malvika'][(min(n, m) & 1) - 1])


(n, m) = map(int, input().split())
while n > 0 and m > 0:
	n -= 1
	m -= 1
	if n == 0 or m == 0:
		print('Akshat')
		exit()
	n -= 1
	m -= 1
	if n == 0 or m == 0:
		print('Malvika')
		exit()


(r, c) = map(int, input().split())
t = r * c
i = 0
while t != 0:
	r = r - 1
	c = c - 1
	t = r * c
	i += 1
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = tuple(map(int, input().split(' ')))
move = 1
while True:
	n -= 1
	m -= 1
	if n < 1 or m < 1:
		break
	move += 1
if move % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(m, n) = list(map(int, input().split()))
ip = m * n
c = 0
while ip > 0:
	ip -= m + n - 1
	m -= 1
	n -= 1
	c += 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
ah = 1
cur = n * m
while cur > 0:
	cur -= n + m - 1
	n -= 1
	m -= 1
	ah *= -1
if ah == -1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(x) for x in input().split()]
intersections = n * m
count = 1
numturns = 0
while intersections > 0:
	intersections -= n + m - count
	count += 2
	numturns += 1
if numturns % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(ak, mal) = (0, 0)
(n, m) = map(int, input().split())
a = min(n, m)
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
(n, m) = map(int, input().split())
i = min(n, m)
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(s, h) = map(int, input().split())
if min(s, h) & 1:
	print('Akshat')
else:
	print('Malvika')


coordinate = list(map(int, input().split()))
print('Akshat') if min(coordinate) % 2 else print('Malvika')


def solve(n, m):
	if min(n, m) % 2 == 0:
		return 'Malvika'
	else:
		return 'Akshat'

def test():
	assert solve(2, 2) == 'Malvika'
	assert solve(2, 3) == 'Malvika'
	assert solve(3, 3) == 'Akshat'

def main():
	[n, m] = [int(i) for i in input().strip().split()]
	result = solve(n, m)
	print(result)
main()


matriz = list(map(int, input().split()))
jogadas = min(matriz[0], matriz[1])
if jogadas % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


istr = input()
[x, y] = istr.split(' ')
n = int(x)
m = int(y)
prod = n * m
c = 0
while n * m > 0:
	c = c + 1
	n = n - 1
	m = m - 1
if c % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


__author__ = 'Gleb'
a = input().split()
(n, m) = a
(n, m) = (int(n), int(m))
if m < n:
	n = m
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def main():
	from sys import stdin, stdout
	(a, b) = map(int, stdin.readline().split())
	if a == 1 or b == 1:
		stdout.write('Akshat')
	elif min(a, b) ** 2 & 1:
		stdout.write('Akshat')
	else:
		stdout.write('Malvika')
main()


from sys import stdin, stdout

def main():
	nums = [int(x) for x in stdin.readline().split(' ')]
	nums.sort()
	if nums[0] % 2 == 0:
		stdout.write('Malvika\n')
	else:
		stdout.write('Akshat\n')
main()


(n, m) = map(int, input().strip().split())
if n * m / max(n, m) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


a = list(map(int, input().split()))
if min(a) % 2 == 0:
	print('Malvika')
elif min(a) % 2 == 1:
	print('Akshat')


lista = input().split(' ')
min = int(lista[0])
if int(lista[1]) < min:
	min = int(lista[1])
if min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


li = list(map(int, input().split()))
n = min(li)
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
checkFlag = 0
intersectionList = []
for i in range(1, n + 1):
	for j in range(1, m + 1):
		intersectionList.append([i, j])
intersectionList.reverse()
while len(intersectionList) > 0:
	(horizontalAxis, verticalAxis) = intersectionList.pop()
	checkFlag += 1
	removeList = []
	for element in intersectionList:
		if element[0] == horizontalAxis or element[1] == verticalAxis:
			removeList.append(element)
	for ele in removeList:
		intersectionList.remove(ele)
if checkFlag % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split(' '))
res = a * b
s = ''
c = 0
while res > 0:
	res = res - (a + (b - 1))
	c = c + 1
	a = a - 1
	b = b - 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


stk = input()
nstkv = 0
nstkh = 0
lista = []
aux = ''
for q in stk:
	if q != ' ':
		aux += q
	else:
		nstkv += int(aux)
		aux = ''
nstkh += int(aux)
lista.append(nstkv)
lista.append(nstkh)
if min(lista) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


n = input().split()
(n, m) = [int(i) for i in n]
MW = False
while n > 1 and m > 1:
	m -= 1
	n -= 1
	MW = not MW
if MW:
	print('Malvika')
else:
	print('Akshat')


x = input()
y = x.split()
z = [int(d) for d in y]
a = min(z)
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from collections import defaultdict as dd

def lcm(a, b):
	return a * b // gcd(a, b)

def inin():
	return int(input())

def inar():
	return list(map(int, input().split()))

def ar(element, size):
	return [element for i in range(size)]

def digitsum(num):
	su = 0
	while num:
		su += num % 10
		num //= 10
	return su

def yes():
	print('YES')

def no():
	print('NO')

def countDivisibles(A, B, M):
	if A % M == 0:
		return B // M - A // M + 1
	return B // M - A // M

def countSetBits(n):
	count = 0
	while n:
		count += n & 1
		n >>= 1
	return count
Testcase = 1
for _ in range(Testcase):
	(n, m) = inar()
	if min(n, m) % 2:
		print('Akshat')
	else:
		print('Malvika')


print('MAaklsvhiakta'[min([int(i) for i in list(input().split())]) % 2::2])


n = list(map(int, input().split()))
s = 0
first = n[0]
second = n[1]
for i in range(max(n[0], n[1])):
	if first == 1 or second == 1:
		s += 1
		break
	first -= 1
	second -= 1
	s += 1
if s % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math

def main():
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	if n < 1 or m > 100:
		exit(1)
	if m == 1 or n == 1:
		result = 'Akshat'
	if m % 2 == 0 and n % 2 == 0:
		result = 'Malvika'
	elif m % 2 != 0 and n % 2 != 0:
		result = 'Akshat'
	elif n > m and n % 2 == 0:
		result = 'Akshat'
	elif m > n and m % 2 == 0:
		result = 'Akshat'
	else:
		result = 'Malvika'
	print(result)
main()


s = input()
p = s.split()
n = int(p[0])
m = int(p[1])
k = min(m, n)
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split(' ')]
a = ['Malvika', 'Akshat']
i = min(n, m) & 1
print(a[i])


(s, t) = map(int, input().split(' '))
print('Akshat' if min(s, t) % 2 else 'Malvika')


(n, m) = map(int, input().split())
t = n * m
ma = 0
while t != 0:
	t -= n + m - 1
	n -= 1
	m -= 1
	ma += 1
print('Malvika' if ma % 2 == 0 else 'Akshat')


import re
a = re.split(' ', input())
c = 101
for i in range(0, len(a)):
	if int(a[i]) < c:
		c = int(a[i])
print(['Malvika', 'Akshat'][c % 2])


(n, m) = map(int, input().split())
flag = 0
a = []
b = []
for i in range(n):
	a.append(1)
for i in range(m):
	b.append(1)
i = 0
while any(a) and any(b) and (i < min(len(a), len(b))):
	if flag == 0:
		flag = 1
	else:
		flag = 0
	a[i] = 0
	b[i] = 0
	i += 1
print('Malvika' if flag == 0 else 'Akshat')


m = list(map(int, input().split()))
mini = min(m[0], m[1])
print('Akshat') if mini % 2 != 0 else print('Malvika')


(m, n) = list(map(int, input().split()))
is_m_even = m % 2 == 0
is_n_even = n % 2 == 0
player1 = 'Akshat'
player2 = 'Malvika'
if is_m_even and is_n_even:
	print(player2)
elif not is_m_even and (not is_n_even):
	print(player1)
else:
	if n > m:
		(m, n) = (n, m)
		(is_n_even, is_m_even) = (is_m_even, is_n_even)
	if is_n_even:
		print(player2)
	else:
		print(player1)


data = map(int, input().split())
data = list(data)
_min = min(data)
if _min % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
t = 0
while n > 0 and m > 0:
	t += 1
	m -= 1
	n -= 1
dic = {1: 'Akshat', 0: 'Malvika'}
print(dic[t % 2])


(m, n) = input().split()
chk = int(m) * int(n)
if int(m) == 1 or int(n) == 1:
	print('Akshat')
elif min(int(m), int(n)) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(ver, hor) = input().split(' ')
ver = int(ver)
hor = int(hor)
cnt = 0
while ver != 0 and hor != 0:
	ver -= 1
	hor -= 1
	cnt += 1
if cnt % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from sys import stdout
grid = input().split()
x = int(grid[0])
y = int(grid[1])
optimalMoves = x if x < y else y
stdout.write('Akshat' if optimalMoves % 2 == 1 else 'Malvika')


(n, m) = map(int, input().split())
maxValue = max(m, n)
minValue = min(m, n)
if minValue % 2:
	print('Akshat')
else:
	print('Malvika')


(a, b) = input().split()
horiz = int(a)
vert = int(b)
if horiz > vert:
	if vert % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif horiz < vert:
	if horiz % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif horiz == vert:
	if vert % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


def gameWithSticks(n, m):
	if min(n, m) % 2 == 0:
		return 'Malvika'
	return 'Akshat'
(n, m) = input().split()
print(gameWithSticks(int(n), int(m)))


def smaller(x, y):
	if x < y:
		return x
	return y
anslist = ['Malvika', 'Akshat']
(N, M) = map(int, input().split())
print(anslist[smaller(N, M) % 2])


(a, b) = map(int, input().split())
m = 0
while True:
	a = a - 1
	b = b - 1
	m = m + 1
	if a * b == 0:
		print(['Akshat', 'Malvika'][m % 2 == 0])
		break


(hor, ver) = input().split()
hor = int(hor)
ver = int(ver)
if hor > ver:
	if ver % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif hor % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


inputed = input()
inputed = inputed.split(' ')
row = int(inputed[0])
col = int(inputed[1])
result = row
if row > col:
	result = col
if result % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split()]
akshatWin = False
points = n * m
while points != 0:
	akshatWin = not akshatWin
	n -= 1
	m -= 1
	points -= 1 + m + n
if akshatWin:
	print('Akshat')
else:
	print('Malvika')


inputs = [int(x) for x in input().split()]
result = 'Akshat'
if min(inputs) % 2 == 0:
	result = 'Malvika'
print(result)


lines = input()
lines = lines.split(' ')
horizontal = int(lines[0])
vertical = int(lines[1])
win_number = 0
if horizontal == vertical:
	win_number = horizontal
else:
	win_number = min(horizontal, vertical)
if win_number % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split(' '))
c = []
c.append(n)
c.append(m)
c.sort()
if c[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
(grid, count) = ([[1] * m] * n, 0)
while grid != [[0] * m] * n:
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				count += 1
				grid[i] = [0] * m
				for k in range(n):
					grid[k][i] = 0
if count % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
count = 0
if m == 1 or n == 1:
	print('Akshat')
else:
	if n == m:
		count += n
	elif n > m:
		count += m
	else:
		count += n
	if count % 2 != 0:
		print('Akshat')
	else:
		print('Malvika')


x = input().split()
for i in range(len(x)):
	x[i] = int(x[i])
x = min(x)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, s) = list(map(int, input().split()))
if min(m, s) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


x = [int(i) for i in input().split()]
if x[0] >= x[1] and x[1] % 2 == 0:
	print('Malvika')
elif x[0] < x[1] and x[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


t = input()
dimension = t.split()
n = int(dimension[0])
m = int(dimension[1])
count = 0
while True:
	numberOfIntersection = n * m
	count += 1
	if numberOfIntersection < 1:
		break
	n = n - 1
	m = m - 1
count -= 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


p = input().split()
n = int(p[0])
m = int(p[1])
sum = 0
i = 0
while True:
	sum = sum + (m - i) + (n - 1) - i
	if sum == n * m:
		break
	i = i + 1
if i % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
p = 0
while n != 0 and m != 0:
	n -= 1
	m -= 1
	if p == 0:
		p = 1
	else:
		p = 0
if p == 0:
	print('Malvika')
else:
	print('Akshat')


(row, col) = list(map(int, input().split()))
total = row * col
k = 0
while total > 0:
	row -= 1
	col -= 1
	total = row * col
	k += 1
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


__author__ = 'Utena'
(m, n) = map(int, input().split())
x = min(m, n)
if x % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


lst = [int(x) for x in input().split()]
(n, m) = (lst[0], lst[1])
min_n = min(lst)
if min_n % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = input().split()
n = int(n)
m = int(m)
l = 0
p = 0
i = 0
while n > 0 and m > 0:
	i += 1
	n -= 1
	m -= 1
	if i % 2 == 0:
		l += 1
	else:
		p += 1
if p > l:
	print('Akshat')
if p == l:
	print('Malvika')


s = input()
a = s.split()
for i in range(len(a)):
	a[i] = int(a[i])
i = 1
while a[0] != 0 and a[1] != 0:
	a[0] -= 1
	a[1] -= 1
	if i % 2 != 0:
		i += 1
	else:
		i -= 1
if i == 2:
	print('Akshat')
else:
	print('Malvika')


n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = 0
while 1:
	if a == 0 or b == 0:
		break
	a = a - 1
	b = b - 1
	c = c + 1
if c % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(x) for x in input().split()]
temp = min(n, m)
winner = temp & 1
print('Akshat') if winner else print('Malvika')


import sys

class Scanner:

	def __init__(self):
		self.current_tokens = []

	def remaining_tokens(self):
		return len(self.current_tokens)

	def nextline(self):
		assert self.remaining_tokens() == 0, 'Reading next line with remaining tokens'
		return input()

	def nexttokens(self):
		return self.nextline().split()

	def nexttoken(self):
		if len(self.current_tokens) == 0:
			self.current_tokens = self.nexttokens()
		assert self.remaining_tokens() > 0, 'Not enough tokens to parse.'
		return self.current_tokens.pop(0)

	def nextints(self, n=-1):
		if n == -1:
			return list(map(int, self.nexttokens()))
		else:
			return (self.nextint() for i in range(n))

	def nextint(self):
		return int(self.nexttoken())

def quit():
	sys.exit(0)
stdin = Scanner()
nextint = stdin.nextint
nextints = stdin.nextints
nextline = stdin.nextline
(n, m) = nextints(2)
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
winner = 1
players = ['Akshat', 'Malvika']
while n * m != 0:
	n -= 1
	m -= 1
	winner = 1 - winner
print(players[winner])


import sys
cases = sys.stdin.readline().strip().split(' ')
a = int(cases[0])
b = int(cases[1])
if min(a, b) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def GameWithSticks(n, m):
	if n < m:
		if n % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
	elif m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
(n, m) = input().split()
GameWithSticks(int(n), int(m))


(p1, l1) = input().split()
p = int(p1)
l = int(l1)
c = 0
while p >= 1 and l >= 1:
	p = p - 1
	l = l - 1
	c = c + 1
if c % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


def smaller(a, b):
	if a > b:
		return b
	return a
(n, m) = [int(x) for x in input().split()]
l = ['Malvika', 'Akshat']
s = smaller(n, m)
print(l[s % 2])


s = input().split(' ')
(n, m) = [int(s[i]) for i in range(0, 2)]
if min(n, m) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
c = 0
p = n * m
while p > 0:
	c += 1
	p -= m + n - 1
	(m, n) = (max(0, m - 1), max(0, n - 1))
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


tmp = input().split()
(a, b) = (int(tmp[0]), int(tmp[1]))
a1 = a
b1 = b
for i in range(min(a, b)):
	a1 -= 1
	b1 -= 1
	if a1 == 0 or b1 == 0:
		break
if i % 2 != 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = input().split(' ')
(n, m) = (int(n), int(m))
i = n * m
t = 0
while i > 0:
	n -= 1
	m -= 1
	i = n * m
	t += 1
if t % 2:
	print('Akshat')
else:
	print('Malvika')


(hor, vert) = map(int, input().split())
if min(hor, vert) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(p, q) = map(int, input().split())
t = p * q
j = 0
while t > 0:
	p -= 1
	q -= 1
	t = p * q
	j += 1
if j % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
if a == 1 and b == 2 or (a == 2 and b == 1):
	print('Akshat')
elif min(a, b) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


arr = list(map(int, input().strip().split()))
x = min(arr)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def decress(turn):
	if turn == 'a' and N[0] > 0 and (N[1] > 0):
		N[0] -= 1
		N[1] -= 1
		return 1
	elif turn == 'm' and N[0] > 0 and (N[1] > 0):
		N[0] -= 1
		N[1] -= 1
		return 1
	else:
		return 0
N = [int(i) for i in input().split()]
if N[0] * N[1] != 0:
	aks = mal = 0
	while N[0] > 0 and N[1] > 0:
		aks += decress('a')
		mal += decress('m')
	if aks > mal:
		print('Akshat')
	else:
		print('Malvika')
else:
	print('Akshat')


n = map(int, input().strip().split())
n = sorted(n)
if n[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(N, M) = map(int, input().split())
if min(N, M) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = (int(x) for x in input().split(' '))
ans = ''
while n != 0 and m != 0:
	n -= 1
	m -= 1
	if ans == '':
		ans = 'Akshat'
	elif ans == 'Akshat':
		ans = 'Malvika'
	else:
		ans = 'Akshat'
print(ans)


(h, v) = map(int, input().split())
m = 0
a = h * v
i = 1
while i >= 1:
	h = h - 1
	v = v - 1
	a = h * v
	if a == 0:
		m = i
		break
	i += 1
if m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(h, v) = map(int, input().split())
a = min(h, v)
x = a
s = 'Malvika'
for i in range(a):
	x -= 1
	if s == 'Akshat':
		s = 'Malvika'
	else:
		s = 'Akshat'
	if x == 0:
		print(s)


(x, y) = map(int, input().split())
t = 0
while True:
	t += 1
	x = x - 1
	y = y - 1
	if x == 0 or y == 0:
		break
if t % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
k = min(a, b)
if a == 1 or b == 1 or k & 1:
	print('Akshat')
else:
	print('Malvika')


(hor, ver) = [int(n) for n in input().split(' ')]
inter = hor * ver
win = 0
while inter != 0:
	hor -= 1
	ver -= 1
	inter = hor * ver
	if win == 0:
		won = 'Akshat'
		win += 1
	else:
		won = 'Malvika'
		win -= 1
print(won)


(n, m) = input().split()
n = int(n)
m = int(m)
akshat = True
while n * m != 0:
	n -= 1
	m -= 1
	akshat = not akshat
if akshat:
	print('Malvika')
else:
	print('Akshat')


N = str(input())
(a, b) = [int(i) for i in N.split()]
s = min(a, b)
if s % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


info = input().split(' ')
n = int(info[0])
m = int(info[1])
p1 = 'Akshat'
p2 = 'Malvika'
if min(n, m) % 2 == 0:
	print(p2)
else:
	print(p1)


mn = input().split()
m = int(mn[0])
n = int(mn[1])
a = min(m, n)
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = (int(x) for x in input().split(' '))
turns = min(a, b) - 1
if turns % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


(n, m) = list(map(int, input().split()))
moves = n * m
turn = 1
while moves > 0 and m >= 1 and (n >= 1):
	moves -= n + m - 1
	n -= 1
	m -= 1
	turn = 1 - turn
if turn == 0:
	print('Akshat')
else:
	print('Malvika')


def grid():
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	grids = n * m
	sticks = n + m
	k = 1
	while grids >= 0 and n >= 0 and (m >= 0):
		n = n - 1
		m = m - 1
		grids = n * m
		k = k + 1
	if k % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
grid()


(n, m) = [int(i) for i in input().split()]
point = n * m
steps = 0
while True:
	if m == 0 or n == 0:
		break
	point -= m + n - 1
	m -= 1
	n -= 1
	steps += 1
if steps % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(m, n) = map(int, input().split())
s = m + n
p = m * n
k = 0
while p > 0:
	p = p - (s - 1)
	s = s - 2
	k = k + 1
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
point = n * m
turn = 0
while n and m:
	turn += 1
	n -= 1
	m -= 1
print(['Akshat', 'Malvika'][turn % 2 == 0])


(m, n) = map(int, input().split())
res = 0
if m == n:
	res = m ** n
if m < n:
	res = m ** n
elif m > n:
	res = n ** m
if res % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from sys import stdin, stdout

def main():
	line = stdin.readline()
	parts = line.split()
	n = int(parts[0])
	m = int(parts[1])
	if n <= m:
		if n % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
	elif m % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


ar = list(map(int, input().split()))
(n, m) = (ar[0], ar[1])
(aks, mal) = ('Akshat', 'Malvika')
small = 0
if n < m:
	small = n
elif m < n:
	small = m
else:
	small = n
if small % 2 != 0:
	print(aks)
else:
	print(mal)


(n, m) = map(int, input().split())
cnt = 0
K = ['Akshat', 'Malvika']
while n and m:
	n -= 1
	m -= 1
	cnt += 1
print(K[(cnt + 1) % 2])


def game_with_stick():
	row_col = input().split(' ')
	even = min(int(row_col[0]), int(row_col[1])) % 2 == 0
	return 'Malvika' if even else 'Akshat'
print(game_with_stick())


x = [int(x) for x in input().split()]
n = x[0]
m = x[1]
if n == 1 or m == 1:
	print('Akshat')
elif min(x) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


def play(P):
	if P == 'A' and x[0] > 0 and (x[1] > 0):
		x[0] -= 1
		x[1] -= 1
		return 1
	elif P == 'M' and x[0] > 0 and (x[1] > 0):
		x[0] -= 1
		x[1] -= 1
		return 1
	else:
		return 0
x = [int(i) for i in input().split()]
if x[0] * x[1] != 0:
	a = m = 0
	while x[0] > 0 and x[1] > 0:
		a += play('A')
		m += play('M')
	if a > m:
		print('Akshat')
	else:
		print('Malvika')
else:
	print('Akshat')


def main():
	res_str = ['Malvika', 'Akshat']
	(n, m) = read()
	print(res_str[min(n, m) % 2])

def read(mode=2):
	inputs = input().strip()
	if mode == 0:
		return inputs
	if mode == 1:
		return inputs.split()
	if mode == 2:
		return map(int, inputs.split())

def read_str():
	return read(0)

def read_int():
	return read(1)

def write(s='\n'):
	if isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='')
main()


thing = input().split(' ')
thing[0] = int(thing[0])
thing[1] = int(thing[1])
counter = 0
while thing[0] > 0 and thing[1] > 0:
	counter += 1
	thing[0] -= 1
	thing[1] -= 1
if counter % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


def main():
	n_turns = min([int(_) for _ in input().split()])
	print('Malvika' if n_turns % 2 == 0 else 'Akshat')
main()


(horizontal, vertical) = [int(x) for x in input().split()]
length = min(horizontal, vertical)
name = ['Akshat', 'Malvika']
count = 0
for i in range(length + 1):
	count += 1
	if horizontal == 0 or vertical == 0:
		if count % 2 != 0:
			m = 1
		else:
			m = 0
		print(name[m])
	horizontal -= 1
	vertical -= 1


x = input()
x = x.split()
a = int(x[0])
b = int(x[1])
if a < b:
	c = a
else:
	c = b
print('Akshat' if c % 2 else 'Malvika')


(n, m) = map(int, input().split())
inter = n * m
palito = n + m
aux = 1
while inter > 0:
	n -= 1
	m -= 1
	inter = n * m
	aux += 1
if aux % 2 == 1:
	print('Malvika')
else:
	print('Akshat')


def solve_problem(a, b):
	m = min(a, b)
	return m - 1
(n, m) = map(int, input().split())
ans = solve_problem(n, m)
if ans & 1:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
print(['Akshat', 'Malvika'][min(n, m) % 2 != 1])


(n, m) = input().split()
n = int(n)
m = int(m)
t = 0
while t >= 0:
	if n > 0 and m > 0:
		t = t + 1
		n = n - 1
		m = m - 1
	else:
		break
if t % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def sticks(x, y):
	a = 0
	m = 0
	d = min(x, y)
	for i in range(0, d):
		if i % 2 == 0 and x * y > 0:
			a += 1
			x -= 1
			y -= 1
		elif i % 2 != 0 and x * y > 0:
			m += 1
			x -= 1
			y -= 1
	if a == m:
		return 'Malvika'
	elif a > m:
		return 'Akshat'
	elif a < m:
		return 'Malvika'
(x, y) = map(int, input().split())
print(sticks(x, y))


(n, m) = map(int, input().split())
a = n * m
b = n + m
cnt = 0
while a != 0:
	a = a - b + 1
	b = b - 2
	cnt = cnt + 1
print(['Malvika', 'Akshat'][cnt % 2])


(n, m) = list(map(int, input().split()))
print('MAaklsvhiakta'[min(n, m) % 2::2])


z = list(map(int, input().split()))
s = min(z)
q = []
for i in range(s):
	if i % 2 == 0:
		q.append('Akshat')
	else:
		q.append('Malvika')
print(q[-1])


def fun(n, m):
	if min(n, m) & 1:
		print('Akshat')
	else:
		print('Malvika')
(n, m) = list(map(lambda x: int(x), input().split()))
fun(n, m)


(a, b) = [int(i) for i in input().split(' ')]
if a * b == max(a, b) ** 2:
	if b % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif a * b != max(a, b) ** 2 and min(a, b) % 2 == 1:
	print('Akshat')
elif a * b != max(a, b) ** 2 and min(a, b) % 2 == 0:
	print('Malvika')


rozmery = map(int, input().split())
mensi = min(rozmery)
if mensi % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = input().split()
n = int(n)
m = int(m)
move = True
if min(n, m) % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


input = input().split()
a = []
for i in range(len(input)):
	a.append(int(input[i]))
min_n = min(a)
if min_n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, a) = [int(t) for t in input().split()]
h = min(m, a)
if h % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
if n % 2 == 0 and m % 2 == 0:
	print('Malvika')
elif n % 2 != 0 and m % 2 != 0:
	print('Akshat')
else:
	min1 = min(n, m)
	if min1 % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


A = [[0 for i in range(105)] for i in range(105)]
for i in range(101):
	A[i][1] = 'Akshat'
for i in range(2, 101):
	for j in range(2, i + 1):
		if A[i - 1][j - 1] == 'Akshat':
			A[i][j] = 'Malvika'
		else:
			A[i][j] = 'Akshat'
(m, n) = map(int, input().split())
(m, n) = (max(m, n), min(m, n))
print(A[m][n])


inp = input().split()
ans = min(int(inp[0]), int(inp[1]))
if ans % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
c = 0
while a[0] * a[1] > 0:
	a[0] -= 1
	a[1] -= 1
	c += 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math

def solve():
	(n, m) = map(int, input().split())
	if n > m:
		(n, m) = (m, n)
	if n % 2 == 0:
		return 'Malvika'
	return 'Akshat'
print(solve())


X = input().split(' ')
x = []
for i in X:
	x.append(int(i))
if x[0] == x[1]:
	if x[0] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
else:
	while True:
		c = 'Akshat'
		x[0] -= 1
		x[1] -= 1
		if x[0] == 0 or x[1] == 0:
			print(c)
			break
		c = 'Malvika'
		x[0] -= 1
		x[1] -= 1
		if x[0] == 0 or x[1] == 0:
			print(c)
			break


(m, n) = input().split(' ')
m = int(m)
n = int(n)
i = min(m, n)
if i % 2 == 0:
	print('Malvika')
if i % 2 != 0:
	print('Akshat')


word = input().split(' ')
n = int(word[0])
m = int(word[1])
k = min(n, m)
if k / 2 == k // 2:
	print('Malvika')
else:
	print('Akshat')


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
(n, m) = rinput()
s = min(n, m)
if s % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve():
	(n, m) = map(int, input().split())
	p = n * m
	i = 0
	while p != 0:
		(n, m) = (n - 1, m - 1)
		p = n * m
		i += 1
	if i % 2 == 0:
		return 'Malvika'
	return 'Akshat'
print(solve())


(m, n) = map(int, input().split())
total = m + n
j = 0
while m != 0 and n != 0:
	m -= 1
	n -= 1
	j += 1
if j % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import math
INF = 1000000000.0

def main():
	(n, m) = map(int, input().split())
	c = n * m
	turn = 'Malvika'
	while c > 0:
		c -= n + m - 1
		n -= 1
		m -= 1
		if turn == 'Akshat':
			turn = 'Malvika'
		else:
			turn = 'Akshat'
	print(turn)
main()


num = list(map(int, input().split()))
if min(num[0], num[1]) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


stickNumber = input()
stickList = stickNumber.split(' ')
n = int(stickList[0])
m = int(stickList[1])
move = n if n < m else m
print('Akshat') if move % 2 == 1 else print('Malvika')


def main():
	(n, m) = [int(i) for i in input().split(' ')]
	_ = min(n, m)
	print('Malvika') if _ % 2 == 0 else print('Akshat')
main()


(n, m) = [int(x) for x in input().split()]
move = 0
while n * m != 0:
	n -= 1
	m -= 1
	move += 11
if move % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
intersection_points = n * m
turn = 1
while intersection_points != 0:
	n -= 1
	m -= 1
	turn += 1
	intersection_points = n * m
if turn % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	(N, M) = getInts()
	return 'Akshat' if min(N, M) % 2 == 1 else 'Malvika'
ans = solve()
print(ans)


def main():
	(red, green) = input().split()
	if int(red) % 2 != 0 and int(green) % 2 != 0:
		print('Akshat')
	elif int(red) < int(green) and int(red) % 2 != 0 or (int(red) > int(green) and int(green) % 2 != 0):
		print('Akshat')
	else:
		print('Malvika')
main()


(n, m) = map(int, input().split())
ans = ('Malvika', 'Akshat')
print(ans[min(n, m) % 2])


import sys
input = lambda : sys.stdin.readline().strip()
(a, b) = map(int, input().split())
print(['Akshat', 'Malvika'][min(a + 1, b + 1) % 2])


import sys
a = list(map(int, input().split()))
if a[0] > a[1]:
	if a[1] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif a[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


arr = list(map(int, input().rstrip().split()))
if min(arr) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


var = input().split(' ')
arr = [0, 0]
arr[0] = int(var[0])
arr[1] = int(var[1])
i = 0
while arr[0] * arr[1] != 0:
	i += 1
	arr[0] -= 1
	arr[1] -= 1
if i % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(i) for i in input().split(' ')]
f = []
if n < m:
	(n, m) = (m, n)
for i in range(n):
	f.append([])
	f[i] = [1 for _ in range(m)]
a = 0
for i in range(m):
	f[i] = [0 for _ in range(len(f[i]))]
	for j in range(i, n):
		f[j][i] = 0
	a += 1
print('Akshat' if a % 2 else 'Malvika')


arr = []
arr = input().split()
a = 0
if int(arr[0]) < int(arr[1]):
	a = int(arr[0])
else:
	a = int(arr[1])
if a % 2:
	print('Akshat')
else:
	print('Malvika')


List = list(map(int, input().split(' ')))
k = min(List)
if k % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


def winDetermine(n, m):
	if min(n, m) % 2 == 0:
		return 'Malvika'
	return 'Akshat'
inputList = [int(x) for x in input().split()]
print(winDetermine(inputList[0], inputList[1]))


l = list(map(int, input().split(' ')))
total = l[0] * l[1]
k = l[0] + l[1] - 1
count = 0
while total > 0:
	total = total - k
	k = k - 2
	count = count + 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def seperateints(x):
	k = ''
	l = []
	for i in x:
		if i == ' ':
			l.append(int(k))
			k = ''
			continue
		k = k + i
	l.append(int(k))
	return l

def luckynum(x):
	for i in x:
		if i != '4' and i != '7':
			return False
	return True
l = seperateints(input())
x = l[0] * l[1]
n = 0
while x != 0:
	l[0] -= 1
	l[1] -= 1
	n += 1
	x = l[0] * l[1]
if n % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


l = list(map(int, input().split()))
count = 0
for i in range(0, l[0]):
	l[0] -= 1
	l[1] -= 1
	count += 1
	if l[1] == 0:
		break
if count % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


a = list(map(int, input().split()))
c = ['Akshat', 'Malvika']
c_help = 0
g = None
for i in range(min(a)):
	c_help += 1
	if c_help == 3:
		c_help = 1
	g = c[1 % c_help]
print(g)


varas = input('')
varas = varas.split(' ')
varasList = []
for item in varas:
	varasList.append(int(item))
if varasList[0] >= 1 and varasList[1] <= 100:
	if varasList[0] > varasList[1]:
		if varasList[1] % 2 == 0:
			print('Malvika')
		else:
			print('Akshat')
	elif varasList[0] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


(hor, ver) = input().split(' ')
hor = int(hor)
ver = int(ver)
minimum = min(hor, ver)
if minimum % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split()]
h = ['Malvika', 'Akshat']
print(h[min(n, m) % 2])


input_size = list(map(int, input().split()))
(n, m) = (input_size[0], input_size[1])
smaller_side = min(n, m)
if smaller_side % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
x = n * m
z = n + m - 1
q = 0
while True:
	q += 1
	x -= z
	z -= 2
	if x <= 0:
		break
if q % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(x) for x in input().split()]
d = {1: 'Akshat', 0: 'Malvika'}
mn = min(n, m)
print(d[mn % 2])


entrada = input().split()
n1 = int(entrada[0])
n2 = int(entrada[1])
if n1 >= 1 and n1 <= 100 and (n2 >= 1) and (n2 <= 100):
	if n1 < n2:
		pegar = n1
	else:
		pegar = n2
	if pegar % 2 == 0 and pegar != 0:
		print('Malvika')
	else:
		print('Akshat')


z = input().split()
n = int(z[0])
m = int(z[1])
a = 0
b = 0
while 1 <= n <= 100 and 1 <= m <= 100:
	x = n * m
	s = n + m
	a = a + x - (s - 1)
	n = n - 1
	m = m - 1
	b = b + 1
if b % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def sticks(n, m):
	if min(n, m) % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
(n, m) = input().split()
sticks(int(n), int(m))


nAndM = input()
n = int(nAndM.split()[0])
m = int(nAndM.split()[1])
deterPoint = min(n, m)
if deterPoint % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
cnt = 0
while n * m > 0:
	n -= 1
	m -= 1
	cnt += 1
if not cnt % 2:
	print('Malvika')
else:
	print('Akshat')


num = input()
arr = []
count = 0
for i in range(0, len(num)):
	if num[i] == ' ':
		arr.append(int(num[count:i]))
		count = i + 1
	elif i == len(num) - 1:
		arr.append(int(num[count:len(num)]))
result = None
if arr[0] <= arr[1]:
	if arr[0] % 2 == 0:
		result = 'Malvika'
	else:
		result = 'Akshat'
elif arr[1] % 2 == 0:
	result = 'Malvika'
else:
	result = 'Akshat'
print(result)


(a, b) = [int(x) for x in input().split()]
if a <= b and a % 2 == 0:
	print('Malvika')
if a <= b and a % 2 != 0:
	print('Akshat')
if b < a and b % 2 == 0:
	print('Malvika')
if b < a and b % 2 != 0:
	print('Akshat')


n = input()
n2 = n.split(' ')
k1 = int(n2[0])
k2 = int(n2[1])
m = k1 * k2
cnt = 0
kk = k1 + k2 - 1
mak = 2
while m > 0:
	m -= kk - mak * cnt
	cnt += 1
if cnt % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = [int(x) for x in input().split()]
a.sort()
if a[0] ** 2 % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


l = input().split()
n = int(l[0])
m = int(l[1])
ac = 0
if m == 1 or n == 1:
	ac = 0
while n != 1 and m != 1:
	n -= 1
	m -= 1
	ac += 1
if ac % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


l = list(map(int, input().split()))
l.sort()
if l[0] % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(m, n) = map(int, input().split()[:2])
if m % 2 == 1 and n % 2 == 1 or m == 1 or n == 1:
	print('Akshat')
elif m % 2 == 0 and n % 2 == 1 or (n % 2 == 0 and m % 2 == 1):
	if m % 2 == 0:
		(e, o) = (m, n)
	else:
		(e, o) = (n, m)
	if e > o:
		print('Akshat')
	else:
		print('Malvika')
else:
	print('Malvika')


def game(n, m, moves):
	if n == 0 or m == 0:
		if moves % 2 == 0:
			return 'Malvika'
		else:
			return 'Akshat'
	else:
		moves += 1
		return game(n - 1, m - 1, moves)
(x, y) = list(map(int, input().split(' ')))
print(game(x, y, 0))


getFirst_line = str(input())
getNumbers = [int(s) for s in getFirst_line.split(' ')]
horizontal_stick = getNumbers[0]
vertical_sticks = getNumbers[1]
last_mover = 'Akshat'
while True:
	horizontal_stick -= 1
	vertical_sticks -= 1
	if horizontal_stick == 0 or vertical_sticks == 0:
		break
	if last_mover == 'Akshat':
		last_mover = 'Malvika'
	else:
		last_mover = 'Akshat'
print(last_mover)


(n, m) = input().split()
n1 = int(n)
m1 = int(m)
c = 0
while n1 != 0 and m1 != 0:
	m1 -= 1
	n1 -= 1
	c += 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().split())
M = A = 0
while m > 0 and n > 0:
	if A == M:
		A += 1
		m = m - 1
		n = n - 1
	elif A == M + 1:
		M += 1
		m = m - 1
		n = n - 1
if A == M:
	stdout.write('Malvika\n')
else:
	stdout.write('Akshat\n')


(v_lines_count, h_lines_count) = map(int, input().split())
if min(v_lines_count, h_lines_count) % 2:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(k) for k in input().split()]
tempt = min(n, m)
if tempt % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def main():
	x = min(map(int, input().split()))
	if x % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


(n, m) = [int(i) for i in input().split()]
win = 0
while n * m != 0:
	n -= 1
	m -= 1
	win = abs(win - 1)
if win == 0:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
c = a[1]
b = a[0]
count1 = 1
count2 = 0
i = 2
while True:
	if (b - 1) * (c - 1) > 0:
		if i % 2 != 0:
			count1 += 1
		else:
			count2 += 1
		b = b - 1
		c = c - 1
	else:
		break
	i += 1
if count1 > count2:
	print('Akshat')
else:
	print('Malvika')


import sys
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().split())
inl = lambda : list(map(int, input().split()))
(n, m) = inm()
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def winner():
	test = input().split()
	n = int(test[0])
	m = int(test[1])
	mult = n * m
	turn = 1
	while mult > 0:
		mult = mult - (n + m - 1)
		n -= 1
		m -= 1
		turn *= -1
	if turn == -1:
		return 'Akshat'
	else:
		return 'Malvika'
print(winner())


def stick_games(n, m):
	i = 1
	dot = n * m
	stick = n + m
	delt_dot = stick - 1
	rem_dot = dot - delt_dot
	rem_stick = stick - 2
	n -= 1
	m -= 1
	while rem_dot > 0:
		dot = n * m
		stick = n + m
		delt_dot = stick - 1
		rem_dot = dot - delt_dot
		rem_stick = stick - 2
		n -= 1
		m -= 1
		i += 1
	if i % 2 != 0:
		print('Akshat')
	else:
		print('Malvika')
(n, m) = input().split()
stick_games(int(n), int(m))


x = input()
(n, m) = (int(x.split()[0]), int(x.split()[1]))
count = 1
remaining = n * m
while remaining > 0:
	x = n + m - 1
	remaining -= x
	n -= 1
	m -= 1
	count *= -1
if count > 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
x = min(n, m)
if x & 1:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split())
print(['Malvika', 'Akshat'][min(a, b) & 1])


from sys import stdin
input = stdin.readline

def sticks(n, m):
	cache = [[False] * (m + 1) for _ in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(1, m + 1):
			if n == 1 or m == 1:
				cache[i][j] = True
			else:
				cache[i][j] = not cache[i - 1][j - 1]
	return cache[n][m]
print(['Malvika', 'Akshat'][sticks(*map(int, input().split()))])


print(['Malvika', 'Akshat'][min((int(x) for x in input().split())) % 2])


(n, m) = input().split()
n = int(n)
m = int(m)
matrix = [[1 for x in range(m)] for x in range(n)]
akshat = 0

def cleanup(i, j):
	for x in range(m):
		matrix[i][x] = 0
	for x in range(n):
		matrix[x][j] = 0
for i in range(n):
	for j in range(m):
		if matrix[i][j] == 1:
			cleanup(i, j)
			akshat = 1 - akshat
if akshat == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = [int(x) for x in input().split()]
first = True
cpoint = n * m
while cpoint > 0:
	cpoint -= n + m - 1
	n -= 1
	m -= 1
	if first:
		first = False
	else:
		first = True
if first:
	print('Malvika')
else:
	print('Akshat')


s = input()
s = s.split()
s = [int(x) for x in s]
if s[0] >= s[1]:
	if s[1] % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif s[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
c = max(a, b)
if a * b / c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve(m, n):
	s = m * n
	winner = None
	i = 0
	while s:
		if i & 1 == 0:
			winner = 'Akshat'
		else:
			winner = 'Malvika'
		s -= m + n - 1
		m -= 1
		n -= 1
		i += 1
	return winner
(m, n) = list(map(int, input().strip().split()))
result = solve(m, n)
print(result)


aa = input().split(' ')
tot = min(int(aa[0]), int(aa[1]))
print('Malvika') if tot % 2 == 0 else print('Akshat')


s = input()
n = [int(i) for i in s.split()]
min1 = min(n)
if min1 % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


ordo = list(map(int, input().split()))
i = min(ordo)
a = 'Akshat'
if i % 2 == 0:
	a = 'Malvika'
print(a)


n = input()
l = []
l = n.split(' ')
for i in range(len(l)):
	l[i] = int(l[i])
if min(l) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n1, n2) = map(int, input().split())
if min(n1, n2) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = str(input()).split(' ')
a = int(a)
b = int(b)
if min(a, b) % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
points = n * m
counter = 0
while points > 0:
	points -= n + m - 1
	n -= 1
	m -= 1
	counter += 1
if counter % 2 > 0:
	print('Akshat')
else:
	print('Malvika')


a = list(map(int, input().split()))
if a[0] <= a[1]:
	point = a[0]
else:
	point = a[1]
if point % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import pprint
(m, n) = map(int, input().split())
ls = [[1 for x in range(n)] for y in range(m)]
count = 0
try:
	for i in range(n):
		ls[i][i] = 0
except IndexError:
	pass
for i in range(m):
	for j in range(n):
		if ls[i][j] == 0:
			count += 1
			break
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


p = input().split()
x = int(p[0])
y = int(p[1])
m = min(x, y)
if m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


try:
	(a, b) = map(int, input().split())
	ans = 'Malvika' if min(a, b) % 2 == 0 else 'Akshat'
	print(ans)
except EOFError as e:
	pass


(n, m) = [int(x) for x in input().split()]
num = 0
while n * m > 0:
	num += 1
	n -= 1
	m -= 1
print(['Malvika', 'Akshat'][num % 2])


def main():
	(n, m) = tuple(map(int, input().rstrip().split()))
	print('Akshat' if min(n, m) % 2 == 1 else 'Malvika')
main()


def myMethod(a, b):
	intersection = a * b
	stickes = a + b
	count = 0
	while intersection > 0:
		intersection = intersection - (stickes - 1)
		stickes = stickes - 2
		count += 1
	if count % 2 == 0:
		return 'Malvika'
	return 'Akshat'
(a, b) = [int(x) for x in input().split()]
print(myMethod(a, b))


(a, b) = map(int, input().split())
turn = 0
intersection = a * b
while intersection > 0:
	turn += 1
	a += -1
	b += -1
	intersection = a * b
if turn % 2 == 0 and turn != 1:
	print('Malvika')
else:
	print('Akshat')


li = input()
w = li.split(' ')
n = int(w[0])
m = int(w[1])
c = 0
p = n * m
while p:
	p = p - (n + m - 1)
	n = n - 1
	m = m - 1
	c = c + 1
if c % 2:
	print('Akshat')
else:
	print('Malvika')


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True
(n, m) = [int(x) for x in input().split()]
least = min(n, m)
if least % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, k) = list(map(int, input().split()))
y = min(n, k)
if y % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(x, y) = [int(i) for i in input().split()]
k = [x % 2, y % 2][y <= x]
print(['Akshat', 'Malvika'][k == 0])


(n, m) = list(map(int, input().split()))
cn = 0
j = n
k = m
for i in range(n + m + 1):
	if j >= 1 and k >= 1:
		cn += 1
		j -= 1
		k -= 1
if cn % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


stick = list(map(int, input().split()))
game = []
for i in range(1, stick[0] * stick[1] + 1, stick[1]):
	game.append(list(range(i, i + stick[1])))
count = 0
point = stick[0] * stick[1]
a = stick[0]
b = stick[1]
while True:
	point -= a + b - 1
	count += 1
	if point <= 0:
		break
	a -= 1
	b -= 1
if count % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


numbers_of_sticks = list(map(int, input().split()))
if numbers_of_sticks[0] % 2 == 0 and numbers_of_sticks[1] >= numbers_of_sticks[0] and (numbers_of_sticks[1] > 1) and (numbers_of_sticks[0] > 1):
	print('Malvika')
elif numbers_of_sticks[1] % 2 == 0 and numbers_of_sticks[1] <= numbers_of_sticks[0] and (numbers_of_sticks[1] > 1) and (numbers_of_sticks[0] > 1):
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(k) for k in input().split()]
mo = 0
while m * n != 0:
	n -= 1
	m -= 1
	mo += 1
if mo % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import sys
(n, m) = map(int, sys.stdin.readline().split())
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


from math import ceil
(n, m) = map(int, input().split())
if min(m, n) % 2:
	print('Akshat')
else:
	print('Malvika')


s = input()
arr = s.split(' ')
a_list = list(map(lambda x: int(x), arr))
(row, col) = (a_list[0], a_list[1])
akshat_win = False
while row != 0 and col != 0:
	akshat_win = not akshat_win
	row -= 1
	col -= 1
print('Akshat' if akshat_win else 'Malvika')


(grx, gry) = [int(x) for x in input().split(' ')]
m = min(grx, gry)
print(['Malvika', 'Akshat'][m % 2])


s = input()
k = s.split(' ')
a = int(k[0])
b = int(k[1])
c = min(a, b)
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


line = input().split()
n = int(line[0])
m = int(line[1])
k = min(n, m)
names = ['Akshat', 'Malvika']
l = k % 2
print(names[1 - l])


(n, m) = map(int, input().split())
names = ['Malvika', 'Akshat']
print(names[min(n, m) % 2])


import sys

def main():
	(m, n) = map(int, sys.stdin.readline().strip().split())
	if min(m, n) % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')
main()


(n, m) = input().split()
n = int(n)
m = int(m)
winner = False
while n > 0 and m > 0:
	n -= 1
	m -= 1
	winner = not winner
if winner:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
isections = m * n
while 2 == 2:
	m -= 1
	n -= 1
	isections = m * n
	if m == 0 or n == 0:
		print('Akshat')
		break
	m -= 1
	n -= 1
	if m == 0 or n == 0:
		print('Malvika')
		break


__author__ = 'JohnHook'
(n, m) = list(map(int, input().split()))
if min(n, m) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


sticks = list(map(int, input().split()))
player = 1
while sticks[0] != 0 and sticks[1] != 0:
	sticks[0] = sticks[0] - 1
	sticks[1] = sticks[1] - 1
	player = player * -1
if player == 1:
	print('Malvika')
else:
	print('Akshat')


def inputMatrix(rows):
	return [list(map(int, input().split())) for _ in range(rows)]
(N, M) = map(int, input().split())
print('Malvika' if min(N, M) % 2 == 0 else 'Akshat')


(n, m) = list(map(int, input().split()))
k = 0
dots = n * m
while dots != 0:
	dots = n * m
	dots -= m + n - 1
	n -= 1
	m -= 1
	k += 1
if k % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(a, b) = map(int, input().split())
print('MAaklsvhiakta'[min(a, b) % 2 != 0::2])


def main():
	(n, m) = map(int, input().split())
	k = min(n, m)
	if k % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


def gameSticks(n1, n2):
	minimum = min(n1, n2)
	if minimum % 2 == 0:
		return 'Malvika'
	else:
		return 'Akshat'
(num1, num2) = map(int, input().split(' '))
print(gameSticks(num1, num2))


(n, m) = map(int, input().split())
a = [[0 for i in range(101)] for j in range(101)]
for i in range(1, 101):
	a[i][1] = 1
	a[1][i] = 1
for i in range(2, 101):
	for j in range(2, 101):
		a[i][j] = a[i - 1][j - 1] + 1
if a[n][m] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import sys
import math
import bisect

def main():
	(n, m) = map(int, input().split())
	if min(n, m) % 2 == 1:
		print('Akshat')
	else:
		print('Malvika')
main()


list = []
(x, y) = input().split()
list.append(int(x))
list.append(int(y))
list.sort()
a = list[0]
if a % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
flag = 0
while True:
	n -= 1
	m -= 1
	if n * m != 0:
		flag = 1 if not flag else 0
	else:
		if not flag:
			print('Akshat')
		else:
			print('Malvika')
		break


(n, m) = [int(i) for i in input().split()]
k = min(n, m)
if k == 1 or k % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = input().split()
n = int(n)
m = int(m)
answer = 0
while n != 0 and m != 0:
	answer += 1
	m -= 1
	n -= 1
if answer % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


nums = input()
nums = nums.split()
for i in range(2):
	nums[i] = int(nums[i])
cont = 0
while nums[0] != 0 and nums[1] != 0:
	nums[0] -= 1
	nums[1] -= 1
	cont += 1
if cont % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split(' '))
inter = n * m
winner = 0
while inter != 0:
	winner += 1
	inter = inter - (n - 1 + (m - 1) + 1)
	n -= 1
	m -= 1
if winner % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


s = str(input()).split()
l = [int(s[0]), int(s[1])]
if min(l) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
N = n * m
x = 1
for i in range(N):
	if n * m - (n + m - 1) > 0:
		x += 1
		n = n - 1
		m = m - 1
	else:
		break
if x % 2 == 0 and x > 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
a = True
M = False
s = ''
while n != 0 and m != 0:
	if a == True and M == False:
		s = 'Akshat'
		n -= 1
		m -= 1
		a = False
		M = True
	else:
		s = 'Malvika'
		n -= 1
		m -= 1
		a = True
		M = False
print(s)


(t, k) = map(int, input().split())
if min(t, k) % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = [int(n) for n in input().split(' ')]
s = 0
while True:
	a[0] = a[0] - 1
	a[1] = a[1] - 1
	s += 1
	if a[0] == 0 or a[1] == 0:
		break
if s % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
if n <= m and n % 2 != 0 or (m <= n and m % 2 != 0):
	print('Akshat')
else:
	print('Malvika')


(n, m) = map(int, input().split())
sticks = n * m
winner = False
while sticks > 0:
	sticks -= n + m - 1
	n -= 1
	m -= 1
	winner = not winner
if winner:
	print('Akshat')
else:
	print('Malvika')


(a, b) = input().split()
a = int(a)
b = int(b)
result = []
result.append(a)
result.append(b)
x = min(result)
if x % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(A, B) = input().split()
(a, b) = (int(A), int(B))
i = 1
f = True

def check(i):
	ak = False
	ma = False
	if i % 2 != 0:
		ak = True
		ma = False
	else:
		ak = False
		ma = True
	return ak
while a > 0 and b > 0:
	f = check(i)
	a = a - 1
	b = b - 1
	i = i + 1
if f == True:
	print('Akshat')
else:
	print('Malvika')


(A, M) = map(int, input().split(' '))
sum = A + M
value = sum % 2
if value == 0 and A % 2 == 0:
	print('Malvika')
elif value == 0 and A % 2 != 0:
	print('Akshat')
elif value != 0:
	v = sum // 2
	if v % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')


s = input().split()
a = int(s[0])
b = int(s[1])
if a >= b:
	ma = b
else:
	ma = a
if ma % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


num = input().split()
n = int(num[0])
m = int(num[1])
cnt_point = n * m
winner = 0
while cnt_point > 0:
	n -= 1
	m -= 1
	cnt_point = n * m
	winner = 1 - winner
if winner == 0:
	print('Malvika')
else:
	print('Akshat')


n_m = list(map(int, input().split()))
n = n_m[0]
m = n_m[1]
count = 0
while n > 0 and m > 0:
	count = count + 1
	n = n - 1
	m = m - 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = input().strip().split()
(n, m) = (int(n), int(m))
if n % 2 == 0 and m % 2 == 0:
	print('Malvika')
elif n % 2 != 0 and m % 2 != 0:
	print('Akshat')
else:
	sum = m + n
	if (sum - 3) % 4 == 0:
		print('Akshat')
	else:
		print('Malvika')


def solve(n, m):
	moves = min(n, m)
	return 'Malvika' if moves % 2 == 0 else 'Akshat'

def parse(line):
	return [int(x) for x in line.split()]

def test():
	assert solve(*parse('2 2')) == 'Malvika'
	assert solve(*parse('2 3')) == 'Malvika'
	assert solve(*parse('3 3')) == 'Akshat'
print(solve(*parse(input())))


def winner(n, m):
	flag = True
	while True:
		if flag == True:
			flag = False
			if n == 0 or m == 0:
				return 'Malvika'
			n -= 1
			m -= 1
		elif flag == False:
			flag = True
			if n == 0 or m == 0:
				return 'Akshat'
			n -= 1
			m -= 1
x = list(map(int, input().rstrip().split()))
print(winner(x[0], x[1]))


n = list(map(int, input().split()))
flag = True
while n[0] != 0 and n[1] != 0:
	flag = not flag
	n[0] -= 1
	n[1] -= 1
if flag:
	print('Malvika')
else:
	print('Akshat')


(a, b) = [int(x) for x in input().split()]
n = 0
while a * b != 0:
	a -= 1
	b -= 1
	n += 1
if n % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list((int(x) for x in input().split()))
c = 0
p = n * m
while p > 0:
	c += 1
	p = p - (n + m - 1)
	n = n - 1
	m = m - 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = tuple(map(int, input().split()))
s = n * m
now = 'Akshat'
while n != 0 and m != 0:
	n -= 1
	m -= 1
	if now == 'Akshat':
		now = 'Malvika'
	else:
		now = 'Akshat'
if now == 'Akshat':
	print('Malvika')
else:
	print('Akshat')


inp = input().split()
n = int(inp[0])
m = int(inp[1])
all = m + n
counter = 1
while all > 1 and m > 0 and (n > 0):
	all -= 2
	m -= 1
	n -= 1
	counter += 1
if counter % 2 == 1:
	print('Malvika')
else:
	print('Akshat')


(n, m) = input().split()
r = int(n)
c = int(m)
count = 0
matrix = []
for i in range(r):
	a = []
	for j in range(c):
		a.append(1)
	matrix.append(a)
for i in range(r):
	for j in range(c):
		if matrix[i][j] != 0:
			matrix[i][j] = 0
			for l in range(c):
				matrix[i][l] = 0
			for l in range(r):
				matrix[l][j] = 0
			count = count + 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
x = sorted([n, m])
if x[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import sys

def chet(val):
	if val % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
in_str = sys.stdin.readline().split()
a = int(in_str[0])
b = int(in_str[1])
if a <= b:
	chet(a)
else:
	chet(b)


line = input().split()
n = int(line[0])
m = int(line[1])
ans = min(n, m)
if ans % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 10 ** 9 + 7
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
(n, m) = value()
tot = min(n, m)
if tot % 2:
	print('Akshat')
else:
	print('Malvika')


(a, b) = map(int, input().split())
to = a * b
k = 0
if a == 1 or b == 1:
	print('Akshat')
else:
	while to != 0:
		to = to - b - a + 1
		a = a - 1
		b = b - 1
		k = k + 1
		if to <= a + b - 1 and k % 2 != 0:
			print('Malvika')
			break
		elif to <= a + b - 1 and k % 2 == 0:
			print('Akshat')
			break


__author__ = 'myduomilia'
(n, m) = list(map(int, input().split()))
ans = -1
while n * m > 0:
	n -= 1
	m -= 1
	ans += 1
	if ans == 2:
		ans = 0
if ans == 0:
	print('Akshat')
else:
	print('Malvika')


def FindMin(n, m):
	if n > m:
		return m
	return n
(n, m) = input().split()
if FindMin(int(n), int(m)) % 2:
	print('Akshat')
else:
	print('Malvika')


import sys
import math
a = [int(x) for x in input().split()]
i = 1
while True:
	a = [x - 1 for x in a]
	if 0 in a:
		if i % 2 == 1:
			print('Akshat')
			sys.exit()
		else:
			print('Malvika')
			sys.exit()
	i += 1


values = list(map(int, input().split(' ')))
sorted_values = sorted(values)
if sorted_values[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def ii():
	return int(input())

def mi():
	return map(int, input().split())

def si():
	return [int(x) for x in input().split()]

def ss():
	return [x for x in input()]
(a, b) = mi()
print('Malvika' * (min(a, b) % 2 == 0) + 'Akshat' * (min(a, b) % 2 == 1))


(m, n) = map(int, input().split())
possibleMoves = m * n
currentPlayer = True
while possibleMoves != 0:
	m = m - 1
	n = n - 1
	possibleMoves = m * n
	currentPlayer = not currentPlayer
if not currentPlayer:
	print('Akshat')
else:
	print('Malvika')


s = input().split(' ')
s = [int(i) for i in s]
n = s[0]
m = s[1]
ti = m * n
g = m + n - 1
c = 0
while ti > 0:
	m = m - 1
	n = n - 1
	ti = m * n
	c += 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


lst = [int(_) for _ in input().split()]
n = lst[0]
m = lst[1]
k = n
if m < n:
	k = m
if k % 2:
	print('Akshat')
else:
	print('Malvika')


(h, v) = [int(i) for i in input().split()]
moves = min(v, h)
print('Malvika' if moves % 2 == 0 else 'Akshat')


(n, m) = list((int(a) for a in input().split()))
print('Akshat') if min(n, m) & 1 else print('Malvika')


(n, m) = list(map(int, input().split()))
cnt = min(n, m)
if not cnt % 2:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
k = min(n, m)
while k > 0:
	if k - 1 == 0:
		print('Akshat')
		break
	else:
		k -= 1
		if k - 1 == 0:
			print('Malvika')
			break
		else:
			k -= 1


from sys import stdin, stdout
nm = list(map(int, stdin.readline().split()))
name_list = ['Akshat', 'Malvika']
name_index = 0
while min(nm) >= 1:
	nm[0] = nm[0] - 1
	nm[1] = nm[1] - 1
	name_index = (name_index + 1) % 2
if min(nm) == 0:
	winner = name_list[(name_index + 1) % 2]
	stdout.write(winner)


(n, m) = map(int, input().split())
b = [n, m]
b.sort()
if b[0] % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


a = list(map(int, input().split()))
a = min(a)
if a % 2:
	print('Akshat', end='')
else:
	print('Malvika', end='')


(a, b) = map(int, input().split())
while a >= b:
	if b % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
	break
while b > a:
	if a % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
	break


i = input()
l = i.split(' ')
j = min(int(l[0]), int(l[1]))
if j % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = map(int, input().split())
if n == 1 or m == 1:
	rez = 1
else:
	if n > m:
		diff = m
	else:
		diff = n
	if diff % 2 == 0:
		rez = 0
	else:
		rez = 1
if rez == 0:
	print('Malvika')
else:
	print('Akshat')


lis = input().split(' ')
n = int(lis[0])
m = int(lis[1])
mult = n * m
i = 0
d = m + n - 1
while mult != 0:
	mult -= d
	d -= 2
	i += 1
if i % 2 == 1:
	print('Akshat')
else:
	print('Malvika')


(n, k) = map(int, input().split())
print(['Malvika', 'Akshat'][min(n, k) % 2])


def main():
	d = input().split()
	n = int(d[0])
	m = int(d[1])
	points = n * m
	win = 0
	while points > 0:
		n = n - 1
		m = m - 1
		win += 1
		points = n * m
	if win % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
main()


def solve():
	(a, b) = map(int, input().split())
	a = min(a, b)
	if a & 1:
		print('Akshat')
	else:
		print('Malvika')
solve()


nm = [int(s) for s in input().split()]
n = int(nm[0])
m = int(nm[1])
times = min(n, m)
if times & 1:
	print('Akshat')
else:
	print('Malvika')


dim = [int(i) for i in input().split()]
step = min(dim)
if step % 2 != 0:
	print('Akshat')
else:
	print('Malvika')


s = str(input()).split()
n = int(s[0])
m = int(s[1])
if n < m:
	if n % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
elif m % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(p1, p2) = ['Akshat', 'Malvika']
(x, y) = [int(i) for i in input().split()]
counter = 0
while x > 0 and y > 0:
	x -= 1
	y -= 1
	counter += 1
print(p2 if counter % 2 == 0 else p1)


(n, m) = input().split()
n = int(n)
m = int(m)
count = 0
c = 0
while c == 0:
	n -= 1
	m -= 1
	count += 1
	if n <= 0 or m <= 0:
		c = 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(m, n) = map(int, input().split())
y = min(m, n)
x = int(n) * int(m)
t = int(y) - 1
if x % 2 == 0:
	if t % 2 == 0:
		print('Akshat')
	else:
		print('Malvika')
else:
	print('Akshat')


lst = input().split()
for i in range(2):
	lst[i] = int(lst[i])
mn = min(lst)
if mn % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def solve():
	n = input().split(' ')
	a = min(int(n[0]), int(n[1]))
	if a % 2 == 0:
		print('Malvika')
	else:
		print('Akshat')
solve()


(n, m) = list(map(int, input().split()))
x = n + m - 1
y = n * m
ans = 0
while y > 0:
	y -= x
	x -= 2
	ans += 1
print('Malvika' if ans % 2 == 0 else 'Akshat')


x = input().split(' ')
num = min(int(x[0]), int(x[1]))
names = ['Malvika', 'Akshat']
print(names[num % 2])


s = input().split()
n = int(s[0])
m = int(s[1])
step = 1
while n * m > 0:
	n -= 1
	m -= 1
	step += 1
print('Malvika' if step % 2 == 1 else 'Akshat')


def main():
	(N, M) = map(int, input().split())
	cnt = min(N, M)
	if cnt % 2 != 0:
		print('Akshat')
	else:
		print('Malvika')
main()


n = list(map(int, input().split()))
if min(n) % 2 == 0:
	print('Malvika')
	exit()
print('Akshat')


(a, b) = map(int, input().split())
for i in range(100000000):
	c = a * b
	if c == 0:
		t = i
		break
	else:
		a -= 1
		b -= 1
if t % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split(' ')]
min_num = n if n < m else m
if min_num % 2:
	print('Akshat')
else:
	print('Malvika')


s = input()
a = s.split()
n = int(a[0])
m = int(a[1])
x = n + m
i = n * m
c = 0
while i != 0:
	i = i - x + 1
	x = x - 2
	c = c + 1
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = list(map(int, input().split()))
kol = n * m
pl = ['Akshat', 'Malvika']
xod = 1
while kol > 0:
	kol = kol - m - (n - 1)
	m -= 1
	n -= 1
	xod += 1
print(pl[xod % 2])


(M, N) = map(int, input().split())
s = 0
if M >= N:
	S = N
else:
	S = M
for i in range(S):
	s += 1
if s % 2 != 0:
	print('Akshat')
elif s % 2 == 0:
	print('Malvika')


(n, m) = input().split()
n = int(n)
m = int(m)
y = 0
a = max(n, m)
for i in range(0, a):
	if n * m != 0:
		y = y + 1
		m = m - 1
		n = n - 1
	else:
		break
if y % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def find_(m):
	for (xk, xv) in enumerate(m):
		for (yk, yv) in enumerate(xv):
			if yv == '*':
				return [xk, yk]
	return None

def remove_(m, idx):
	for (xk, xv) in enumerate(m):
		for (yk, yv) in enumerate(xv):
			if xk == idx[0] or yk == idx[1]:
				m[xk][yk] = '-'
(a, b) = [int(x) for x in input().split()]
m = [['*' for y in range(b)] for x in range(a)]
c = 0
while True:
	c += 1
	idx = find_(m)
	if idx is not None:
		remove_(m, idx)
	else:
		break
print(['Akshat', 'Malvika'][c % 2])


(x, y) = map(int, input().split(' '))
count = 1
while x != 0 and y != 0:
	count += 1
	x -= 1
	y -= 1
if count % 2 == 0:
	print('Akshat')
else:
	print('Malvika')


sticks = input()
sticks = sticks.split()
vert = int(sticks[0])
hor = int(sticks[1])
if vert < hor:
	minim = vert
else:
	minim = hor
if minim % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = input().split(' ')
n = int(n)
m = int(m)
if m < n:
	n = m
if n % 2 == 1:
	winner = 'A'
elif n % 2 == 0:
	winner = 'M'
if winner == 'A':
	print('Akshat')
else:
	print('Malvika')


a = list(map(int, input().split()))
(n, m) = a
point = n * m
stp = 0
while n != 0 and m != 0:
	n -= 1
	m -= 1
	stp += 1
if stp % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


s = input().split(' ')
ls = min(int(s[0]), int(s[1]))
if ls % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


def sticks(n, m):
	total = n + m
	i_pt = n * m
	if n != 0 and m != 0:
		n -= 1
		m -= 1
		return (n, m)
(n, m) = input().split()
n = int(n)
m = int(m)
try:
	while n != 0 and m != 0:
		for player in ['Akshat', 'Malvika']:
			(n, m) = sticks(n, m)
except TypeError:
	player = 'Akshat'
print(player)


(n, m) = map(int, input().split())
cnt = n * m
Ak = True
Ma = False
while m > 0 and n > 0:
	m -= 1
	n -= 1
	cnt = m * n
	if Ak:
		Ak = False
		Ma = True
	elif Ma:
		Ma = False
		Ak = True
if Ak:
	print('Malvika')
else:
	print('Akshat')


def end(n, m):
	count = 1
	while n > 0 and m > 0:
		if n == 1 or m == 1:
			return count
		m = m - 1
		n = n - 1
		count += 1
	return count
(n, m) = map(int, input().split())
c = end(n, m)
if c % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


T = input().split()
n = int(T[0])
m = int(T[1])
count = 0
while n != 0 and m != 0:
	count = count + 1
	n = n - 1
	m = m - 1
if count % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


TN = 1

def solution():
	(n, m) = map(int, input().split())
	ans = 0
	while n != 0 and m != 0:
		n -= 1
		m -= 1
		ans = abs(1 - ans)
	if not ans:
		print('Malvika')
	else:
		print('Akshat')
while TN != 0:
	solution()
	TN -= 1


(n, m) = map(int, input().split())
total = n * m
cnt = 0
while total > 0:
	cnt += 1
	total -= 1
	if total > 0:
		total = total - (n - 1) - (m - 1)
		n = n - 1
		m = m - 1
if cnt % 2 == 0:
	print('Malvika')
else:
	print('Akshat')


(n, m) = [int(x) for x in input().split()]
ip = n * m
turn = 'Malvika'
while ip:
	turn = 'Akshat' if turn == 'Malvika' else 'Malvika'
	n -= 1
	m -= 1
	ip = n * m
print(turn)