#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

struct Point
{
    int x;
    int y;
};

bool isValid(int x, int y, int rows, int cols)
{
    return x >= 0 && x < rows && y >= 0 && y < cols;
}

int bfs(const std::vector<std::vector<char>>& grid, Point start, Point finish)
{
    int rows = grid.size();
    int cols = grid[0].size();
    std::vector<std::vector<int>> dist(rows, std::vector<int>(cols, -1));
    std::queue<Point> q;
    q.push(start);
    dist[start.x][start.y] = 0;

    int dx[] = { -1, 1, 0, 0 };
    int dy[] = { 0, 0, -1, 1 };

    while (!q.empty())
    {
        Point p = q.front();
        q.pop();

        if (p.x == finish.x && p.y == finish.y)
        {
            return dist[p.x][p.y];
        }

        for (int i = 0; i < 4; ++i)
        {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];

            if (isValid(nx, ny, rows, cols) && dist[nx][ny] == -1 && grid[nx][ny] != 'W')
            {
                dist[nx][ny] = dist[p.x][p.y] + 1;
                q.push({ nx, ny });
            }
        }
    }
    return -1; // Путь не найден
}

int bfsMouse(const std::vector<std::vector<char>>& grid, Point start, Point finish, int humanSteps)
{
    int rows = grid.size();
    int cols = grid[0].size();
    std::vector<std::vector<std::vector<int>>> dist(rows, std::vector<std::vector<int>>(cols, std::vector<int>(2, -1)));
    std::queue<std::pair<Point, int>> q;
    q.push({ start, 0 });
    dist[start.x][start.y][0] = 0;

    int dx[] = { -1, 1, 0, 0 };
    int dy[] = { 0, 0, -1, 1 };

    while (!q.empty())
    {
        Point p = q.front().first;
        int wallsBroken = q.front().second;
        q.pop();

        if (p.x == finish.x && p.y == finish.y)
        {
            return dist[p.x][p.y][wallsBroken];
        }


        if (dist[p.x][p.y][wallsBroken] >= humanSteps)
            continue;

        for (int i = 0; i < 4; ++i)
        {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];

            if (!isValid(nx, ny, rows, cols))
                continue;

            char cell = grid[nx][ny];

            if (cell != 'W')
            {
                if (dist[nx][ny][wallsBroken] == -1)
                {
                    dist[nx][ny][wallsBroken] = dist[p.x][p.y][wallsBroken] + 1;
                    q.push({ { nx, ny }, wallsBroken });
                }
            }
            else if (wallsBroken == 0)
            {
                if (dist[nx][ny][1] == -1)
                {
                    dist[nx][ny][1] = dist[p.x][p.y][wallsBroken] + 1;
                    q.push({ { nx, ny }, 1 });
                }
            }
        }
    }
    return -1;
}

int main()
{
    int M, N;
    std::cin >> M >> N;

    std::vector<std::vector<char>> field(M, std::vector<char>(N));
    Point humanStart, mouseStart, finish;

    for (int i = 0; i < M; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            std::cin >> field[i][j];
            if (field[i][j] == 'H')
                humanStart = { i, j };
            else if (field[i][j] == 'M')
                mouseStart = { i, j };
            else if (field[i][j] == 'F')
                finish = { i, j };
        }
    }

    int humanSteps = bfs(field, humanStart, finish);

    if (humanSteps == -1)
    {
        std::cout << "MOUSE";
        return 0;
    }

    humanSteps = std::ceil(humanSteps / 2.0);

    int mouseSteps = bfsMouse(field, mouseStart, finish, humanSteps);

    if (mouseSteps == -1 || humanSteps < mouseSteps)
    {
        std::cout << "HUMAN";
    }
    else if (humanSteps > mouseSteps)
    {
        std::cout << "MOUSE";
    }
    else
    {
        std::cout << "DRAW";
    }

    return 0;
}