Two beavers, Timur and Marsel, play the following game.

There are n logs, each of exactly m meters in length. The beavers move in turns. For each move a beaver chooses a log and gnaws it into some number (more than one) of equal parts, the length of each one is expressed by an integer and is no less than k meters. Each resulting part is also a log which can be gnawed in future by any beaver. The beaver that can't make a move loses. Thus, the other beaver wins.

Timur makes the first move. The players play in the optimal way. Determine the winner.

Input

The first line contains three integers n, m, k (1 ≤ n, m, k ≤ 109).

Output

Print "Timur", if Timur wins, or "Marsel", if Marsel wins. You should print everything without the quotes. 

Examples

Input

1 15 4


Output

Timur

Input

4 9 5


Output

Marsel

Note

In the first sample the beavers only have one log, of 15 meters in length. Timur moves first. The only move he can do is to split the log into 3 parts each 5 meters in length. Then Marsel moves but he can't split any of the resulting logs, as k = 4. Thus, the winner is Timur.

In the second example the beavers have 4 logs 9 meters in length. Timur can't split any of them, so that the resulting parts possessed the length of not less than 5 meters, that's why he loses instantly.
import java.util.InputMismatchException;
import java.io.*;
import java.util.HashSet;
import java.util.HashMap;

/**
 * Generated by Contest helper plug-in
 * Actual solution is at the bottom
 */
public class Main {
    public static void main(String[] args) {
        InputReader in = new StreamInputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        run(in, out);
    }

    public static void run(InputReader in, PrintWriter out) {
        Solver solver = new Game();
        solver.solve(1, in, out);
        Exit.exit(in, out);
    }
}

class StreamInputReader extends InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar, numChars;

    public StreamInputReader(InputStream stream) {
        this.stream = stream;
        curChar = 0;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    @Override
    public void close() {
        try {
            stream.close();
        } catch (IOException ignored) {
        }
    }
}

abstract class InputReader {
    private boolean finished = false;

    public abstract int read();

    public int nextInt() {
        return Integer.parseInt(nextToken());
    }
    public String readString() {
        return readLine();
    }


    public String readLine() {
        StringBuffer res = new StringBuffer();
        do {
            int c = read();
            if (isEndOfLineChar(c)) {
                return res.toString();
            }
            res.appendCodePoint(c);
        }  while (true) ;
    }
    public String nextToken() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuffer res = new StringBuffer();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }
    private boolean isEndOfLineChar(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }
    private boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public void setFinished(boolean finished) {
        this.finished = finished;
    }

    public abstract void close();
}

interface Solver {
    public void solve(int testNumber, InputReader in, PrintWriter out);
}

class Exit {
    private Exit() {
    }

    public static void exit(InputReader in, PrintWriter out) {
        in.setFinished(true);
        in.close();
        out.close();
    }
}

class Game implements Solver {

    HashMap<Integer, Integer> cache ;
    int k ;
    int go(int len) {
        if (cache.containsKey(len)) return cache.get(len);

        HashSet<Integer> mex = new HashSet<Integer>();
        for (int i = 1; (long)i * i <= (long)len; ++i){
            if (len % i == 0) {
                int c = len / i;
                if (c > 1 && i >= k){
                    if (!existStep(i)) {
                        mex.add(0);
                    } else if (c % 2 == 1)
                        mex.add(go(i));
                }
                if (i > 1 && c >= k && i != len / i) {
                    if (!existStep(c)) mex.add(0);
                    else if (i % 2 == 1) {
                        mex.add(go(c)) ;
                    }
                }
            }
        }
        for (int i = 0; ; ++i) {
            if (!mex.contains(i)) {
                cache.put(len, i);
                return i;
            }
        }
    }
    boolean existStep(int x) {
        for (int i = 1;(long ) i * i <= (long ) x; ++i) {
            if (x % i == 0) {
                if (x / i > 1 && i >= k) return true;
            }
        }
        return false;
    }

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        k = in.nextInt();
        cache = new HashMap<Integer, Integer> () ;
        int g = go(m);
        if (g == 0 || n % 2 == 0) {
            out.print("Marsel");
            return;
        }
        out.print("Timur");
    }
}

