Mahmoud and Ehab play a game called the even-odd game. Ehab chooses his favorite integer *n* and then they take turns, starting from Mahmoud. In each player's turn, he has to choose an integer *a* and subtract it from *n* such that:
 -  1 ≤ *a* ≤ *n*. -  If it's Mahmoud's turn, *a* has to be even, but if it's Ehab's turn, *a* has to be odd. 
If the current player can't choose any number satisfying the conditions, he loses. Can you determine the winner if they both play optimally?
The only line contains an integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">9</sup>), the number at the beginning of the game.
In the first sample, Mahmoud can't choose any integer *a* initially because there is no positive even integer less than or equal to 1 so Ehab wins.

In the second sample, Mahmoud has to choose *a* = 2 and subtract it from *n*. It's Ehab's turn and *n* = 0. There is no positive odd integer less than or equal to 0 so Mahmoud wins.
1
Ehab
2
Mahmoud
10000
Mahmoud
33333
Ehab
5
Ehab
1000000000
Mahmoud
999999999
Ehab
123123123
Ehab
22222221
Ehab
22222220
Mahmoud
3
Ehab
4
Mahmoud
6
Mahmoud
7
Ehab
8
Mahmoud
9
Ehab
10
Mahmoud
536870912
Mahmoud
536870913
Ehab
536870911
Ehab
import os
import sys
import math
import numpy
import collections
import itertools
from io import BytesIO, IOBase

#---<Fast I/O>---#
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 & Print>---#

def scanf(datatype = str):
    if datatype is not None:
        return datatype(sys.stdin.readline())
    else:
        return sys.stdin.readline()

def printf(answer):
    return sys.stdin.write(str(answer) + "\n")

def map_input(datatype):
    return map(datatype, sys.stdin.readline().split())

def list_input(datatype):
    return list(map(datatype, sys.stdin.readline().split()))

def testcase(number: int, solve_function):
    while (number != 0):
        solve_function()
        number -= 1

#---<Mathematical Operations>---#

def gcd(num1: int, num2: int): #greatest common divisor
    if num1 == 0:
        return num2
    if num2 == 0:
        return num1
    if num1 > num2:
        return gcd(num1 % num2, num2)
    else:
        return gcd(num1, num2 % num1)

def lcm(num1: int, num2: int): #lowest common multiple
    return (num1 * num2) // gcd(num1, num2)

def big_power(num1: int, num2: int):
    result = 1
    while (num2 > 0):
        if num2 & 1:
            result = result * num1
        num1 = num1 ** 2
        num2 >>= 1
    return result

#---<Algorithms>---#

def sieve_of_eratosthenes(number: int):
    num1 = (number - 1) // 2
    arr = [True] * num1
    num2, num3, primes = 0, 3, [2]
    while (num3 * num3 < number):
        if arr[num2]:
            primes.append(num3)
            num4 = 2 * num2 * num2 + 6 * num2 + 3
            while (num4 < num1):
                arr[num4] = False
                num4 = num4 + 2 * num2 + 3
        num2 += 1
        num3 += 1
    while (num2 < num1):
        if arr[num2]:
            primes.append(num3)
        num2 += 1
        num3 += 2
    return primes

def dfs(graph, start, visited = None): #depth first search
    '''
    Here 'graph' represents the adjacency list
    of the graph, and 'start' represents the
    node from which to start
    '''
    if visited is None:
        visited = set()
    visited.add(start)
    for next in (graph[start] - visited):
        dfs(graph, next, visited)
    return visited

def dfs_paths(graph, start, goal):
    '''
    Returns all possible paths between a
    start vertex and a goal vertex
    '''
    stack = [(start, [start])]
    while (stack):
        (vertex, path) = stack.pop()
        for next in (graph[vertex] - set(path)):
            if next == goal:
                yield path + [next]
            else:
                stack.append((next, path + [next]))
    return stack

def bfs(graph, start): #breadth first search
    visited, queue = set(), [start]
    while (queue):
        vertex = queue.pop(0)
        if (vertex not in visited):
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)
    return visited

def bfs_paths(graph, start, goal):
    '''
    Returns all possible paths between a
    start vertex and a goal vertex, where
    the first path is the shortest path
    '''
    queue = [(start, [start])]
    while (queue):
        (vertex, path) = queue.pop(0)
        for next in (graph[vertex] - set(path)):
            if (next == goal):
                yield path + [next]
            else:
                queue.append((next, path + [next]))
    return queue

def main():
    n = scanf(int)
    
    # Mahmoud plays first 
    # chooses integer (a) and subtracts it from n
    # n - a
    # a should be even in Mahmoud's turn 
    # a should be odd in Ehbab's turn 
    # if current player fails to choose, he loses 
    if n % 2 == 0:
        print("Mahmoud")
    else:
        print("Ehab")

if __name__ == "__main__":
    main()