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, sys
from io import BytesIO, IOBase
from collections import Counter
# Fast IO Region
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 sieve(n):
    p = [1 for i in range (n + 1)]
    z = 2
    while z * z <= n:
        if p[z] == 1:
            for i in range (z * z, n + 1, z):
                p[i] = 0
        z += 1
    primes = [2]
    for i in range (3, n + 1, 2):
        if p[i]:
            primes.append (i)
    return set (primes)
def ordinarynunm(x):
    ans = 0
    k = 0
    for i in range (9):
        k = k + 10 ** i
        for t in range (1, 10):
            if t * k <= x:
                ans += 1
    return ans
def findodddivisor(x):
    while x>=2:
        x=x/2
    if x==1:
        return "NO"
    else:
        return "YES"


def bins(arr, n, k):
    l = 0
    r = n - 1

    # Stores the index of the left most element
    # from the array which is greater than k
    leftGreater = n

    # Finds number of elements greater than k
    while (l <= r):
        m = int (l + (r - l) / 2)

        # If mid element is greater than
        # k update leftGreater and r
        if (arr[m] > k):
            leftGreater = m
            r = m - 1

        # If mid element is less than
        # or equal to k update l
        else:
            l = m + 1

    # Return the count of elements
    # greater than k
    return leftGreater
for _ in range(1):
    x=int(input())
    if x%2==0:
        print("Mahmoud")
    else:
        print("Ehab")



