#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define debug(x) cerr << "[" << #x << ": "<< x << "]" << endl;
#define debug2(x, y) cerr << "[" << #x << ": "<< x << "  " << #y << ": "<< y << "]" << endl;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define ar array
#define se second
#define sz(x) ((int)(x).size())
#define ends "\n"
#define sp ' '

const long long M=1e9+7;
typedef long long ll;
typedef pair<int, int> pii;
long long mul(long long x, long long y){ return ((x%M)*(y%M)%M); }
long long binpow(long long x, long long y){ long long z=1; while(y){ if(y&1LL) z=mul(z, x); x = mul(x, x); y >>= 1LL; } return z; }
long long inv(long long x){ return binpow(x, M - 2); }
long long divide(long long x, long long y){ return mul(x, inv(y)); }

const int INF=1e9+1;
int n, m, k;

void solve(){
	cin >> n >> m >> k;
    int f=INF;
    for(int i=1; i*i<=m; ++i){
        if(m%i==0){
            if(i!=m&&i>=k)
                f=min(f, i);
            else if(i>1&&m/i>=k)
                f=min(f, m/i);
        }
    }

    if(f==INF) cout << "Marsel" << ends;
    else if(n&1) cout << "Timur" << ends;
    else cout << "Marsel" << ends;
}

int main(){
	ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int q, multicase=0;

    if(multicase) cin >> q;
    else q=1;

    for(int i=1; i<=q; ++i){
		solve();
    }

}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{

    ll n,m,k;
    cin>>n>>m>>k;

    if(n%2==0)
    {
        cout<<"Marsel"<<endl;
        return 0;

    }
    else
    {
        if(m==2  && k==1)
        {

        }
        for(ll i=1;i*i<=m;i++)
        {
            if(m%i==0)
            {
                if(k==1 && m/i>=2)
                {
                    cout<<"Timur"<<endl;
                    return 0;
                }
                else if(i!=1 && m/i>=k)
                {
                    cout<<"Timur"<<endl;
                    return 0;
                }
            }
        }

        cout<<"Marsel"<<endl;

    }

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
vector<int> divit;
int k, n, m, max_turn = 0;
int memo[32000][100];

int win(int l, int turn, int p, int num) {
    max_turn = max(max_turn, turn);
//    if (divit[l] < k) {
//        memo[l][turn][(p + 1) % 2] = 1;
//        return memo[l][turn][p] = 0;
//    }
    if (divit[l] <= k) {
//        memo[l][turn][(p + 1) % 2] = 1;
        return memo[l][turn] = (p+1)%2;
    }
    if (memo[l][turn] != -1) return memo[l][turn];
    for (int i = divit.size() - 1; i >= 1; i--) {
        if (divit[l] % divit[i] != 0) continue;
        int t = divit[l] / divit[i];
        int ele = lower_bound(divit.begin(), divit.end(), t) - divit.begin();
        if (t < k) memo[l][turn] = (memo[l][turn]==-1)?win(ele, turn + 1, p, num):min(win(ele, turn + 1, p, num), memo[l][turn]);
        else {
            p += num % 2;
            p %= 2;
            memo[l][turn] = (memo[l][turn]==-1)?win(ele, turn + 1, p, num):min(win(ele, turn + 1, p, num), memo[l][turn]);
        }
    }
    return memo[l][turn] = (memo[l][turn]==-1) ? p: memo[l][turn];
}

int main() {
  //  freopen("in", "r", stdin);
    //int tc = 1;
    while (scanf("%d %d %d", &n, &m, &k) != EOF) {
//           printf("Test case %d: \n",tc++);
        if (m <= k) {
            printf("Marsel\n");
            continue;
        }
        if (k == 1) {
            if (n % 2) printf("Timur\n");
            else printf("Marsel\n");
            continue;
        }
        divit.clear();
        divit.push_back(1);
        memset(memo, -1, sizeof memo);
        for (int i = 2; i <= (sqrt(m) + 0.001); i++)
            if (m % i == 0) divit.push_back(i);
        int s = divit.size();
        if (m == (m / divit[s - 1])*(m / divit[s - 1])) s--;
        for (int i = s - 1; i >= 0; i--)
            divit.push_back(m / divit[i]);
        if(win(divit.size() - 1, 1, 0, n)) printf("Marsel\n");
        else printf("Timur\n");
    }
    return 0;

}

#include <bits/stdc++.h>

using namespace std;

int main() {
    int n, m, k;
    cin >> n >> m >> k;

    bool fl = (k == 1 && m > 1);
    for(int i = 2; i * i <= m; i++) {
        if(m % i == 0) {
            if(m / i >= k)
                fl = true;
        }
    }

    if(n % 2 == 0 || !fl)
        cout << "Marsel";
    else
        cout << "Timur";

}

#include <iostream>
#include <cmath>
using namespace std;
int main()
{
        int N,M,K;
        cin>>N>>M>>K;
        bool first_move=false;

        for(int i=1; i*i<=M; i++) {
                if(M%i==0) {
                        if((M/i>=K&&i>1)||(i>=K&&(M/i)>1)) {
                                first_move=true;
                                //return 0;
                                break;
                        }
                }
        }
        if(!first_move)cout<<"Marsel";
        else cout<<((N%2==0)?"Marsel":"Timur");
        return 0;
}

// IN THE NAME OF METAL
#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
typedef pair<ll, ll> pll;

#define sz(x)                       (ll) x.size()
#define all(x)                      (x).begin(),(x).end()
#define F                           first
#define S                           second

ll Pow(ll a, ll b, ll md, ll ans = 1) {
    for (; b; b >>= 1, a = a * a % md)
        if (b & 1)
            ans = ans * a % md;
    return ans % md;
}

const ll MAXN = 1e6 + 10;
const ll INF = 8e18;
const ll MOD = 1e9 + 7;
ll n, m, k;
map<ll, ll> Gr;

ll Grundy(ll x) {
    if (Gr.find(x) != Gr.end()) return Gr[x];
    unordered_set<ll> St;
    for (ll i = 1; i * i <= x; i++) {
        if (x % i) continue;
        if (x / i >= k && x / i < x) St.insert(Grundy(x / i));
        if (i < x && i >= k) St.insert(Grundy(i));
    }
    ll Mx = 0;
    while (St.find(Mx) != St.end()) Mx++;
    Gr[x] = Mx;
    return Gr[x];
}

int main() {
    scanf("%lld%lld%lld", &n, &m, &k);
    Gr[1] = 0;
    if (Grundy(m) == 0) printf("Marsel\n");
    else if (n % 2) printf("Timur\n");
    else printf("Marsel\n");
    return 0;
}

// IN THE NAME OF METAL
#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
typedef pair<ll, ll> pll;

#define sz(x)                       (ll) x.size()
#define all(x)                      (x).begin(),(x).end()
#define F                           first
#define S                           second

ll Pow(ll a, ll b, ll md, ll ans = 1) {
    for (; b; b >>= 1, a = a * a % md)
        if (b & 1)
            ans = ans * a % md;
    return ans % md;
}

const ll MAXN = 1e6 + 10;
const ll INF = 8e18;
const ll MOD = 1e9 + 7;
ll n, m, k;
map<ll, ll> Gr;

ll check(ll x) {
    for (ll i = 1; i * i <= x; i++) {
        if (x % i) continue;
        if ((x / i >= k && x / i < x) || (i >= k && i < m)) return 1;
    }
    return 0;
}

int main() {
    scanf("%lld%lld%lld", &n, &m, &k);
    printf(check(m) && n % 2 ? "Timur\n" : "Marsel\n");
    return 0;
}

#include <bits/stdc++.h>

using namespace std;
#define DEBUG_ON 1

#define INF 0x3f3f3f3f
#define NSYNC ios::sync_with_stdio(false);
#define FOR(i,a,b) for(int i=a; i<(b); ++i)
#define FOR0(i,b) for(int i=0; i<(b); ++i)
#define TRAV(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define RTRAV(it,c) for(__typeof((c).rbegin()) it=(c).rbegin(); it!=(c).rend(); ++it)
#define DBG(x) if(DEBUG_ON) cout << #x << " == " << x << endl
#define DBGP(x) if(DEBUG_ON) cout << "(" << (x).first << ", " << (x).second << ")" << endl
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define R(x) scanf(" %d",&(x))
#define RR(x,y) scanf(" %d %d",&(x), &(y))
#define RRR(x,y,z) scanf(" %d %d %d",&(x), &(y),&(z))
#define CLR(v) memset(v, 0, sizeof(v))
#define SET(v) memset(v, -1, sizeof(v))

typedef long long ll;
typedef int int_type;
typedef pair<int_type, int_type> pii;
typedef vector<int_type> vi;
typedef vector<vi> vii;

vector<pii> facts;
map<int,bool> mp;
int k;
int m;

void fact(int n) {
	for(int i=2; i*i<=n; ++i) {
		while(!(n%i)) {
			if(!facts.size() || facts.back().first !=i) facts.pb(mp(i,1));
			else ++facts.back().second;
			n/=i;
		}
	}
	if(n>1) facts.pb(mp(n,1));
}

int get_val(const vector<pii>& v) {
	int x = 1;
	TRAV(it,v) {
		FOR0(iii,it->second) x*=(it->first);
	}
	return x;
}

void gen(int p, const vector<pii>& facts, int x, vector<pii> auxfacts, int intval, vector<vector<pii> >& aux) {
	if(p==facts.size()) {
		if(x>1 && (ll)intval >= k*1LL*x) {
			aux.pb(auxfacts);
		}
		return;
	}
	FOR0(i,facts[p].second+1) {
		vector<pii> newv(auxfacts);
		newv.pb(mp(facts[p].first,i));
		gen(p+1,facts, x, newv,intval,aux);
		x*=facts[p].first;
	}
}

int solve(vector<pii> v) {
	int x = get_val(v);

	auto it = mp.find(x);
	if(it!=mp.end()) return it->second;
	vector<vector<pii> > aux;

	gen(0,v,1,vector<pii>(), x,aux);

	set<int> st;

	TRAV(it,aux) {
		int pdiv = get_val(*it);
		// DBG(pdiv);
		if(pdiv%2==0) st.insert(0);
		else {

			vector<pii> newvec(v);
			FOR0(i,newvec.size()) newvec[i].second -= (*it)[i].second;

			st.insert(solve(newvec));
		}
	}

	int ans = 0;
	while(true) {
		if(!st.count(ans)) {
			return mp[x] = ans;
		}
		++ans;
	}

	assert(false);
}

int main() {
	NSYNC;
	int n,m;
	cin >> n >> m >> k;
	if(!(n&1)) {
		cout << "Marsel\n";
		exit(0);
	}
	fact(m);

	// TRAV(it,facts) DBGP(*it);

	if(solve(facts)) cout << "Timur\n";
	else cout << "Marsel\n";

	return 0;
}

#include <iostream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <assert.h>
#include <deque>
using namespace std;

typedef unsigned long long UL;
typedef long long LL;
typedef long double LD;
#define LP(i, a, b) for (int i = int(a); i < int(b); i++)
#define LPE(i, a, b) for (int i = int(a); i <= int(b); i++)
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<vector<PII> > WAL;
typedef vector<vector<int> > SAL;
#define Ep 1e-8
#define INF 1e9
#define LINF 1e18

/*
 if n is even, then there are in total even # of steps, M will win for sure -> just replicate what T does
 if n is odd, T should make sure, the first bite can finish the log, otherwise, M will finish it, and T will end up in the lose case

 this means T needs to find minimal d >= k, s.t. d % m = 0, note that checking all divisors can be done in sqrt(m) => we have pairs here!
 note that minimal means that we can not further divide by by divisors > k, otherwise, it is not minimal

 corner case:
 1 2 1
 1 1 1
 */

int const MaxSize = 1e5 + 5;

//NOTE WORKS ONLY WHEN MOD IS PRIME
LL MOD = 1e9 + 7;
int n, m, k;

int main() {
	ios_base::sync_with_stdio(false);
	//freopen("/Users/georgeli/A_1.in", "r", stdin);
	cin >> n >> m >> k;
	if (n % 2 == 0 || m == 1) {
		cout << "Marsel" << endl;
		return 0;
	}

	bool isPrime = true;
	LPE(d, 2, sqrt(m))
	{
		if (m % d == 0) {
			isPrime = false;
			if (d >= k || m / d >= k) {
				cout << "Timur" << endl;
				return 0;

			}
		}
	}

	if (isPrime && k == 1) {
		cout << "Timur";
		return 0;
	}

	cout << "Marsel" << endl;
	return 0;

	return 0;
}

/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define all(x) (x).begin(), (x).end()

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;

template <typename T>
inline T sqr(T n) {
    return n * n;
}

int n, m, k;

int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif

    scanf("%d%d%d", &n, &m, &k);

    if (n % 2 == 0) {
        puts("Marsel");
        return 0;
    }

    for (int i = 2; i * i <= m; i++) {
        if (m % i == 0) {
            if (i >= k || m / i >= k) {
                puts("Timur");
                return 0;
            }
        }
    }

    if (k == 1 && m != 1) {
        puts("Timur");
        return 0;
    }

    puts("Marsel");

    return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define ff first
#define ss second
#define SI(x) ((int)(x).size())
#define nl "\n"
typedef vector<int> VI;
typedef long long ll;
typedef pair<int,int> PII;
typedef double db;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);

	/*
	k>m/2
	not a factor >=k 2
	if n is even 2
	if n is odd 1
	*/

	ll n,m,k;
	cin >> n >> m >> k;
	if(k>m/2){
		cout << "Marsel\n";
		return 0;
	}
	ll sn=sqrt(m)+1;
	int flag=0;
	rep(i,1,sn){
		if(i==1){
			if(k==1){
				flag=1;
				break;
			}
		}
		else if(i==m)
			break;
		else if(m%i==0){
			if(i>=k || (m/i)>=k){
				flag=1;
				break;
			}
		}
	}
	// cout << "flag 2 " << flag << nl;
	if(!flag){
		cout << "Marsel\n";
		return 0;
	}

	if(n%2==0)
	    cout<<"Marsel\n";
	else
	    cout<<"Timur\n";

	return 0;
}

// I love natalia

#include <iostream>
#include <cstdio>

using namespace std;

#define mp make_pair
#define pb push_back

int m, k;

bool doMagic() {
    for (int i = 2; i*i <= m; i++)
        if ( m%i == 0 )
            return ( m/i >= k );

    return ( m != 1 && k == 1 );
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "rt", stdin);
#endif

    int    n;
    cin >> n >> m >> k;

    if ( n%2 == 0 ) {
        cout << "Marsel";
        goto exit;
    }

    //if ( k == 1 ) {
    //  cout << ( ((n&1 )&& m != 1) ? "Timur" : "Marsel" );
    //  goto exit;
    //}

    cout << ( (doMagic()) ? "Timur" : "Marsel" );

exit:
    return ( 0 );
}

#include<iostream>

using namespace std;

int n, d, k;

int main()
{
    cin >> n >> d >> k;

    if (n % 2 == 0)
    {
        cout << "Marsel\n";
        return 0;
    }
    else {
        for (int i = 1; i*i<=d; i++)
            if (d%i == 0)
            {
                if (k<=i && d/i>1)
                {
                    cout << "Timur\n";
                    return 0;
                }
                else if (k<=d/i && i >1) {
                    cout << "Timur\n";
                    return 0;
                }

            }
    }

    cout << "Marsel\n";

    return 0;
}

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
int n,m,k,i,j=0;
string s;
cin>>n>>m>>k;
for(i=2;i*i<=m;i++)
{
while(m/i>=k && m%i==0)
{
m/=i;
j++;
}
}
if(n%2==0) s="Marsel";
if(j>=1 || (k==1 && m!=1))
{
if(n%2==1) s="Timur";
else s="Marsel";
}
else s="Marsel";
cout<<s;
return 0;
}

// 22 - 4
// 6.000
// 24
// 1589
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define mod1 1187278649
#define mod2 1149736019
#define ioi cout<<"\n------------ioi------------\n"
#define all(x) (x).begin(),(x).end()

const ld PI=3.14159265358979323;
const int linf=1000111000111000111LL;
const int inf=1011111111;
const int N=100005;

int gcd(int a, int b);
int power(int x, int y, int p);
int modInverse(int n, int p);
int nCrModPFermat(int n, int r, int p);
void pri(int n);
void sieve_primes(int n);
void sieve(int n);
int copa(int n);

main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int test=1;
    // cin>>test;
    while(test--){
        int n,m,k;
        cin>>n>>m>>k;
        if(n%2==0){
            cout<<"Marsel\n";
            continue;
        }
        int mx=0;
        for(int i=2;i<=sqrt(m);i++){
            if(m%i==0){
                mx=max(mx,i);
                mx=max(mx,m/i);
            }
        }
        if(m!=1)
            mx=max(mx,(int)1);
        if(mx<k){
            cout<<"Marsel\n";
            continue;
        }
        cout<<"Timur\n";
    }
    cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
    return 0;
}

// int gcd(int a, int b){
//     if(b==0)
//         return a;
//     else
//         return gcd(b,a%b);
// }

// int power(int x, int y, int p){
//     int res=1;
//     x=x%p;
//     while(y>0)
//     {
//         if (y & 1)
//             res=(res*x)%p;
//         y=y>>1;
//         x=(x*x)%p;
//     }
//     return res;
// }

// int modInverse(int n, int p)
// {
//     return power(n,p-2,p);
// }

// int nCrModPFermat(int n, int r, int p)
// {
//     if(r==0)
//         return 1;
//     return ((fac[n]*modInverse(fac[r],p))%p*modInverse(fac[n-r],p)%p)%p;
// }

// !!!---> IMP <----!!! Create a vector of primes before using this function...
// void pri(int n)
// {
//     for(int i=2;i<=sqrt(n);i++)
//     {
//         if(n%i==0)
//         {
//             while(n%i==0) n=n/i;
//             primes.pb(i);
//        }
//     }
//     if(n>=2) primes.pb(n);
// }

// Create spf array and bool primes array....
// void sieve_primes(int n)
// {
//     primes[0]=true;
//     primes[1]=true;
//     for(int i=2;i*i<=n;i++)
//     {
//         if(primes[i]==false)
//         {
//             for(int j=i*i;j<=n;j+=i)
//                 primes[j]=true;
//         }
//     }
// }

// void sieve(int n)
// {
//     spf[1]=1;
//     for(int i=2;i<=n;i++) spf[i]=i;
//     for(int i=4;i<=n;i+=2) spf[i]=2;
//     for(int i=3;i*i<=n;i++)
//     {
//         if(spf[i]==i)
//         {
//             for(int j=i*i;j<=n;j+=i)
//             {
//                 if(spf[j]==j) spf[j]=i;
//             }
//         }
//     }
// }

// int copa(int n)
// {
//     int result=n;
//     for(int i=2;i<=sqrt(n);i++)
//     {
//         if(n%i==0)
//         {
//             while(n%i==0)
//                 n/=i;
//             result-=result/i;
//         }
//     }
//     if(n>1)
//         result-=result/n;
//     return result;
// }

#include <bits/stdc++.h>
using namespace std;

const int R = 40004;
int n, m, k, g[R];
bool d[R];
vector<int> v;

void D(int x) {
	vector<int> ve; ve.clear();
	for(int i = 0; i < x; ++i) {
		if(v[x] % v[i] == 0) {
			int gw = 0;
			if(v[x] / v[i] % 2) gw = g[i];
			if(!d[gw]) ve.push_back(gw);
			d[gw] = 1;
		}
	}
	int j = -1;
	for(int i = 0; d[i]; j = i, ++i);
	g[x] = j + 1;
	for(int i = 0; i < ve.size(); ++i) d[ve[i]] = 0;
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cin >> n >> m >> k;
	if(n & 1 ^ 1) return cout << "Marsel" << endl, 0;
	int ei = 0;
	for(int i = 1; i * i <= m; ei = i, ++i)
		if(m % i == 0 && i >= k) v.push_back(i);
	for(int i = ei; i >= 1; --i)
		if(m % i == 0 && i * i != m && m / i >= k) v.push_back(m / i);
	for(int i = 0; i < v.size(); ++i)
		D(i);
	cout << (vector<string>){"Timur", "Marsel"}[!g[(int)v.size() - 1]] << endl;
	return 0;
}

#pragma comment(linker, "/STACK:64000000")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <ctime>
#include <deque>

#define forn(i, n) for (int i = 0; i < n; i ++)
#define ford(i, n) for (int i = n - 1; i >= 0; i --)
#define mp make_pair
#define pb push_back
#define x first
#define y second
#define pi 3.1415926535897932
#define ll long long
#define ld long double

using namespace std;

int main(){
#ifndef ONLINE_JUDGE
    freopen ("input.txt","rt",stdin);
    freopen ("output.txt","wt",stdout);
#endif
    int n, m, k;
    cin >> n >> m >> k;
    bool q = false;
    for (int i = 1; i * i <= m; i ++){
        if ((m % i) == 0 && i != m && i >= k) q = true;
        if ((m % i) == 0){
            int j = m / i;
            if ((m % j) == 0 && j != m && j >= k) q = true;
        }
    }
    if (!q){
        printf ("Marsel");
        return 0;
    }
    if ((n % 2) == 0) printf ("Marsel");
    else printf ("Timur");
    return 0;
}

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <map>
using namespace std;

/*
char str[MAXN];
int n;

bool Check(int n)
{
    return true;
}

void MusicalTheme()
{
    while(scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
          scanf("%d",&str[i]);
        a.Set(str);
        if(!Check(4))
        {
                printf("0\n");
                continue;
        }
        int l=5;
        int r=n;
        int mid;
        int ans=5;
        while(r-l<=1)
        {
            mid =(l+r)>>1;
            if(Check(l))
            {
                l=mid;
                ans=l;
            }
            else
                r=mid;
        }
        if(Check(l))
            ans =l ;
        if(Check(r))
            ans=r;
        printf("%d\n",ans);
    }
}
*/

void BeaverGame()
{
    int n , m , k;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        if(n%2==0)
            printf("Marsel\n");
        else
        {
            int minfactor=m;
            for(int i=1;i*i<=m;i++)
            {
               if(m%i==0)
               {
                   if(i>=k && minfactor>i)
                       minfactor = i;
                   if((m/i)>=k && minfactor>(m/i))
                       minfactor = m/i;
               }
            }
            if(minfactor!=m)
                printf("Timur\n");
            else
                printf("Marsel\n");
        }
    }
}

int main()
{
  //  freopen("c:\\in.txt","r",stdin);
//  freopen("f:\\i.in","r",stdin);
    //freopen("f:\\myi.out","w+",stdout);
//  MusicalTheme();
   BeaverGame();
    return 0;
}

//#pragma GCC optimize("trapv")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
//#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define pb push_back
#define all(x) x.begin(), x.end()
using namespace std;
using ll = long long;
using vi = vector<ll>;
using pi = pair<ll, ll>;
using vpi = vector<pi>;
const int maxn = 1e3 + 5;
ll n, m, k;
vi divs;
int s[maxn], b[maxn];
#define dp (l<maxn?s[l]:b[m/l])
int go(int l) {
	if(dp!=-1) return dp;
	dp=0;
	for(auto d : divs) {
//		cout << d << " " << (d==l) << bool(l%d) << (d<k) << "\n";
		if(d>=l||l%d||d<k) continue;
		if((l/d)&1) {dp=1;break;}
		dp|=go(d)^1;
		if(dp) break;
	}
//	cout << l << " " << dp << "\n";
	return dp;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	memset(s, -1, sizeof s);
	memset(b, -1, sizeof b);
	cin >> n >> m >> k;
	for(ll d = 1; d*d <= m; d++) {
		if(m%d) continue;
		divs.pb(d);
		if(d*d!=m)
			divs.pb(m/d);
	}
	if(n&1) {
		if(go(m))
			cout << "Timur";
		else
			cout << "Marsel";
	} else
		cout << "Marsel";
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define f(i, l, r) for (int i = l; i <= r; i++)
#define rf(i, r, l) for (int i = r; i >= l; i--)
#define all(x) (x).begin(), (x).end()
#define sf(a) scanf("%d",&a)
#define llsf(a) scanf("%lld", &a)
#define l l
#define r r
#define lch (o << 1)
#define rch (o << 1 | 1)
#define mid ((l + r) >> 1)
#define mem(x, y) memset(x, y, sizeof(x))

const int inf = 2e9 + 7;
const ll INF = INT64_MAX;
double eps = 1e-6;
int mod = 1e9 + 7;
const int N = 5e5 + 10;
const double pi = acos(-1.0);

int main() {
#ifdef local
	freopen("in.txt", "r", stdin);
#endif
	int s = 1e5;
	int n, m, k; cin >> n >> m >> k;
	if (n % 2) {
		bool ok = 0;
		for (int i = 1; i * i <= m; i++) {
			if (m % i == 0) {
				if (i >= k && m / i >= 2)ok = 1;
				if (m / i >= k&&i>=2)ok = 1;
			}
		}
		if (ok) {
			cout << "Timur";
		}
		else cout << "Marsel";
	}
	else {
		cout << "Marsel";
	}
}

//#define __USE_MINGW_ANSI_STDIO 0
#include <iostream>
#include <bits/stdc++.h>
using namespace std;

#define debug(x) cout<<#x<<" :: "<<x<<endl;
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<endl;
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<endl;

#define boost ios::sync_with_stdio(0); cin.tie(0)

#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)

typedef long long ll;
typedef double ld;
typedef pair<int, int> pii;

const int N = 1e6 + 5;

/***************************************************************************/

vector<int> find_divisors(int n) {
	vector<int> v;
	for(int i=1; i*i<=n; i++) {
		if(n % i) continue;
		v.pb(i);
		if(i*i != n) v.pb(n/i);
	}
	sort(v.begin(), v.end());
	return v;
}

int dp[N];

int main() {

	boost;
	int n, m, k; cin>>n>>m>>k;
	vector<int> divs = find_divisors(m);
	for(int i=0; i<(int)divs.size(); i++) {
		int d = divs[i];
		if(d < k) continue;
		for(int j=i-1; j>=0; j--) {
			if(divs[j] < k) break;
			if((d/divs[j]) % 2 == 0 or dp[j] == 0) {
				dp[i] = 1;
				break;
			}
		}
	}
	if(n % 2 == 0 or dp[divs.size()-1] == 0) {
		cout<<"Marsel\n";
	}
	else {
		cout<<"Timur\n";
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	if (n%2==0) {
		cout<<"Marsel";
		return 0;
	}
	else {
		bool ch = 0;
		for (int i = 1; i * i <= m; i++)
		{
			if (m%i==0)
			if (((m / i) >= k && i !=1) || ((k <= i) && (m / i > 1)) )
			{
				ch = true;
				break;
			}
		}
    cout<<(ch?"Timur":"Marsel");
	}
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define int               long long
#define pb                push_back
#define ppb               pop_back
#define pf                push_front
#define ppf               pop_front
#define all(x)            (x).begin(),(x).end()
#define sz(x)             (int)((x).size())
#define fr                first
#define sc                second
#define pii               pair<int,int>
#define rep(i,a,b)        for(int i=a;i<b;i++)
#define mem1(a)           memset(a,-1,sizeof(a))
#define mem0(a)           memset(a,0,sizeof(a))
#define ppc               __builtin_popcount
#define ppcll             __builtin_popcountll

template<typename T1,typename T2>istream& operator>>(istream& in,pair<T1,T2> &a){in>>a.fr>>a.sc;return in;}
template<typename T1,typename T2>ostream& operator<<(ostream& out,pair<T1,T2> a){out<<a.fr<<" "<<a.sc;return out;}
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}

const long long INF=1e18;
const int32_t M=1e9+7;
const int32_t MM=998244353;

const int N=0;

void solve(){
	int n,m,k;
	cin>>n>>m>>k;
	if(n%2==0 || k>=m){
		cout<<"Marsel";
		return;
	}
	if(m%2==0 && k<=m/2){
		cout<<"Timur";
		return;
	}
	vector<int> d,s;
	for(int i=1;i*i<=m;i++){
		if(m%i)continue;
		if(i>=k)d.pb(i);
		if(m/i != i && m/i>=k)d.pb(m/i);
	}
	sort(all(d));
	s.resize(sz(d));
	rep(i,0,sz(d)){//cout<<d[i]<<" ";
		int ans=0;
		rep(j,0,i){
			if(d[i]%d[j]==0 && s[j]==0)ans=1;
		}
		s[i]=ans;
	}
	if(s.back()){
		cout<<"Timur";
	}
	else{
		cout<<"Marsel";
	}
}
signed main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	#ifdef SEIVE
		seive();
	#endif
	#ifdef NCR
		init();
	#endif
	int t=1;
	//cin>>t;
	while(t--) solve();
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
    ll n,m,k;
    while(~scanf("%lld%lld%lld",&n,&m,&k)){
        if(n%2==0){
            printf("Marsel\n");continue;
        }
        if(m%2==0&&m/2>=k){
            printf("Timur\n");continue;
        }
        bool flag=false;
        for(ll i=2;i*i<=m;i++){
            if(m%i==0){
                int j=m/i;
                //cout<<i<<endl;
                if(j<k) break;
                flag=true;
            }
        }
        if(k==1&&m!=1) flag=true;
        if(flag) printf("Timur\n");
        else printf("Marsel\n");
    }
}

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#define ABS(a) ((a>0)?a:-(a))
#define MIN(a,b) ((a<b)?(a):(b))
#define MAX(a,b) ((a<b)?(b):(a))
#define FOR(i,a,n) for (int i=(a);i<(n);++i)
#define FI(i,n) for (int i=0; i<(n); ++i)
#define pnt pair <int,int>
#define mp make_pair
#define PI 3.14159265358979
#define MEMS(a,b) memset(a,b,sizeof(a))
#define LL long long
#define U unsigned
using namespace std;
map <int,int> mm;
vector<int> d;
int dp(int v)
{
	if (v==1)
		return 0;
	if (mm.find(v)!=mm.end())
		return mm[v];
	vector<int> a;
	a.resize(d.size(),0);
	FOR(i,0,a.size())
	{
		if ((v%d[i]==0) && (v!=d[i]))
		{
			int k=v/d[i];
			if (!(k&1))
				a[0]=1;
			else
			{
				int vv=dp(d[i]);
				if (vv<a.size())
					a[vv]=1;
			}
		}
	}
	FOR(i,0,a.size())
		if (a[i]==0)
			return mm[v]=i;
	return mm[v]=a.size();
}
int main()
{
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	if (!(n&1))
	{
		printf("Marsel\n");
		return 0;
	}
	for (int i=1; i*i<=m; ++i)
		if ((m%i)==0)
		{
			if (m/i>=k)
				d.push_back(m/i);
			if (i>=k)
				d.push_back(i);
		}
	int c=dp(m);
	if (c)
		printf("Timur\n");
	else
		printf("Marsel\n");
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

bool is_div(int m, int k)
{
	for (int i = min(2, k); i * i <= m; ++i){
		if (m % i == 0 && (i >= k || m / i >= k) &&  m > i)
			return true;
	}
	return false;
}

void solution(int n, int m, int k)
{
	if (n % 2 == 0 || !is_div(m, k))
		cout << "Marsel" << endl;
	else
		cout << "Timur" << endl;
}

int main() {
    ios::sync_with_stdio(false);
	cout.precision(10);

	int n, m, k;
	while(cin >> n >> m >> k)
	{
		solution(n, m, k);
	}
	return 0;
}

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <cmath>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;

int main(){
        LL n,m,k;
        scanf("%lld %lld %lld",&n,&m,&k);
        LL d=0;
        LL n_m=ceil(sqrt(double(m)));
		bool flag=false;
        for (LL i=1;i*i<=m;++i){
			if(!(m%i)){
                if (i>1 && m/i>=k){
					flag=true;
					break;
				}
				if (i>=k && m/i>1){
					flag=true;
					break;
				}
			}
		}
        if (flag){
                if((n&1))printf("Timur\n");
                else printf("Marsel\n");
        }
        else{
                printf("Marsel\n");
        }
        return 0;
}

#include <iostream>

using namespace std;

int main()
{int n,m,k,i;
cin >> n >> m >> k;
if (n%2==0||m<=k) {cout << "Marsel"; return 0;}
if (k<=1) {cout << "Timur"; return 0;}
i=2;
while (i*i<=m) {
    if (m%i==0) {if (m/i>=k) {cout << "Timur"; return 0;}}
    i++;
}
    cout << "Marsel";
    return 0;
}

#include <iostream>
#include <vector>
//#include <stdio.h>

using namespace std;

bool firstPrime (int n, int k) {
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            if (n / i >= k) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    //freopen("input.txt", "r", stdin);
    int n, m, k;
    cin >> n >> m >> k;
    bool f = firstPrime(m, k);
    if (m == 1) {
        cout << "Marsel";
    }
    else if (!f && k != 1) {
        cout << "Marsel";
    }
    else if (n % 2 == 0) {
        cout << "Marsel";
    }
    else {
        cout << "Timur";
    }
    return 0;
}

#include<bits/stdc++.h>
#include<cmath>
using namespace std;
#define ll long long
#define F first
#define S second
#define pb push_back
#define mp make_pair
const int MX=1*1e5 + 10;
const double PI = acos(-1.0), EPS = 1e-9;
int N, Q, M, k;
int main()
{
    cin>>N>>M>>k;
    vector<int> dd;
    for(int i=1; i*i<=M; i++)
    {
        if(M%i) continue;
        dd.push_back(i);
        dd.push_back(M/i);
    }
    bool found=0, even=0, odd=0;

    /// cout<<even<<" "<<odd<<"\n";
    if(N % 2 == 0)
    {
        cout<<"Marsel\n";
        return 0;
    }
    if(k == 1 && M > 1)
    {
        cout<<"Timur\n";
        return 0;
    }
    int c=0;
    for(int i=0; i<dd.size(); i++)
    {
        if(dd[i] == 1) continue;
        if(M/dd[i] >= k || i >= k)
        {
            cout<<"Timur\n";
            return 0;
        }
    }
    cout<<"Marsel\n";
    return 0;
}

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=100001;
int main()
{
    int n,m,k;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        int flag=0;
        if(n&1)
        {
            for(int i=1;i*i<=m;i++)
                if(m%i==0)
                {
                    if(i>=k&&m/i>1||i>1&&m/i>=k)
                    {
                        flag=1;
                        break;
                    }
                }
        }
        printf("%s\n",flag?"Timur":"Marsel");
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n,m,k;
	cin>>n>>m>>k;
	if(n%2 == 0){
		cout<<"Marsel"<<endl;
	}
	else{
		if(k == 1 && m > 1){
			cout<<"Timur"<<endl;
			return 0;
		}
		int z =sqrt(m)+1;
		for(int i=2;i<=z;i++){
			if(m%i == 0){
				if(m/i >= k){
					cout<<"Timur"<<endl;
					return 0;
				}
			}
		}
		cout<<"Marsel"<<endl;
	}
}

#include<cstdio>
#include<cmath>
int main()
{
 //freopen("a.in","r",stdin);
 //freopen("a.out","w",stdout);
 int n,m,k;
 scanf("%d %d %d ",&n,&m,&k);
 if(m==1)
    {
     printf("Marsel");
     return 0;
    }
 bool se_poate=k==1;
 int radical=sqrt(m);
 for(long long i=2;i<=radical;i++)
     {
      if(m%i==0 && (i>=k || m/i>=k))
         se_poate=true;
     }
 if(se_poate)
    {
     if(n%2==1)
        printf("Timur");
     else
        printf("Marsel");
    }
 else
    printf("Marsel");
return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MOD = 1000000007;
#define fr(i, n) for (i = 0; i < n; i++)
#define rep(i, n) for (i = 1; i <= n; i++)
#define lcm(x, y) ((x) * (y) / __gcd((x), (y)))
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define debug(x) cout << #x << " : " << x << endl
#define part cout << "----------------------------------\n";
#include <iostream>

int dx[] = {1, 1, 0, -1, -1, -1, 0, 1}; // trick to explore an implicit 2D grid
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1}; // S,SE,E,NE,N,NW,W,SW neighbors  //GO FOR EVEN FOR 4 moves

#define fastinput                     \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL);

vector<LL> factors;
void factorize(LL m)
{
    LL i, j, k, t, temp;
    for (i = 1; i * i <= m; i++)
    {
        if (m % i == 0)
        {
            factors.pb(i);
            factors.pb(m / i);
        }
    }
}

int main()
{
    fastinput;
    LL n, i, j, k, t, temp, tc;
    LL m;
    cin >> n >> m >> k;
    if (n % 2 == 0)
    {
        cout << "Marsel" << endl;
        return 0;
    }

    factorize(m);
    set<LL> facs(all(factors));
    //debug(facs.size());

    factors.clear();
    for (auto &x : facs)
    {
        //debug(x);
        if (x >= k)
        {
            factors.pb(x);
        }
    }

    LL sz = factors.size();
    //debug(sz);
    if (sz == 0)
    {
        cout << "Marsel" << endl;
        return 0;
    }
    LL num = m;
    vector<bool> dp(sz, false);
    for (i = 0; i < sz; i++)
    {
        //debug(i);
        LL consider = factors[i];
        if (dp[i])
        {
            continue;
        }
        for (j = i + 1; j < sz; j++)
        {
            LL check = factors[j];
            if (check % consider == 0)
            {
                dp[j] = true;
            }
        }
    }

    if (dp[sz - 1])
    {
        cout << "Timur" << endl;
    }
    else
    {
        cout << "Marsel" << endl;
    }

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)

typedef long long int ll;
typedef unsigned long long ull;

#define int ll

typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;

#define pb push_back
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'

#define mod 1000000007
// #define mod 998244353

// ################################## Debugging statements  ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true;  string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################

inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1;  int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}

// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
	rep(i, p){rep(j, s){rep(k, q){
				// C[i][j] += A[i][k] * B[k][j];
				C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
	}}}return C;}

inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}

// ###########################################################################################

// #################################### Combinatorics template ###############################
struct factorial{
	int N;int *fac;int *ifac;int MOD;
	factorial(int n, int m = 1000000007){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];pre_calc();}
	int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
	int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
	int multiply(int a, int b){return (int)((long long) a * b %MOD);}
	int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
	int inverse(int a){return binpow(a, MOD - 2);}
	void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
	int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
	int derangement(int n){
		if (n == 1) return 0;
		int ans = 0;
		for (int i = 2; i <= n ; i++){
			int sign = (i%2) ? -1 : 1;
			ans = add(ans, multiply(sign, fac[n]/fac[i]));
		}
		return ans;
	}
};

vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################

// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
	int *bit;int n;
	fenwick_tree(){this->n = 100005;this->bit = new int[100005+1];}
	fenwick_tree(int n){this->n = n;this->bit = new int[n+1];}
	void add(int i, int v){for (; i<=this->n; i+= i&-i)this->bit[i] += v;}
	int get(int i){int s = 0;for (; i; i -= i&-i){s += this->bit[i];}return s;}
};
// ###########################################################################################

// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;

// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)

// ###########################################################################################

// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################

// ###################################### Convex Hull Trick  ##################################
// struct Line {
//     mutable ll k, m, p;
//     bool operator<(const Line& o) const { return k < o.k; }
//     bool operator<(ll x) const { return p < x; }
// };

// struct LineContainer : multiset<Line, less<>> {
//     // (for doubles, use inf = 1/.0, div(a,b) = a/b)
//     const ll inf = LLONG_MAX;
//     ll div(ll a, ll b) { // floored division
//         return a / b - ((a ^ b) < 0 && a % b); }
//     bool isect(iterator x, iterator y) {
//         if (y == end()) { x->p = inf; return false; }
//         if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
//         else x->p = div(y->m - x->m, x->k - y->k);
//         return x->p >= y->p;
//     }
//     void add(ll k, ll m) { // y = k * x + m
//         auto z = insert({k, m, 0}), y = z++, x = y;
//         while (isect(y, z)) z = erase(z);
//         if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
//         while ((y = x) != begin() && (--x)->p >= y->p)
//             isect(x, erase(y));
//     }
//     ll query(ll x) {
//         assert(!empty());
//         auto l = *lower_bound(x);
//         return l.k * x + l.m;
//     }
// };
// ###########################################################################################

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

// ################################### Template ends here ####################################

signed main(){
	crap;
	int n, m, k;
	cin >> n >> m >> k;
	if (n % 2 == 0){
		cout << "Marsel" << endl;
		return 0;
	}
	vi fac = factors_n(m);
	sort(all(fac));
	int idx = lb(fac, k) - fac.begin();
	if (idx == sz(fac) or fac[idx] == m){
		cout << "Marsel" << endl;
	}
	else{
		cout << "Timur" << endl;
	}
}

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=100001;
int main()
{
	int n,m,k;
	while(~scanf("%d%d%d",&n,&m,&k))
	{
		int flag=0;
		if(n&1)
		{
			for(int i=1;i*i<=m;i++)
				if(m%i==0)
				{
					if(i>=k&&m/i>1||i>1&&m/i>=k)
					{
						flag=1;
						break;
					}
				}
		}
		printf("%s\n",flag?"Timur":"Marsel");
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define MOD 1000000007
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(var) (var).begin(), (var).end()
#define MAXX 9000000000000000000
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vector<int> >
#define vpi vector<pair<int,int> >
#define vvpi vector<vector<pair<int,int> > >

int32_t main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	#ifndef ONLINE_JUDGE
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
	#endif

	int n,m,k;
	cin >> n >> m >> k;
	if(n % 2 == 0 || m < 2 * k)
	{
		cout << "Marsel";
		return 0;
	}
	if(k == 1)
	{
		cout << "Timur";
		return 0;
	}
	for(int i=2;i*i<=m;i++)
	{
		if(m % i == 0)
		{
			if(m / i >= k || i >= k)
			{
				cout << "Timur";
				return 0;
			}
		}
	}

	cout << "Marsel";

	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define rev(i,n,a) for (int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define x first
#define y second
#define SZ(x) ((int)(x).size())
typedef vector<int> vi;
typedef long long ll;
typedef pair<int,int> pii;
const ll mod=1000000007;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}

template<class T,class U> bool smax(T &a,U b) { return (a < b ? a = b,1 : 0); }
template<class T,class U> bool smin(T &a,U b) { return (a > b ? a = b,1 : 0); }

const int N = 1e5+10;
int n,m,k;
vi d;
vi divs(int num){
	vi r;
	for(int i=1;i*i<=num;++i)if(num % i == 0){
		r.pb(i);
		if(i != (num/i)) r.pb(num/i);
	}
	return r;
}
map<int,int> dp;
int solve(int m){
	int res = 0;
	if(dp.count(m))return dp[m];
	vi d = divs(m);
	for(int x : d)if(x >= k && x < m && m%x == 0){
		int pieces = m/x;
		int ff = solve(x);
		if(!(ff && (pieces&1))) {
            res = 1;
		}
	}
	return dp[m]=res;
}
int main(){
	cin>>n>>m>>k;
	int ff = solve(m);
	if(n % 2 == 0) puts("Marsel");
	else puts(ff ? "Timur" : "Marsel");
}

#include <bits/stdc++.h>
using namespace std;
#define int long long int
int32_t main() {

	int t=1;
	//cin>>t;
	while(t--)
	{
		int n,m,k;
		cin >> n>>m>>k;
		if(n%2==0)cout <<"Marsel";
		else
		{
			int f=0;
			for(int i=1; i*i<=m; i++)
			{
			    if(m%i==0)
			    {
			    	if(i>=k && m/i>1)f=1;
			    	if(m/i>=k && i>1)f=1;
			    }
			}
			if(f==1)cout<<"Timur";
			else cout <<"Marsel";
		}

	}
	// your code goes here
	return 0;
}

#define ONLINE_JUDGE 1
/*Frederica Bernkastel
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒
▒░░░░░    ░░░░░░░▒▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░▒
▒░░░░░   ░░░░░░▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓▒▓▒▒▓▓▓▓▒▒▒▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓░▒
▒        ░░░░░▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▓▓▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓▒▒▒▓▒▒▒▒▓▓▒▒
▒        ░░░▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▓▓▓▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▓▒▒▒▒▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓
▒░░░░░░░░░░▒▓▒▒▒▒▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░░░░░░▒▓▓▒▒▒▒▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░░░░░░▓▓▒▒▒▓▓▓▒▒▒▒▒▒▒▓▓▓▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░░░░▒▓▓▒▒▒▓▓▓▓▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▓▓▓▒▓▓▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░░░░▓▓▒▒▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▓▓▓▒▒▓▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▓▓▒▓▓▓▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▒▒▒▓▒▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓██▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓
▒░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓█▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓██▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓██▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓█▓▓▓██▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓█▓▓▓██▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▒▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
▒░░░░░░▒▓█▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓███▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
▒░░░░░░▓▓▓▓█▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓▓▓████▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░░▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓████▓▓▓▓▓▓████▓▒▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓█████▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓▓▓▓▓▓▓▓█▓█▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░░▓▓▓▓▓████████▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▒▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓▓▓▓▓▓▓▓█▓█▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░░▓▓▓▓▓▓▓▓▓▓▓█████████████▓▓▓▓▓▓▓▓▓▓██▓▒▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▒▓███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓█████████▓▓▓███▓▓▒▓█▓▒▓▓▓▓▓▓▓█▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓█████▓▓▓▒▒█▓▓▓▓▓▓████▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓███████████████▓▓▒▒█▓▒▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▒▒▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████████████████▒▒▒▒▒▓▓▒▒▓▓▓▓▓▓██▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓█████▓▓▓▓▓▓▓▓▓█▓▓▒█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓█▓▓████████▓▓█████████▓▓▒░░░░░░░░░░▒▒▒▒▒▒▒▓▓▓▓▓▓███████▓▓▓▓▓▓▓▓██████▓▒▒████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓██▓████▓▓█▓▒▒▓█████████▓▒░░░░░░░░░░░░░░░░░░░░░░░░░▒▒██████████████████▓▓▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▒▒█▓░▓█████████▓▓▒░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓█████████████████████▓▒▒▒▓▓▓▓▓▓▓███████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▒░▒▓░▒▓███████▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░███████████████████▓▒░░░░░░▓█▓▓▓███████▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▒░░▒░░▓██▓▓████▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█████████████████████▓▒░░░░▓█▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓░░░░░░██▓▓▓▓▓█▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓█████████████████████▓▒░░░▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▒░░░░░▓█▓▓▓▓▓█▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓████▓▓██████████▓▒▓████▓░░▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░░░▓█▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓███▓▓▓▓▓▓▓▓▓▓██▓▒▓██▓▒░▒▒▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓░░░░▒▒▒█████▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒███▓▓▓▓▓▓▓▓▓███▒▓▓▒░░░░░░▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓█▓░░░░░░░▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓███▓▓▓▓▓▓▓███▒░▒░░░░░░░░▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓█▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒░▒█████▓███▓▓░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓█▓░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓██▓▓▒░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓██▒░░░░░░░░░░░░░░░░▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓██▒░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓██▓▒░░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓█▓▓▓░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓█▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓█▓▓█▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓█▓▓██▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓█▓▓█▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓█▓▓▓█▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓█▓▓██▓▒░░░░░░░░░░░░░▒░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▒░░░░░░░░░░░░░░░░░▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓██▓▓▓▓░░░░░░░░░░░░░▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓██▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓██▓▓██▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓███▓██▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒█▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓███▓██▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▓██▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░▒▓▓▓▒▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒▒▒▒▒▒▒▓██▓▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░▒▓▓▓▒▒▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▒▒▒▒▒░░░░░▒▒▒▓▓██▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▒▓▒▒▒▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▒▒▒░▒░▒▒░░░░░░░░░▓▓▓█▓██▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▒░░░░░▒▓▒▒▒▒▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓▒▒▒░░░░░░░░░░░░░░░░░▒▓▓▓█▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
▒░░░░░░▓▓▒▒▒▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▒▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓███▓▓▓▓████████▓▓▓██▒▒░░░░░░░░░░░░░░░░░▒▒▒░▒▓▓▓██▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█
▒░░░░░░▒▓▒▒▒▒▓▓▓▓▓▓▓█▓▒▒▓▓▓▒▒▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓██▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░▒▓▓▒▒▒▓▓▓▓███▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓█▓▓▓▓▓██▓▓▓▓▓██▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓█
▒░░░░░░▒▓▒▒▒▒▒▓█▓▓▓▓█▓▒▓▓▓▒▒▒▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▒░░░░░▒▒▒▒▒▒░▒▒▒░░░░▒▓▓▓██▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓██▓▓▓▓▓███▓▓▓▓▓██▓▓▓▓▓▓▓▓███▓▓▓▓▓█
▒░░░░░░░▒▓▒▒▒▒▓▓█▓▓▓█▓▒▓▓▓▒▒▒▒▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▒░░░▒▒▒▒░░▒▒▒▓▓▒░░░░▓▓▓▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓█▓▓▓▓▓███▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓▓▓█
▒░░░░░░░░▓▓▒▒▒▓▓█▓▓▓█▓▒▓▓▓▒▒▒▒▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▒▒░▒▒▒░▒▓▒░░░░░░░▒▓▒░░░▒▓▓▓▓█▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓██▓▓▓▓▓███▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓██▓▓▓▓▓█
▒░░░░░░░░▒▓▒▒▒▒▓▓▓▓▓█▓▒▓▓▒▒▒▒▒▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓█████▓▓▓▓▓████▓▓▓▓▓▓████▓▒░░░▓▒▒▒▒░░░░░░░░░░░░▒▒▒▓▓▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓██▓▓▓▓▓██▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓███▓▓▓▓█
▒░░░░░░░░░▒▓▒▒▒▒▓█▓▓█▓▒▓▓▒▒▒▒▒▒▓▓████▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓████▓▓▓▓▓▓▓▒▓▓░░▒▒▒▒░░▓▒░░░░░░░░░░░░▒▒▓▓▓██▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓██▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓███▓▓▓▓█
▒░░░░░░░░░▒▓▒▒▒▒▒▓█▓█▓▓▓▓▒▒▒▒▒▒▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓██▓██▓▓▓▓▓▓███▓▓▓▓▓▓▓▒▓▓▒▒▓▒░░░░░░░░░░░░░░░░░░▒▓▓▓▓█▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓███▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓███▓▓▓█
▒░░░░░░░░░░▒▓▒▒▒▒▓▓██▓▓▓▒▒▒▒▒▒▒▓▓▓███▓▓▓▓▓▓▓▓▓▓▓██▓▓▓██▓▓▓▓▓▓███▓▓▓▓▓▓▒░░▓▓▒░░░░░░░░░░░░░░░░░░░▓▓▓▓█▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓███▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓███▓▓▓█
▒   ░░░░░░░░▓▓▒▒▒▓▓██▓▓▓▒▒▒▒▒▒▒▓▓▓███▓▓▓▓▓▓▓▓▓▓███▓▓▓▓██▓▓▓▓▓███▓▓▓▓▓▓▒░░▓▓▒░░░░░░░░░░░░░░░░░░▒▓▓▓██▓▓▓▓▒▒▒▒▓▓▓▓▓▓▓▓▓▓███▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓███▓▓▓█
▒░  ░░░░░░░░▒▓▓▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▓▓▓███▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓██▓▓▓▓████▓▓▓▓▓▓░░▒▒▒░░░░░░░░░░░░░░░░░░▒▓▓▓█▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓██████▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓███▓▓▓█
▒░  ░░░░░░░░░░▓▓▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓███▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓██▓▓▓▓▓███▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓███▓▓▓█
▒         ░░░░▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▓▓▓▓▓███▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓████▓▓▓███▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓███▓▓▓█
▒        ░░░░░░░▒▓▓▓▓▓▒▒▒▒▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓███████▓▓▓▓▓▒░░▒▓▓▓▓██▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████████████████████████▓███▓▓▓▓▓▓▓▓███▓▓█
▒        ░░░░░░░░▒▓▓▓▓▒▓▓▓▓▓▓███████▓▓▓▓▓▓▓▓▒▒▒▒▓▓▓███▒░░░░░░▓▓▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████████████████████████████████▓▓▓▓▓▓▓▓███▓▓█
▒         ░░░░░░░░▒▓▓▓▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓░░░░░▓▓▒░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓▒▒▒▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██████████████████████████████████▓▓▓▓▓▓▓▓███▓▓█
▒         ░░░░░░░░░▓▓▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓███████████████████████▓▓▓▓▓▓▓▓██████▓▓▓▓▓▓████▓█
▒         ░░░░░░░░░▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓███████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓▓▓▓███▓█
▒         ░░░░░░░░░▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒█▓████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓▓▓▓██▓█
▒         ░░░░░░░░▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓█████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓▓██▓█
▒         ░░░░░░░░▒▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▒▒▓▓▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓██▓█
▒         ░░░░░░░▒▓▓▓▓▓▓▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓███████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓██▓█
▒        ░░░░░░░░▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓███████▓▓▓█▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓███████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████
▒        ░░░░░░░░▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓█████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████
▒         ░░░░░░▒▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████
▒        ░░░░░░░▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓███▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▓▓██████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒        ░░░░░▒▓█▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▓███████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒         ░░░▒███▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓█████▓▓██▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▓▓▓███████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░░░░░░░░░░░▓███▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒▒▒▒▒▓▓▓█▓██████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░░░░░░░░░░▒███▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███
▒░░░░░░░░▒▓████▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓█▓▓▓▓▓▓▓▓▓██▒▒░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓███████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███
▒░░░░░░░░▓█████▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓░░░░░░░░░░▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓███████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░░░░░░▒▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓█▓▓▓▓▓▓▓███▓▓▒░░░░░░░░░░░▒▓▓▓█▓▓▓██▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓█████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░░░░░▒███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓██▓▓▓▓▓▒░░░░░░░░░░░▒▓▓▓▓█▓▓▓▓▓███▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓█████████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████
▒░░░▒▓████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓██▓▓▓▓▓▓▓▓░░░░░░░░░░░░▒▓▓▒▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓█████████████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░░▒██████████▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓█▓▓▓▓▓▓▒░░░░░░░░░░░░░░▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓██▓▓▓▓▒▒▒▒▓▓▓▓▓▓▓██▓████████████████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████
▒░▒▓█████████▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▒▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░▒▓▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░▒▓█▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓█████████████████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████
▒░███████████▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▓▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░▒▓▒▒▒▒▓▓▓▓▓▓▒▓▓▓▓▓▓▓▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓█▓▓▓█████████████████████████████████████████████████▓▓▓▓▓▓▓▓███████
▒▓██████████▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░▓▓▒▒▒▒▓▓▓▓▓▓▒▒▓▓▓▓▓▓▓▒░░░░░░▒███▓▓▓██▓▓▓█████████████████████████████████████████████████████████████████
▓███████████▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░▒▓▒▒▒▒▓▓▓▓▓▓▒▒▒▓▓▓▓▓▓▓▒░░░░░░░█████▓▓▓▓▓▓█████████████████████████████████████████████████████████████████
████████████▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▓▓▓▓▓▓▓▓░░░░░░▒▓▓▓▓▓▓▓▓▓▓██████████████████████████████████████████████████████████████████
████████████▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░▒▓▒▒▒▒▒▓▓▓▓▓▓▒▒▒▓▓▓▓▓▒▓▓░░░░░░▒▓▓▓▓▓▓▓▓▓▓██████████████████████████████████████████████████████████████████
████████████▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░▒▓▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▓▓▓▓▓▒▒▓░░░░░░▒▓▓▓▓▓▓▓▓▓███████████████████████████████████████████████████████████████████
████████████▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░▓▓▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▓▓▓▓▓▒▒▒▒░░░░░▒▓▓▓▓▓▓▓▓████████████████████████████████████████████████████████████████████
████████████▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░▓▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▓▓▓▓▓▒▒▒▒░░░░░▓▓▓▓▓▓▓▓▓████████████████████████████████████████████████████████████████████
████████████▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▓▓▓▓▓▒▒▒▒▒░░░▒▓▓▓▓▓▓▓▓█████████████████████████████████████████████████████████████████████
▒▓██████████▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓░░░░░░░ ░░░░░░░▒▓▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▓▓▓▒▒▒▒▓▒░░░▒▓▓▓▓▓▓▓██████████████████████████████████████████████████████████████████████
▒▒██████████▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▒░░░░░░░ ░░░░░░░▒▓▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▓▓▓▒▒▒▒▓▒░░░▒▓▓▓▓▓▓███████████████████████████████████████████████████████████████████████
▒░░▓████████▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒▓▓░░░░░░░  ░░░░░░░▓▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▓▓▓▒▒▒▒▒▒░░░▒▓▓▓▓▓▓▓██████████████████████████████████████████████████████████████████████
▒░░▒▓▓▓████▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒▓▒░░░░░░    ░░░░░░▓▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▓▒▒▒▒▒▒▓░░░▒▓▓▓▓▓▓▓▓█████████████████████████████████████████████████████████████████████
▒░▒▒░░░▒▓█▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒░░░ ░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▓▒▒▒▒▒▒▒▒░░▒▓▓▓▓▓▓▓▓▓████████████████████████████████████████████████████████████████████
▒░▒▒░░░░▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▓░░░  ░░░░░░░░░░░░▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▓▓▓▓▓▓▓▓▓▓███████████████████████████████████████████████████████████████████
▒░▒▒░▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒▒▒▒▒▓░░░          ░░░▒▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒▓▓▓▓▓▓▓▓▓████████████████████████████████████████████████████████████████████
▒░▓█████▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░░░          ░░░▒▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░▒▓▓▓▓▓▓▓▓▓██▓▓████████████████████████████████████████████████████████████████
▒▒█████▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░░░          ░░░▒▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒▒▓▓▓▓▓▓▓▓▓██▓▓████████████████████████████████████████████████████████████████
▓▒▓███▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░         ░░▒▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░▒▓▓▓▓▓▓▓▓██▓▓████████████████████████████████████████████████████████████████
*/
#include <bits/stdc++.h>

#define x first
#define y second
#define all(v) v.begin(), v.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> ii;

namespace my {
    ii operator+(const ii &a, const ii &b) {return {a.x + b.x, a.y + b.y};}
    ii operator-(const ii &a, const ii &b) {return {a.x - b.x, a.y - b.y};}
    ii operator*(const ii &a, const ii &b) {return {a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};}
    ii operator*(const ii &a, const int &b) {return {a.x * b, a.y * b};}
    ii operator/(const ii &a, const int &b) {return {a.x / b, a.y / b};}
    ostream& operator<<(ostream &s, const ii &p) {s << '(' << p.x << ", " << p.y << ')';return s;}
}

using namespace my;

int n, m, k;
map<int, int> G_c;

int G(const int &x) {
    if(G_c.count(x))
        return G_c[x];
    vector<int> mex;
    for(int i = 1;i * i <= x;i++) {
        if(x % i == 0 && i >= k && x / i > 1) {
            mex.push_back(G(i) * ((x / i) % 2));
        }
        if(x % i == 0 && x / i >= k && i > 1) {
            mex.push_back(G(x / i) * ((i) % 2));
        }
    }
    sort(all(mex));
    mex.erase(unique(all(mex)), mex.end());
    size_t p = 0;
    for(int i = 0;i < INT_MAX;i++) {
        if(p < mex.size() && mex[p] == i) {
            p++;
        } else {
            return (G_c[x] = i);
        }
    }
    assert(false);
}

void solve() {
    scanf("%d %d %d", &n, &m, &k);
    int result = G(m);
    printf("%s", (result && n % 2 == 1 ? "Timur" : "Marsel"));
}

int main() {
    if(ONLINE_JUDGE) { //usual problem
//        freopen("ants.in", "r", stdin);
//        freopen("ants.out", "w", stdout);
    } else {
        freopen("input.txt", "r", stdin);
    }
    solve();
    return 0;
}

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<iostream>
#include<fstream>
#include<iomanip>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<algorithm>
#include<set>
#include<sstream>
#include<stack>
#define maxim 100
#define LLD long long int
#define LLU long long unsigned
#define HD short int
#define HU short unsigned
#define pi acos(-1.0)
#define inf (1<<29)
#define CLR(a) memset(a,0,sizeof(a))
#define SET(a) memset(a,-1,sizeof(a))
#define pb push_back
#define sz(a) ((int)a.size())
#define all(a) a.begin(),a.end()
#define eps 1e-9
#define rep(i,init,n) for(i=init;i<n;i++)
#define rem(i,init,n) for(i=init;i>n;i--)
#define area(x1,y1,x2,y2,x3,y3) ( x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2) )
#define sqr(x) ((x)*(x))
#define distSqr(x1,y1,x2,y2) ( sqr(x1-x2) + sqr(y1-y2) )
#define spDist(lat1,long1,lat2,long2,r) ( r * acos( sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(long1-long2) ) )
#define isEq(a,b) (fabs(a-b)<eps)
#define STR string
#define LF double
#define IT iterator
#define VI vector<int>
#define VLLD vector<LLD>
#define VS vector<STR>
#define VLF vector<LF>
#define MII map<int,int>
#define MIB map<int,bool>
#define MSI map<STR,int>
#define MSB map<STR,bool>
#define MSS map<STR,STR>
#define M2dII map<int,map<int,int> >
#define QI queue<int>
#define SI stack<int>
#define PII pair< int, int >
#define PPI pair< PII, int >
#define ff first
#define ss second
#define VPII vector<PII>
#define MP make_pair

#define chk(a,k) ((bool)(a&(1<<(k))))
#define set0(a,k) (a&(~(1<<(k))))
#define set1(a,k) (a|(1<<(k)))

#define chkA(a,k) (bool)(a[(k)>>5] & (1<<((k)&31)))
#define setA0(a,k) (a[(k)>>5] &= ~(1<<((k)&31)))
#define setA1(a,k) (a[(k)>>5] |= (1<<((k)&31)))

#define SD(a) scanf("%d",&a)
#define SU(a) scanf("%u",&a)
#define SHD(a) scanf("%hd",&a)
#define SHU(a) scanf("%hu",&a)
#define SLLD(a) scanf("%lld",&a)
#define SLLU(a) scanf("%llu",&a)
#define SF(a) scanf("%f",&a)
#define SLF(a) scanf("%lf",&a)
#define SC(a) scanf("%c",&a)
#define SS(a) scanf("%s",a)

#define foreach(i, c) for( __typeof( (c).begin() ) i = (c).begin(); i != (c).end(); ++i )

int diru[] = {-1,-1,-1,0,0,1,1,1};
int dirv[] = {-1,0,1,-1,1,-1,0,1};

using namespace std;

template< class T > T sq(T n) { return n*n; }
template< class T > T gcd(T a, T b) { return (b != 0 ? gcd<T>(b, a%b) : a); }
template< class T > T lcm(T a, T b) { return (a / gcd<T>(a, b) * b); }
template< class T > bool inside(T a, T b, T c) { return a<=b && b<=c; }
template< class T > void setmax(T &a, T b) { if(a < b) a = b; }
template< class T > void setmin(T &a, T b) { if(b < a) a = b; }
template< class T > T power(T N,T P){  return (P==0)?  1: N*power(N,P-1); }

int n,m,k ;
/*
bool f[1010] ;

void gen()
{
    CLR(f) ;

    int i,j,c ;

    rep(i,k,1000)
    {
        if(f[i] == 0)
            for(j=i*2,c=2;j<1000;)
            {
                f[j] = 1 ;

                c++;
                j=i*c;
            }
    }
    rep(i,k,100)
    {
        if(f[i])        printf("%d win\n",i) ;
        else            printf("%d lose\n",i) ;
    }
}
*/

//int dp[1000000000/32+1] ;
//int isV[1000000000/32+1] ;

bool cal( int n )
{
    //if(chkA(isV,n))
    {
        //puts("sdadsds") ;
        //return chkA(dp,n) ;
    }

    bool ret = 0 ;

    int i,j,sq=(int)sqrt((LF)n) ;

    rep(i,1,sq+3)
    {
        if(n%i)       continue ;
        j = n/i ;

        if(i>=k && j>1)
        if(!cal(i) || !(j&1))
        {
            ret = 1 ;
            break ;
        }

        if(j>=k && i>1)
        if(!cal(j) || !(i&1))
        {
            ret = 1 ;
            break ;
        }
    }

    //isV[n] = 1 ;
    //setA1(isV,n) ;

    //if(ret)     setA1(dp,n) ;

    return ret ;
}

int main()
{
    int T,t=1,i,j;
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //scanf("%d",&T);
    //for(t=1;t<=T;t++)
    while(scanf("%d",&n)==1)
    {
        SD(m) ;
        SD(k) ;
        //gen() ;
        //rep(i,0,n)
            //scanf("%d",&m);
        if(!cal(m) || n%2==0)
                printf("Marsel\n");
        else    printf("Timur\n");
    }
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <map>
#include <string>
#include <algorithm>
#include <vector>
#include <string.h>
#include <set>
#include <algorithm>

using namespace std;

int opr (long long a,long long b)
{
	for (long long i=1;i*i<=a;i++)
	{
		if (a%i==0 && (a/i)>=b && (a/i)!=a && a>i) return i;
		if (a%i==0 && i>=b && a>i) return i;
	}
	return -1;
}
int main()
{
	long long n,m,k;
	cin>>n>>m>>k;
	if(n%2==0) {cout<<"Marsel";return 0;}
	else
	{
		if (opr(m,k)==-1) cout<<"Marsel"; else cout<<"Timur";
	}

  return 0;
}

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

int main() {

    int n, m, k;
    cin >> n >> m >> k;
    bool found = false;
    for(int i = 1; i * i <= m; i++) {
        if(m % i == 0) {
            if(i >= k) {
                found = true;
                break;
            }
            if(m / i >= k && i != 1) {
                found = true;
                break;
            }
        }
    }
    if (m == 1) {
		cout << "Marsel";
    } else if (found == false) {
		cout << "Marsel";
    } else if (n % 2 == 0) {
		cout << "Marsel";
	} else {
		cout << "Timur";
	}

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define M 1000000007
#define Fast ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
ll po(ll x,ll n)
{
    if(n==0)
        return 1;
    else if(n%2 == 0)
        return po((x*x)%M,n/2);
    else
        return (x*po((x*x)%M,(n-1)/2))%M;

}
ll GCD(ll A, ll B) {
    if(B==0)
        return A;
    else
        return GCD(B, A % B);
}
ll tree[1000001];
void update(int node, int start, int end, int idx, ll val)
{
    if(start == end)
    {
        // Leaf node
        tree[node] += val;
        tree[node]%=M;
    }
    else
    {
        int mid = (start + end) / 2;
        if(start <= idx and idx <= mid)
        {
            // If idx is in the left child, recurse on the left child
            update(2*node, start, mid, idx, val);
        }
        else
        {
            // if idx is in the right child, recurse on the right child
            update(2*node+1, mid+1, end, idx, val);
        }
        // Internal node will have the sum of both of its children
        tree[node] = (tree[2*node] + tree[2*node+1])%M;
    }
}
ll query(int node, int start, int end, int l, int r)
{
    if(r < start or end < l)
    {
        // range represented by a node is completely outside the given range
        return 0;
    }
    if(l <= start and end <= r)
    {
        // range represented by a node is completely inside the given range
        return tree[node];
    }
    // range represented by a node is partially inside and partially outside the given range
    int mid = (start + end) / 2;
    ll p1 = query(2*node, start, mid, l, r);
    ll p2 = query(2*node+1, mid+1, end, l, r);
    return (p1 + p2)%M;
}
int N=200000;
int main()
{
    Fast;
    int n,m,k;
    cin>>n>>m>>k;
    if(n%2==0)
    {
        cout<<"Marsel";
        return 0;
    }
    if(k==1 && m>1)
    {
        cout<<"Timur";
        return 0;
    }
    for(int i=2;i<=sqrt(m);++i)
    {
        if(m%i==0 && m/i>=k)
        {
            cout<<"Timur";
            return 0;
        }
    }
    cout<<"Marsel";
}

/*benamekhoda*/
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <math.h>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#define rep(i, n) for(LL i = 0; i < n; i++)
typedef long long LL;
using namespace std;

const LL N=1002014;
LL n, m, k;
map <LL, LL> mp;
vector <LL> kdiv;

LL solve(LL l)
{
    if (k == 1) return (1);
    if (mp[l]) return mp[l];
    LL winner = 0;
    rep(i, kdiv.size())
        if (l % kdiv[i] == 0 && l / kdiv[i] >= k && !solve(l / kdiv[i]))
            winner = 1;
    return mp[l] = winner;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin >> n >> m >> k;
    if (m == 1) {cout << "Marsel"; return 0;}
    for (LL i = 2; i <= sqrt(m) + 2; i++)
        if (m % i == 0)
            kdiv.push_back(i);
    LL winner = solve(m);
    if (winner && n % 2 == 1)
        cout << "Timur"; else cout << "Marsel";
    return 0;
}

#undef __USE_MINGW_ANSI_STDIO
#define __USE_MINGW_ANSI_STDIO    1

#include <functional>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <complex>
#include <numeric>
#include <cstring>
#include <vector>
#include <string>
#include <cstdio>
#include <queue>
#include <cmath>
#include <map>
#include <set>

using namespace std;

#define all(a)		(a).begin(), (a).end()

typedef long long int64;

void answer(bool first) {
	puts(first ? "Timur" : "Marsel");
	exit(0);
}

vector<int> d;
map<int, int> f;
int n, m, k;

bool go(int n) {
	if (f.count(n)) return f[n];
	bool res = false;
	for (int x : d)
		if (x >= k && x < n) {
			if ((n / x) % 2 == 0 || !go(x)) {
				res = true;
				break;
			}
		}
	f[n] = res;
	return res;
}

int main(){
	#ifdef LocalHost
	freopen("x.in", "r", stdin);
	freopen("x.out", "w", stdout);
	#endif
	cin >> n >> m >> k;
	if (n % 2 == 0) answer(false);
	for (int x = 1; x * x <= m; ++x) {
		if (m % x == 0) {
			d.push_back(x);
			if (x * x != m) d.push_back(m / x);
		}
	}
	sort(all(d));
	answer(go(m));
	return 0;
}

#include<iostream>
#include<vector>
#include<cmath>
#include<map>
#include<vector>
#include<sstream>
#include<cstring>
#include<cstdio>
#include<cassert>
#include<set>
#include<list>
#include<algorithm>
using namespace std;
typedef long long Long;

typedef pair<int,int> PII;

int K;
map<int,int> MEM;
int G(int n)
{
    if(n == 1)return 0;
    set<int> S;
    if(MEM.count(n))return MEM[n];
    for(int i = 1; i*i <= n; ++i)
    {
        if(n%i != 0)continue;
        if(n/i < K)break;

        if(i!= 1 && n/i >= K)
        {
            if(i%2 == 0)S.insert(0);
            else S.insert(G(n/i));
        }
        if(i >= K)
        {
            if((n/i)%2 == 0)S.insert(0);
            else S.insert(G(i));
        }
    }
    int k = 0;
    while(S.count(k))k++;
    return MEM[n] = k;
}

int main()
{
    int N,M;
    cin >> N >> M >> K;
    cout << (N%2!=0 && G(M) ? "Timur" : "Marsel") << endl;

    return 0;
}

 #include <cstdio>
 #include <cassert>
 #include <vector>
 #include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<map>
#include<list>
#include<queue>
#include<utility>
#include<sstream>
#include<cstdlib>
#include<cctype>
#include<math.h>
#include<set>
#include<stack>
#include<fstream>
#include<numeric>
#include<string>
#include<vector>
#include<iterator>
using namespace std;
int k;
map<int,int>name,dp;
int dp_func(int val)
{
    if(name[val]!=0)return dp[val];
    set<int>s;
    int m,l;
    for(int i=1;i<=sqrt(val);i++){
        if((val%i)==0){
            m=val/i;

            if(m>=k&&i>1){
           l=dp_func(m);
           if(l==0||i%2==0)s.insert(0);
           else s.insert(l);
        }
        if(i>=k&&m>1){
            l=dp_func(i);
            if(l==0||m%2==0)s.insert(0);
            else s.insert(l);
        }

    }
    }
    name[val]=1;
    int ans=0;
    while(s.find(ans)!=s.end())ans++;
    return dp[val]=ans;
}
int main()
{
    int i,j,l,m,n;
    cin>>n>>m>>k;
    m=dp_func(m);
    if(m==0||n%2==0)printf("Marsel\n");
    else printf("Timur\n");
}

#include<bits/stdc++.h>
using namespace std;
//#define ll long long int;
bool isprime(int n){
	if(n==1){
		false;
	}
	for(int i=2;i<=sqrt(n);i++){
		if(n%i==0) return false;
	}
	return true;
}
int main(){
	int n,m,k;
	cin>>n>>m>>k;
	if(m==1){
		cout<<"Marsel"<<'\n';return 0;
	}
	if(n%2==0){
		cout<<"Marsel"<<'\n';
	}
	else{
			//long long int sum=1,l=0;
			for(int i=2;i<=sqrt(m);i++){
				if(m%i==0){
					if(m/i>=k||i>=k){
						cout<<"Timur"<<'\n';return 0;
					}
				}
			}
			if(k==1){
				cout<<"Timur"<<'\n';return 0;
			}
			cout<<"Marsel"<<'\n';
	}
}

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <limits.h>

using namespace std;

int main( void )
{
    int n, m, k;

    //freopen( "input.txt", "r", stdin );
    //freopen( "output.txt", "w", stdout );

    cin >> n >> m >> k;

    if( !(n % 2) || m <= k )
        cout << "Marsel";
    else
    {
        for( int i = 1; i*i <= m; i++ )
        {
            if( m % i == 0 && ( i >= k || (m/i >= k && m/i != m ) ) )
            {
                cout << "Timur";
                return 0;
            }
        }
        cout << "Marsel";
    }

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int k,n,m,l,r;
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	if(!(n&1))
		printf("Marsel"),exit(0);
	l=sqrt(m);
	for(register int i=1;i<=l;i++)
	{
		if(m%i)
			continue;
		r=m/i;
		if(((i>=k)&&(r>1))||(i>1)&&(r>=k))
		printf("Timur"),exit(0);
	}
	printf("Marsel");
	return 0;
}

#include <cstdlib>
#include <cmath>

#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
using namespace std;

//#define LOCAL

#ifdef LOCAL
#include <fstream>
ifstream cin("input.txt");
ofstream cout("output.txt");
#else
#include <iostream>
#endif

int n, m, k;

int main() {
	ios_base::sync_with_stdio(false);
	cin >> n >> m >> k;
	if (n % 2 == 0) {
		cout << "Marsel" << endl;
		return 0;
	}
	for (int i = 1; i * i <= m; ++i)
		if (m % i == 0 && (i != 1 && m / i >= k || i != m && i >= k)) {
			cout << "Timur" << endl;
			return 0;
		}
	cout << "Marsel" << endl;
	return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<iterator>
#include<climits>
#include<functional>
#include<iomanip>
using namespace std;
#define   MP             make_pair
#define   PB             push_back
#define   endl           '\n'
#define   IOS            ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define   int            long long
#define   LL             long long

const int MOD=1e9+7,Base=998244353;
const int N=1e5+7;
const int INF=1LL*1000*1000*1000*1000*1000*1000+7LL;
const double pie=acos(-1.0);

int n, m, k ;

int32_t main()
{
    IOS

    cin>>n>>m>>k ;

    bool Divisible =false ;

    if(k==1)Divisible=true ;

    for(int i=2;i*i<=m;++i)
    {
        if(i>=k||m/i>=k)
        {
            if(m%i==0)Divisible=true ;
        }
    }

    if(2*k>m || !Divisible)
    {
        cout<<"Marsel\n" ;
        return 0 ;
    }

    if(n&1)
        cout<<"Timur\n";
    else
        cout<<"Marsel\n";

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

vector<int> divs(int x) {
    vector<int> A;
    for(int i = 1; i * i <= x; i++) {
        if(x % i == 0) {
            A.push_back(i);
            if(i != x / i) A.push_back(x / i);
        }
    }
    return A;
}

map<int, int> memo;

int grundy(int state, int k) {
    if(memo.count(state)) return memo[state];
    set<int> my_set;
    vector<int> A = divs(state);
    for(int i : A) {
        if(i == 1) continue;
        if((state / i) < k) continue;
        my_set.insert( (i % 2) ? grundy((state / i), k) : 0);
    }
    int mex = 0;
    while(my_set.count(mex)) mex++;
    return memo[state] = mex;
}

int main () {
    int n, m, k;
    cin >> n >> m >> k;
    int res = (n % 2) ? grundy(m, k) : 0;
    cout << (res == 0 ? "Marsel" : "Timur") << endl;
}

#include <bits/stdc++.h>

using namespace std;
int *factor(int temp , int &a)
{
    int *arr = new int[1000000];
    int sqrot = sqrt(temp);
    for(int i = 2; i <= sqrot; i++)
    {
        if(temp%i==0){
            arr[a++] = i;
            arr[a++] = temp/i;
        }
    }
    arr[a++] = temp;
    sort(arr,arr+a);
    return arr;
}
int main()
{
    int64_t n,l,k , c = 0,temp;
    cin >> n >> l >> k; temp=l;
    while(k!=temp)
    {
        bool b = 0;
        int *arr = new int[1000000];
        int a = 0;
        arr = factor(temp,a);
        reverse(arr,arr+a);
        for(int i = 0; i < a; i++)
        {
            if(temp/arr[i] >= k)
            {
                b = 1;
                temp /= arr[i];
                break;
            }
        }
        if(b)
        {
            c++;
        }
        else break;
    }
    if((n*c)%2==0)
        cout << "Marsel";
    else
        cout << "Timur\n";
}

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
int a[100000],kolv=0;
int main ()
{
	int n,m,k;
	cin>>n>>m>>k;
	if(n%2==0)
	{
		printf("Marsel");
		return 0;
	}
	for(int i=1;i*i<=m;i++)
	{
		if(i*i!=m)
		{
			if(m%i==0)
			{
				a[kolv]=i;
				a[kolv+1]=m/i;
				kolv+=2;
			}
		}
		else
		{
			a[kolv]=i;
			kolv++;
		}
	}
	sort(a,a+kolv);
	reverse(a,a+kolv);
	if(a[1]>=k)
		printf("Timur");
	else
		printf("Marsel");
	return 0;
}

#include<cstdio>
using namespace std;
int main(){
    char name[2][10]={"Timur", "Marsel"};
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    bool f=false;
    for(int t=2;t*t<=m;t++)if(m%t==0 && (m/t>=k || t>=k)){f=true;break;}
    if(k==1) f=true;
    if(m==1) f=false;
    if(n%2){
        if(f) puts(name[0]);
        else puts(name[1]);
    }else {
        puts(name[1]);
    }
}

#include <stdio.h>
#include <math.h>
int main(){
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    if (n%2==0) printf("Marsel");
    else{
        for (int i=1; i<=sqrt(m); i++)
            if ((m%i==0) && ((i>=k && m/i>1) || (m/i>=k && i>1))){
                printf("Timur");
                return 0;
            }
        printf("Marsel");
    }
    return 0;
}

#include <stdio.h>
#include <iostream>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <math.h>
#include <algorithm>

using namespace std;

#define file "cooling"
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;

const int MAXN = 1e5+100;
const double EPS = 1e-9;
const ll INF = 1000000000+5;

int n,m,k;
map<pii,int> list;

int main()
{
	//freopen(file".in","r",stdin); freopen(file".out","w",stdout);
	#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	#endif

	cin>>n>>m>>k;

	int ans = 0;
	for(int i=1;i*i<=m;i++)
	{
		if(m%i==0)
		{
			if(i>=k && m/i>1) ans = 1;
			if(i>1 && m/i>=k) ans = 1;
		}
	}

	if(n%2==0) ans = 0;

	if(ans) printf("Timur");
	else printf("Marsel");
	return 0;
}

#include <iostream>
using namespace std;

int n,m,k;

bool unable_first()
{

  int i;

  for(i=2;i*i<=m;i++)
  {

      if(m%i==0 && m/i>=k)
        return false;
  }

  if(k==1 && m>1)
    return false;

  return true;
}

int main()
{

   int i;

   cin>>n>>m>>k;

   if(n%2==0)
   {
     cout<<"Marsel"<<endl;
     return 0;
   }

   if(unable_first())
   {
       cout<<"Marsel"<<endl;
       return 0;
   }

   cout<<"Timur"<<endl;

   return 0;
}

#include <bits/stdc++.h>
#define max4 10004
#define maxx 100005
#define max6 1000006
#define oo 2000000000
#define mod 1000000007
#define pii pair<int,int>
#define piii pair<pii,pii>
#define pli pair<ll,int>
#define pll pair<ll,ll>
#define pid pair<int, double>
#define plll pair<ll,pll>
#define f first
#define s second
#define in(x) scanf("%d",&x)
#define IN(x) scanf("%I64d",&x)
#define inch(x) scanf("%s",x)
#define indo(x) scanf("%lf",&x)
#define outn(x) printf("%d\n",x)
#define OUTN(x) printf("%I64d\n",x)
#define out(x) printf("%d ",x)
#define OUT(x) printf("%I64d ",x)
#define pb push_back

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

using namespace std;

int n, m, k;
int main()
{
    in(n); in(m); in(k);
    if((n & 1) == 0){
        puts("Marsel");
    }else{
        for(int i = 1; i * i <= m; i++){
            if(m % i == 0){
                if(i > 1 && m / i >= k){
                    puts("Timur");
                    return 0;
                }
                if(m / i > 1 && i >= k){
                    puts("Timur");
                    return 0;
                }
            }
        }
        puts("Marsel");
    }
    return 0;
}

#include <iostream>
#include<cstdio>
#include<string.h>
#include<cmath>
using namespace std;

int n , m , k ;

bool divable( int d ){
    int t = sqrt( d ) ;
    for( int i = 2 ; i <= t ; i ++ ){
        if( d % i == 0 ){
            if( i >= k || d / i >= k ){
                return 1 ;
            }
        }
    }
    return 0 ;
}

int main()
{

    while( scanf( "%d%d%d" , &n , &m , &k )!= EOF ){
        if( n % 2 == 0 ){
            printf( "Marsel\n" ) ;
            continue ;
        }
        int t = sqrt( m ) ;
        int flag = 0 ;
        for( int i = 1 ; i <= t  ; i ++ ){
            if( m % i == 0 ){
                if( i >= k && m / i > 1 && !divable(i)){
                    flag = 1;
                    break ;
                }
                if( i > 1 && m / i >= k && !divable( m / i ) ){
                    flag = 1 ;
                    break ;
                }
            }
        }
        if( flag == 0 ){
            printf( "Marsel\n" ) ;
        }
        else{
            printf( "Timur\n" ) ;
        }
    }
    return 0;
}

#include<bits/stdc++.h>

using namespace std;

int main ()
{
   long long n, m, k;
    cin >> n >> m >> k;
    int b = 0;
    if(n % 10 % 2 == 0)
    {
        cout << "Marsel";
    return 0;
    }
    if(m == k)
    {
        cout << "Marsel";
    return 0;
    }
        if(k == 1)
    {
        cout << "Timur";
        return 0;
    }
    for(int i = 2; i <= sqrt(m) + 1; i ++)
    {
        if(m % i == 0 && m / i >= k)
        {
            cout << "Timur";
        return 0;
        }
    }
    /*while(true)
    {
        for(int i = (m / 2) + 1; i >= k; i --)
        {
            if(m % i == 0 && m / i >= k)
            {
                m /= k;
                b ++;
                break;
            }
        }
            break;
    }
    b = (b % 10) * (n % 10);
    if(b % 2 == 0)
        cout << "Marsel";
    else cout << "Timur";*/
    cout << "Marsel";
return 0;
}

//God & me
/*
    #   #####  TM    #   ###       ####   ####    #####      #     #######  #####     #   #
  # #      #         #  #         #       #   #   #         # #       #     #         #   #
    #     #          #   ##       #  ##   ####    #####    #####      #     #####     #   #
    #    #           #     #      #   #   #   #   #       #     #     #     #
  ####  #            #  ###        ####   #    #  #####  #       #    #     #####     #   #
  D-And his name is joon sina
*/
#include <bits/stdc++.h>
#define pb push_back
#define X first
#define Y second
#define int long long
#define in(a,n) for_each(a,a+n,[](int &x){cin>>x;})
using namespace std;
/*<===LINE==#17#===>*/
template <class T,class L> T& smax(T &x,L y){if(y>x)x=y;return x;}
template <class T,class L> T& smin(T &x,L y){if(y<x)x=y;return x;}
typedef pair<int,int> pii;
const int maxn=2e2+17,maxm=17;
int a,n,k;
main(){
  ios::sync_with_stdio(0),cin.tie(0);
  cin>>n>>a>>k;
  if(n%2==0)
    return cout<<"Marsel\n",0;
  for(int i=1;i*i<=a;i++)
    if(a%i==0)
      if(i!=1 && a/i>=k)
	return cout<<"Timur\n",0;
      else if(i>=k && a/i!=1)
	return cout<<"Timur\n",0;
  cout<<"Marsel\n";
  return 0;
}

#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <complex>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstring>
#define REP(i,x) for(int i = 0 ; i < (int)(x) ; i++)
#define ALL(x) (x).begin(),(x).end()
#define LL long long
using namespace std;

int main(){
    int N,M,K;
    while(cin>>N>>M>>K){
        bool t = false;
        for(int i=1 ; i*i<=M ; i++){
            if(M%i==0){
                int a = i,b = M/i;
                if(N%2==1 && a>1 && b>=K)t = true;
                swap(a,b);
                if(N%2==1 && a>1 && b>=K)t = true;
            }
        }
        cout << (t?"Timur":"Marsel") << endl;
    }
    return 0;
}

#include <bits/stdc++.h>

typedef long long ll;
using namespace std;

#define all(x) x.begin(), x.end()
#define f(i,a,b) for(int i = (a); i <= (b); i++)
#define fd(i,a,b) for(int i = (a); i >= (b); i--)
#define mp make_pair
#define faster_io() ios_base::sync_with_stdio(false)
#define pb push_back
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
#define vii vector<pair<int,int>>

const int INF = 1000000002;
const ll INFLL = 100000000000000000ll;
const ll MOD = 1000000007;

// ----------------------------------------------------------------------------------------------------------

int N, H, K;
unordered_map<int,int> grun;

int grundy(int n)
{
    if(grun.find(n) != grun.end()) return grun[n];
    unordered_set<int> can;

    for(ll i = 2; i*i <= n; i++) if(n%i == 0)
    {
        int sz = n/i;
        if(sz < K) continue;
        if(i%2 == 0) can.insert(0);
        else can.insert(grundy(sz));
    }

    f(i,0,10000) if(can.find(i) == can.end()) return grun[n] = i;
}

int main()
{
    cin >> N >> H >> K;
    if(N%2 == 0)
    {
        cout << "Marsel";
        return 0;
    }
    if((K == 1 && H>1) || grundy(H)) cout << "Timur";
    else cout << "Marsel";
}

#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <set>
#include <map>
#include <vector>
#include <complex>

using namespace std;
typedef complex<double> P;

#define EPS (1e-10)
#define EQ(a,b) (abs((a)-(b)) < EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
long m,k,f;
int check(long s){

 for(long i=1;i*i<=m;i++)
    if(m%i==0){
      if(i>=k&&i<s){f++;check(i);}
      if((m/i)>=k&&(m/i)<s){f++;check(m/i);};
    }

 if(f%2)return 1;
 else return 0;
}

int main(){

  long  n,insu,flag=0;
  //vector<long> num;
  cin>>n>>m>>k;
  for(long i=2;i*i<=m&&!flag;i++){
    if(m%i==0){ f=0;
      if(i>=k)flag=1;
      if((m/i)>=k)flag=1;
    }
  }
  if(m<=k){ cout<<"Marsel";return 0;}
  if( ((flag||k==1)&&n%2)||m==1||(n%2&&k==1))
    cout<<"Timur";
  else cout<<"Marsel";

  return 0;
}

#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <set>
#include <map>
#include <vector>
#include <complex>

using namespace std;
typedef complex<double> P;

#define EPS (1e-10)
#define EQ(a,b) (abs((a)-(b)) < EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
long m,k,f;
int check(long s){

 for(long i=1;i*i<=m;i++)
    if(m%i==0){
      if(i>=k&&i<s){f++;check(i);}
      if((m/i)>=k&&(m/i)<s){f++;check(m/i);};
    }

 if(f%2)return 1;
 else return 0;
}

int main(){

  long  n,insu,flag=0;
  //vector<long> num;
  cin>>n>>m>>k;
  for(long i=2;i*i<=m&&!flag;i++){
    if(m%i==0){ f=0;
      if(i>=k)flag=1;
      if((m/i)>=k)flag=1;
    }
  }
  if(m<=k){ cout<<"Marsel";return 0;}
  if( ((flag||k==1)&&n%2)||m==1)
    cout<<"Timur";
  else cout<<"Marsel";

  return 0;
}

#include <iostream>
#include <sstream>

#include <cstdio>
 #include <cstdlib>
#include <cmath>
 #include <cctype>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX = 10000;
int Div[MAX], dl;

void findDiv(int n) {
   int i, j, k;
   dl = 0;
   for(i=1; i*i<=n; i++) {
      if(n%i == 0) {
         if(i*i != n) {
              Div[dl++] = i;
             Div[dl++] = n/i;
           }
           else Div[dl++] = i;
       }
    }
 }

int upper_boundary(int val, int n) {
   int lo = 0, hi = n-1, mid;
   while(lo <= hi) {
       mid = (lo + hi)/2;
      if(Div[mid] > val) {
           if(Div[mid-1] <= val)
             return mid;
           hi = mid - 1;
       }
        else lo = mid + 1;
    }
    return mid;
 }

int main() {

 int i, j, k;
   int test, t = 0;
    int n, m, mn;
     int ub, lb;

   while(scanf("%d %d %d", &n, &m, &mn)==3) {
       findDiv(m);
        sort(Div, Div+dl);
        //for(i=0; i<dl; i++) printf("%d ", Div[i]); printf("\n");
       ub = upper_boundary(mn, dl);
       //lb = lower_boundary(mn, dl);
        //printf("%d %d\n", Div[lb], Div[ub]);
        if(Div[ub-1] == mn) ub--;
       //printf("%d\n", Div[ub]);
       if(Div[ub] == m) printf("Marsel\n");
       else if(n%2) printf("Timur\n");
      else printf("Marsel\n");
    }
   return 0;
}

#include <bits/stdc++.h>
using namespace std;

int n, m, k;
int i(){
    int i;
    for (i=1;(long long)i*i<=m;i++)
        if (((m/i>=k&&i!=1)||i>=k) && (m%i==0) &&(i<m))
            return 0;

    return 1;
}

int main()
{   scanf("%d %d %d", &n, &m, &k);
    if(n%2==0)puts("Marsel");
    else{
        if(i())puts("Marsel");
        else puts("Timur");
    }

    return 0;

}

#include <bits/stdc++.h>
using namespace std;
long long ans[50] ;
int main()
{
    int n , m , k ;
    cin >> n >> m >> k ;
    if(n%2 == 0 || m <= k){
        return cout << "Marsel" , 0 ;
    }
    if(k == 1){
        if(m == 1)return cout << "Marsel" , 0 ;
        else return cout << "Timur" , 0 ;
    }
    bool flag = false ;
    for(int i = 2 ;i <= (int)sqrt(m) + 1 ; i++){
        if(m%i==0&&m/i >= k){flag = true ;break;}
    }
    if(flag == false)cout << "Marsel" , 0 ;
    else {
        cout << "Timur" ;
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

int n,m,k;

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n>>m>>k;
    if(n%2==0){
        return cout<<"Marsel",0;
    }
    if(m>1 && k==1){
        return cout<<"Timur",0;
    }
    for(int i=2;i*i<=m;i++){
        if(m%i==0){
            if(k<=i || k<=m/i){
                return cout<<"Timur",0;
            }
        }
    }
    cout<<"Marsel";
}

#include<iostream>
#include<algorithm>
#include<vector>
#define fr(a,b,c) for (a=b;a<=c;a++)
using namespace std;
int k,m,n;
vector <int> a,b;

int main()
{
    int i,j;
    cin >> n >> m >> k;
    a.clear();
    fr(i,1,m)
      if (1LL*i*i>m) break;
      else
      {
         if (m%i==0)
         {
            if (i>=k) a.push_back(i);
            if (m/i>=k && m/i!=i) a.push_back(m/i);
         }
      }
    if (!a.empty())
    {
      sort(a.begin(),a.end());
      fr(i,0,a.size()-1)
      {
         b.push_back(-1);
         fr(j,0,i-1)
           if (a[i]%a[j]==0)
           {
              int x=a[i]/a[j];
              if (b[j]<0)
              {
                 b[i]=1; break;
              }
              if (b[j]^(x%2))
              {
                 b[i]=1; break;
              }
              b[i]=0;
           }
      }
      i--;
    }
    if (!a.empty() && b[i]>=0 && (b[i]^(n%2==0))) cout << "Timur" << endl;
    else cout << "Marsel" << endl;
    //system("pause");
    return 0;
}

//  main.cpp
//  Created by Omar Shawky
#include<set>
#include<map>
#include<list>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<complex>
#include<sstream>
#include<iostream>
#include<fstream>
#include<algorithm>
#include<numeric>
#include<utility>
#include<functional>
#include<stdio.h>
#include<assert.h>
#include<memory.h>
#include<bitset>
#include<math.h>

#define f first
#define s second
#define pb push_back
#define lp(i,a,n) for(int (i)=(a);i<=(int)(n);(i)++)
#define lpb(i,a,n) for(int (i)=(a);i>=(int)(n);(i)--)
#define mp make_pair
#define clr(a) memset(a,-1,sizeof a)
#define sz(x) ((int)(x).size())
#define all(v) v.begin(),v.end()
#define mod 1000000007
#define infi 1e9
#define infll 1e16
#define readi(x) scanf("%d",&x)
#define read2i(x,y) scanf("%d%d",&x,&y)
#define close exit(0)
#define sqr(x)  (x*x);
#define readll(x) scanf("%I64d",&x)
#define read2ll(x,y) scanf("%I64d%I64d",&x,&y)
#define printi(x) printf("%d",x)
#define printll(x) printf("%I64d",x)

#define eps 1e-9
#define EQ(a,b) (fabs((a) - (b)) <= eps) /* equal to */
#define NE(a,b) (fabs((a) - (b)) > eps)  /* not equal to */
#define LT(a,b) ((a) < (b) - eps)        /* less than */
#define GT(a,b) ((a) > (b) + eps)        /* greater than */
#define LE(a,b) ((a) <= (b) + eps)       /* less than or equal to */
#define GE(a,b) ((a) >= (b) - eps)       /* greater than or equal to */

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double,double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef set<int> si;
typedef map<int, int> mii;
int dcmp(double x, double y){return EQ(x,y) ? 0 : LT(x,y) ? -1 : 1;}

/*==========================================================================*/
int n,m,k;
map<int,bool> v;
bool solve(int cnt,int len){
    if(v.find(len) != v.end())return v[len];
    bool ret = false;
    bool entered = false;
    vi divisors;
    for(int i = 2 ;i*i<=len; ++i)if(len % i == 0)if(len/i >= k)divisors.pb(len/i),entered = true;
    lp(i,0,sz(divisors)-1)ret |= !solve(len/divisors[i],divisors[i]);
    if(cnt % 2 == 0 && entered)ret = !ret;
    v.insert(mp(len,ret));
    return  ret;
}

int main(void)
{
    read2i(n,m);
    readi(k);
    if(m == 1)return cout<<"Marsel",0;
    if(k == 1)
       if(n%2 == 0) return cout<<"Marsel",0;
       else  return cout<<"Timur",0;
    if(solve(n,m))cout<<"Timur";
    else cout<<"Marsel";

}

#include <stdlib.h>
#include <time.h>
#include <vector>
#include <math.h>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <map>
#include <stack>
#include <queue>
#include <utility>

using namespace std;

const int M=100000+10;
typedef long long int ll;

int main()
{
	//freopen("input.txt","r",stdin);
	//freopen("output.txt","w",stdout);

	int n,m,k;
	cin>>n>>m>>k;

	if (n%2==0)
	{
		cout<<"Marsel"<<endl;
	}
	else
	{
		vector<int> factor;
		for (int fac=1; fac*fac<=m; fac++)
		{
			if (m%fac==0)
			{
				factor.push_back(fac);
				if (m/fac!=fac)
				{
					factor.push_back(m/fac);
				}
			}

		}

		sort(factor.begin(), factor.end());
		reverse(factor.begin(), factor.end());
		int F=1;
		for (int i=0; i<factor.size(); i++)
		{
			if (factor[i]<=m/k)
			{
				F=factor[i];
				break;
			}
		}
		if (F==1)
		{
			cout<<"Marsel"<<endl;
		}
		else
		{
			cout<<"Timur"<<endl;
		}
	}

	return 0;

}

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>

using namespace std;

int main()
{
    int n,m,k;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        int flag=0;
        for(int i=1;i<=sqrt(m);i++)
        {
            if(m%i==0&&((i>=k&&i!=m)||((m/i)>=k&&(m/i!=m))))
            {
                //cout<<i<<endl;
                flag=1;
                break;
            }
        }
        //cout<<flag<<endl;
        if(flag==1&&n%2!=0)
        {
            printf("Timur\n");
        }
        else
        {
            printf("Marsel\n");
        }
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <algorithm>
using namespace std;

#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define clr(a, b) memset(a, b, sizeof(a))
#define SZ(a) ((int)a.size())
#define MP make_pair
#define PB push_back
#define inf 0x3f3f3f3f
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;

namespace acm {

int n, m, k;
void icpc() {
	scanf("%d%d%d", &n, &m, &k);
	bool chk = 0;
	for(int i = 2; i * i <= m; i++){
		if(m % i == 0 && m / i >= k) {chk = 1; break;}
	}
	if(k == 1 && m > 1) chk = 1;
	if(chk && (n & 1)) puts("Timur");
	else puts("Marsel");
}

}

int main() {
#ifdef Ecust
	freopen("dat.in", "r", stdin);
#endif
	acm::icpc();
	return 0;
}

#include<bits/stdc++.h>
using namespace std;

#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vpii vector<pair<int,int>>
#define vpll vector<pair<ll,ll>>
#define fr(i,k,n) for (int i = k; i < n; ++i)
#define fri(i,k,n) for (int i = k; i >= n; --i)
#define pb push_back
#define mp make_pair
#define all(arr) arr.begin(),arr.end()
#define ff first
#define ss second

const double pi=3.1415926535897932384626433832795;
const int inf=1e9;
const ll inf2=1e18;
const int mod=1e9+7;

void boost(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
}

void solve(){
    int n,m,k;
    cin>>n>>m>>k;
    if(n%2==0){
        cout<<"Marsel"<<endl;
        return;
    }
    ll j;
    ll ans=mod;
    for(ll i=1;i*i<=m;i++){
        if(m%i==0){
            if(i!=m && i>=k)
            ans=min(ans,i);
            j=m/i;
            if(j!=m && j>=k)
                ans=min(ans,j);
        }
    }
    if(ans!=mod){
        cout<<"Timur"<<endl;
    }
    else{
        cout<<"Marsel"<<endl;
    }
    return;
}

int main()
{
    boost();

    int tc=1;
    //cin>>tc;
    while(tc--)
        solve();
    return 0;
}

#include"bits/stdc++.h"
using namespace std;

int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    if(n % 2 == 0){
        cout << "Marsel" << endl;
    }
    else{
        if(m % 2 == 0){
            if(m / 2 >= k){
                cout << "Timur" << endl;
            }
            else{
                cout << "Marsel" << endl;
            }
        }
        else{
            int flag = 0;
            for(int i = k; i <= m / 3; i ++){
                if(m % i == 0){
                    cout << "Timur" << endl;
                    flag = 1;
                    break;
                }
            }
            if(flag == 0){
                cout << "Marsel" << endl;
            }
        }
    }
    return 0;
}

#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<vector>
#include<algorithm>
using namespace std;
map<int,int>sg,vst;
int k;
int f(int n)
{
  if(k==1)
    return 1;
  for(int i=2;i<=(int)sqrt(n);i++)if(n%i==0)
    if(i>=k||n/i>=k)
      return 1;
  return 0;
}
int main()
{
  int n,m;
  sg.clear();vst.clear();
  sg[1]=0;
  vst[1]=1;
  scanf("%d%d%d",&n,&m,&k);
  if(m>1&&n%2&&f(m))
    printf("Timur\n");
  else
    printf("Marsel\n");
  return 0;
}

using namespace std;
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cassert>
#include<cstring>

typedef long double D; typedef long long LL;
typedef vector<int> VI; typedef vector<VI> VVI;
typedef vector<bool> VB; typedef vector<VB> VVB;
typedef pair<int,int> pii; typedef vector<pii> VII;
#define IA(v) (v).begin()
#define IB(v) (v).end()
#define ALL(v) IA(v),IB(v)
#define REP(i, n) for (int i (0); i < (n); i ++)
#define FORIT(a,b, it) for(__typeof(b)it(a);it!=(b);++it)
#define FOREACH(v, it) FORIT(IA(v),IB(v),it)
#define len(v) ((int)(v).size())
#define append push_back
#define _ make_pair
#define fi first
#define se second
#define add insert
#define remove erase
const int inf (1010101010);

/*
equiv:
als n even dan wint B (kopieer strategie).
als je een even aantal stukken over laat dan kan de tegenstander kopieren dus equivalent is:

kies steeds een oneven deler d (d > 1) zodat n/d >= k en set n := d.
*/
int k;
bool wins(int);
void try_div(int n, int d, bool & re)
{
	if (n % d == 0) if (n / d >= k)
	{
		if (d % 2 == 1) re=true;
		if (d % 2 == 0) re=true;
	}
}
bool wins(int n)
{
	for (int d (1); d * d <= (n); d ++) if (n % d == 0)
	{
		bool re (false);
		if (d > 1) try_div(n, d, re);
		if (d < n) try_div(n, n / d, re);
		if (re) return true;
	}
	return false;
}

main()
{
	int n,m;cin>>n>>m>>k;
	if(n%2==0){puts("Marsel");return 0;}
	puts(wins(m)?"Timur":"Marsel");
}

# include <bits/stdc++.h>
using namespace std;

int n, m, k;

bool jd(int x) {return k<=x&&x<m;}

bool chk() {
    for (int i = 1; i*i <= m; ++i) {
        if (m%i == 0) {
            if (jd(i) || jd(m/i)) {
                return true;
            }
        }
    }
    return false;
}

int main()
{
    cin >> n >> m >> k;

    if (n%2 == 0 || !chk()) cout << "Marsel" << endl;
    else cout << "Timur" << endl;

    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
const int N = 103;
const int mod = 1e9+7;
#define snuke(it, x) \
for(__typeof((x).begin()) it = (x).begin(); \
it != (x).end(); it++)
map<int, int > dp;
int n, m, k;
int dfs(int u) {
	if(dp.count(u)) return dp[u];
	int i;
	int ret = 0;
	map <int, bool> vis;
	for(i = 1; i*i <= u; i++) if(u%i==0) {
		int t = u/i;
		if(t >= k && i>1) {
			if(i&1) vis[dfs(t)] = 1;
			else vis[0] = 1;
		}
		if(i != u/i) {
			if(i >= k && t > 1) {
				if(t&1) vis[dfs(i)] = 1;
				else vis[0] = 1;
			}
		}
	}
	for(i=0;;i++) if(!vis.count(i)) break;
	return dp[u] = i;
}
int main() {
	scanf("%d%d%d", &n, &m, &k);
	if(n%2==0) {
		puts("Marsel");
		return 0;
	}else {
		int ret = dfs(m);
		if(ret) puts("Timur");
		else puts("Marsel");
	}
	return 0;
}

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=2000;
int q[maxn],tot,sg[maxn],vis[maxn];
map<int,int>mp;
int main()
{
    int N,M,K,T=0;
    scanf("%d%d%d",&N,&M,&K);
    if(N%2==0) return puts("Marsel"),0;
    for(int i=1;i*i<=M;i++) {
        if(M%i!=0) continue;
        if(i>=K) q[++tot]=i;
        if(i*i!=M&&M/i>=K) q[++tot]=M/i;
    }
    sort(q+1,q+tot+1);
    rep(i,1,tot) mp[q[i]]=i;
    rep(i,1,tot) {
        T++;
        rep(j,1,i-1) {
            if(q[i]%q[j]==0){
                if(q[i]/q[j]%2==0) vis[0]=T;
                else vis[sg[j]]=T;
            }
        }
        rep(j,0,maxn)if(vis[j]!=T) {
            sg[i]=j; break;
        }
    }
    if(sg[mp[M]]) puts("Timur");
    else puts("Marsel");
    return 0;
}

//#include "stdafx.h"
#include <string>
#include <vector>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
#include <cstdio>
#include <algorithm>
#pragma comment(linker, "/STACK:167772160")
using namespace std;
typedef long long    int64;
int n,m,i,j,k,v;
int main()
{
    //freopen("input.txt","r",stdin);
	cin>>n>>m>>k;
	if(n%2==0)cout<<"Marsel"<<endl;else
	{
		v=0;
		for(i=2;i*i<=m;i++)
			if(m%i==0)
			if(i>=k || m/i>=k)v++;
		if(k==1 && m>1)v++;

		if(v==0)cout<<"Marsel"<<endl;else cout<<"Timur"<<endl;
	}
}

#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;

int n, m, k;
unordered_map<int, int> sgfunc;
int sg(int x) {
    if (sgfunc.count(x)) return sgfunc[x];
    if (x < k) return -1;
    unordered_map<int, bool> mp;
    for (int i = 1; i * i <= x; i++) {
        if (x % i != 0) continue;
        if (i != x) mp[ sg(i) ] = true;
        if (i != 1) mp[ sg(x / i) ] = true;
    }
    for (int i = 0; ; i++)
        if (!mp[i]) {
            sgfunc[x] = i;
            return i;
        }

}

int main() {
    scanf("%d%d%d", &n, &m, &k);
    if (!(n & 1)) {
        printf("Marsel\n");
        return 0;
    }
    if (m <= k) {
        printf("Marsel\n");
    }
    else if (sg(m)) {
        printf("Timur\n");
    }
    else {
        printf("Marsel\n");
    }

    return 0;
}

#ifdef ONLINE_JUDGE
#pragma comment(linker, "/STACK:16777216")
#endif

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#include <stack>
#include <sstream>
#include <cstring>
#include <numeric>
#include <ctime>

#define re return
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int) (x).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; i--)
#define y0 y32479
#define y1 y95874
#define fill(x, y) memset(x, y, sizeof(x))
#define sqr(x) ((x) * (x))
#define prev prev239
#define next next239
#define hash hash239
#define rank rank239

using namespace std;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<string> vs;
typedef long long ll;
typedef double D;
typedef long double LD;

template<class T> T abs(T x) {return x > 0 ? x : -x;}

int n;
int m;

map<int, int> mm;
int k;

int getans(int m) {
    if (mm.count(m)) {
        re mm[m];
    }
    int ans = 0;
    for (int i = 1; i * i <= m; i++) {
        if (m % i == 0) {
            if (m / i >= k && i > 1)
            if (i % 2 == 0 || getans(m / i) == 0) {
                ans = 1;
                break;
            }
            if (i >= k && m / i > 1)
            if ((m / i) % 2 == 0 || getans(i) == 0) {
                ans = 1;
                break;
            }
        }
    }

    mm[m] = ans;
    re ans;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
#endif
    string s1 = "Timur";
    string s2 = "Marsel";
/*
    k = 50;
    for (int i = 1; i <= 100; i++)
        cout << i << ' ' << getans(i) << endl;
    return 0;*/

    cin >> n >> m >> k;
    if (n % 2 == 0) {
        cout << s2 << endl;
        re 0;
    }

    if (getans(m) == 0)
        cout << s2 << endl;
    else
        cout << s1 << endl;

    re 0;
}

#include<bits/stdc++.h>
#include<time.h>
#include<stdlib.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define pll pair<ll,ll>
#define vll vector<ll,ll>
#define all(a) (a).begin(),(a).end()
#define ff first
#define ss second
#define sz(x) (ll)x.size()
#define hell 1000000007
#define repf(i,a,b) for(ll i=a;i<b;i++)
#define repb(i,a,b) for(ll i=a;i>b;i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a,b) __gcd((a),(b))
#define EPS 1e-12
#define lcm(a,b) ((a)*(b))/__gcd((a),(b))
using namespace std;

int32_t main()
{
	ll n,m,k,i;
	cin>>n>>m>>k;
	if(k>=m)
		cout<<"Marsel\n";
	else
	{
	vector<ll> v;
	for(i=1;i<=sqrt(m);i++)
	if(m%i==0)
	{
		v.pb(i);
		if(m/i!=i)
			v.pb(m/i);
	}
	sort(all(v));
	ll l=lbnd(v.begin(),v.end(),k)-v.begin();
	ll z=m/v[l];
	if(z==1)z--;
	if(z%2==0)
	{
		if(z==0)
			cout<<"Marsel\n";
		else
		{
		if(n%2)
			cout<<"Timur\n";
		else
		cout<<"Marsel\n";
}
	}
	else
	{
		if(n%2)
		cout<<"Timur\n";
		else
			cout<<"Marsel\n";
	}
}
	return 0;
}

#include <stdio.h>
main(int n,int m,int k,int i) {
	scanf("%d%d%d",&n,&m,&k);
	if(n&1)
		for(i=1;i*i<=m;++i)
			if(!(m%i)&&((m/i>=k&&i>1)||(i>=k&&m/i>1))) return puts("Timur");
	puts("Marsel");
}

#include <bits/stdc++.h>

using namespace std;

typedef long long unsigned ll;

bool exists_divisor(ll k, ll m)
{
    for (ll i = 2; i <= (ll) sqrt(m); ++ i)
        if (m % i == 0 && m / i >= k)
            return true;
    return false;
}

int main()
{
    ll n, m, k;

    cin >> n >> m >> k;

    if (n % 2 == 0) cout << "Marsel" << endl;
    else {
        if ((k == 1 and m > 1) || exists_divisor(k, m)) {
            cout << "Timur" << endl;
        } else {
            cout << "Marsel" << endl;
        }
    }
}

#include<bits/stdc++.h>
using namespace std;

    int main(){
    //freopen("in.in","r",stdin);
    int n,m,k,i,j;
    bool c=0;
    cin>>n>>m>>k;
    for(i=1;i<=sqrt(m);i++)
        if(m%i==0 && ( (m/i>=k && i!=1) || (i>=k && m/i!=1)))

        {        c=1;}

    if(n%2==1 && c)
        cout<<"Timur";
    else
        cout<<"Marsel";

    return 0;
}

/*
***************************************************************
Author           : Ishan Dutta
Email            : ishandutta2007@gmail.com
Facebook         : http://www.facebook.com/ishan.dutta
Blog             : tessellationsoftechnology.wordpress.com
Topcoder Handle  : Ishandutta2007
Codeforces Handle: ishandutta2007
Codechef Username: ishandutta2007
Spoj Username    : ishandutta2007
UVA Username     : ishandutta2007
***************************************************************
*/
/* ***************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/\_/---Headers---\_/\_/\_/\_/\_/\_/\_/\_/
/* ***************************************************************** */

//C headers
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<cstdio>
#include<ctime>
#include<cctype>
#include<cassert>
#include<climits>
#include<cerrno>
#include<cfloat>
#include<ciso646>
#include<clocale>
#include<csetjmp>
#include<csignal>
#include<cstdarg>
#include<cstddef>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cwchar>
#include<cwctype>

//containers
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<deque>
#include<set>
#include<complex>
#include<string>
#include<stack>
#include<bitset>
#include<istream>
#include<valarray>

//IOs
#include<iostream>
#include<sstream>
#include<iomanip>
#include<fstream>
#include<exception>
#include<ios>
#include<iosfwd>
#include<ostream>
#include<iterator>
#include<stdexcept>
#include<streambuf>

//algorithm & miscellaneous
#include<algorithm>
#include<functional>
#include<numeric>
#include<utility>
#include<limits>
#include<locale>
#include<memory>
#include<new>

/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/---Frequently used macros---\_/\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */

#define MOD 1000000007
#define INF 1000000000

/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/\_/\_/---Shorthands---\_/\_/\_/\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */

#define ll long long
#define F first
#define S second
#define pb push_back

#define SZ(c) (c).size()
#define reset(x) memset((x),0,sizeof(x));
#define negset(x) memset((x),-1,sizeof(x));
#define set(x) memset((x),1,sizeof(x));

#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort(ALL(x))
#define REVERSE(c) reverse(ALL(c))

#define FOR(i,a,b) for(int i=(int)(a);i<=(int)(b);i++)
#define REP(i,n) FOR(i,0,(n-1))

#define FORD(i,a,b) for(int i=(int)(a);i>=(int)(b);i--)
#define REPD(i,n) FOR(i,(n-1),0)

#define tst int t;scanf("%d",&t);while(t--)
#define s(x) scanf("%d",&x)
#define sl(x) scanf("%lld",&x)
#define ss(x) scanf("%s",x)

#define p(x) printf("%d",x)
#define pl(x) printf("%lld",x)
#define ps(x) printf("%s",x)

#define pn(x) printf("%d\n",x)
#define pln(x) printf("%lld\n",x)
#define psn(x) printf("%s\n",x)

#define sp system("PAUSE")

/* ****************************************************************** */
// \_/\_/\_/\_/\_/---Fast IO using getchar_unlocked---\_/\_/\_/\_/\_/
/* ****************************************************************** */
/*
int gi(){
   int c = 'a';
   while (!(c >= '0' && c <= '9') && c != '-') c = getchar_unlocked();//();//
   int c2;
   if (c != '-')
     c2 = c;
   else
     c2 = '0';
   int res = 0;
   while((c2 >= '0' && c2 <= '9')){
     res = (res << 3) + (res << 1) + (c2 - '0');
     c2 = getchar_unlocked();//();//
   }
   return res * (c == '-' ? -1 : 1);
}
*/
using namespace std;
/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/---Actual Code Starts Here---\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */
int n,m,k;
bool fact(){
  if(k==1 && m>1)return true;
  int s=int(sqrt(m));
  for(int i=2;i<=s;i++)
      if(m%i==0 && (i>=k || m/i>=k))return true;
  return false;
}
int main(){
  s(n);s(m);s(k);
  if(n&1 && fact())cout<<"Timur";
  else cout<<"Marsel";
//sp;
  return 0;
}

#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

typedef long long LL;
typedef vector<int> vint;
typedef vector<vint> vvint;
//typedef double D;

const int inf = 1000 * 1000 * 1000;

int n, k, m;

int main()
{
	cin >> n >> m >> k;
	bool f = 0;
	for(int i = 2; i * i <= m; ++i)
		if (m % i == 0 && m / i >= k)
			f = 1;
	if (k == 1 && m > 1)
		f = 1;
	if (f && (n & 1))
		cout << "Timur" << endl;
	else
		cout << "Marsel" << endl;
	return 0;
}

#include <iostream>
using namespace std;
int n,m,k,f;
int main()
{
    cin >> n >> m >> k;
    if (n%2==0 || 2*k>m) cout << "Marsel";
    else
    {
        if (k==1)
        {
            cout << "Timur";
            return 0;
        }
        for (int i=2;i*i<=m;i++) if (m%i==0 && (m/i>=k))
        {
            cout << "Timur";
            return 0;
        }
        cout << "Marsel";
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main(){
    long long int n,m,k,l,i,ans=0,flag,x;
    cin>>n>>m>>k;
    l=1;
    while(m>k){
        flag=0;
        x=int(floor(sqrt(m)));
        for(int i=x;i<=k;i++){
            if(m%i==0){
                ans+=l;
                l=i;
                m=m/i;
                flag=1;
                break;
            }
        }
        if(flag==0)
            break;
    }
    ans*=n;
    if(ans%2==0)
        cout<<"Marsel";
    else
        cout<<"Timur";
    return 0;
}

#include <iostream>
using namespace std;
int n,m,k;
bool divi(int p){
for(int i=1;i*i<=p;i++){
    if(p%i){
        if(i>=k||p/i>=k)return true;
    }
}
return false;

}
int main(){

cin>>n>>m>>k;
if(divi(m)){
    if(m%2)cout<<"Timur";
    else cout<<"Marsel";
}
else cout<<"Marsel";

}

#include <vector>
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

#define ll long long
#define REP(i, X, Y) for(int i = X;i < Y;i++)
#define rep(i, X) REP(i, 0, X)

int main(){
    int n,m,k,res;
    vector<int> vec;
    while( cin>>n>>m>>k ){
    bool odd = (n&1);
    if(!odd || m < k){
        cout << "Marsel" << endl;
        continue;
    }

    for(int i = 1;i*i <= m && i <= k;i++){
            if(m%i == 0) vec.push_back(i);
    }
    if(vec.size() > 0){
        cout << "Timur" << endl;
        continue;
    }else{
        cout << "Marsel" << endl;
        continue;
    }
    }
}

#include <cstdio>
#include <cmath>
using namespace std;
int main() {
	int n, m, k, i, j;
	scanf("%d%d%d", &n, &m, &k);
	j = floor(sqrt(m));
	for (i = 2; i <= j; ++i)
		if (m % i == 0) break;
	if (k > 1 && i > j || m > 1 && m / i < k) printf("Marsel\n");
	else if (n & 1) printf("Timur\n");
	else printf("Marsel\n");
	return 0;
}

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	if(n%2==0){
		cout<<"Marsel"<<endl;
		return 0;
	}
	bool check=1;
	for(int i=1;i*i<=m;i++)
	{
		int piles=i;
		if(piles != 1 && m/piles>=k && piles%2==0){
			check=1;
			break;
		}
		piles=m/i;
		if(piles != 1 && m/piles>=k && piles%2==0){
			check=1;
			break;
		}
	}
	if(check)
		cout<<"Timur";
	else
		cout<<"Marsel";
}

#include <bits/stdc++.h>

using namespace std;
#define DEBUG_ON 1

#define INF 0x3f3f3f3f
#define NSYNC ios::sync_with_stdio(false);
#define FOR(i,a,b) for(int i=a; i<(b); ++i)
#define FOR0(i,b) for(int i=0; i<(b); ++i)
#define TRAV(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define RTRAV(it,c) for(__typeof((c).rbegin()) it=(c).rbegin(); it!=(c).rend(); ++it)
#define DBG(x) if(DEBUG_ON) cout << #x << " == " << x << endl
#define DBGP(x) if(DEBUG_ON) cout << "(" << (x).first << ", " << (x).second << ")" << endl
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define R(x) scanf(" %d",&(x))
#define RR(x,y) scanf(" %d %d",&(x), &(y))
#define RRR(x,y,z) scanf(" %d %d %d",&(x), &(y),&(z))
#define CLR(v) memset(v, 0, sizeof(v))
#define SET(v) memset(v, -1, sizeof(v))

typedef long long ll;
typedef int int_type;
typedef pair<int_type, int_type> pii;
typedef vector<int_type> vi;
typedef vector<vi> vii;

vector<pii> facts;
map<int,bool> mp;
int k;
int m;

void fact(int n) {
	for(int i=2; i*i<=n; ++i) {
		while(!(n%i)) {
			if(!facts.size() || facts.back().first !=i) facts.pb(mp(i,1));
			else ++facts.back().second;
			n/=i;
		}
	}
	if(n>1) facts.pb(mp(n,1));
}

int get_val(const vector<pii>& v) {
	int x = 1;
	TRAV(it,v) {
		FOR0(iii,it->second) x*=(it->first);
	}
	return x;
}

void gen(int p, const vector<pii>& facts, int x, vector<pii> auxfacts, int intval, vector<vector<pii> >& aux) {
	if(p==facts.size()) {
		if(x>1 && intval >= k*x) {
			aux.pb(auxfacts);
		}
		return;
	}
	FOR0(i,facts[p].second+1) {
		vector<pii> newv(auxfacts);
		newv.pb(mp(facts[p].first,i));
		gen(p+1,facts, x, newv,intval,aux);
		x*=facts[p].first;
	}
}

int solve(vector<pii> v) {
	int x = get_val(v);

	auto it = mp.find(x);
	if(it!=mp.end()) return it->second;
	vector<vector<pii> > aux;

	gen(0,v,1,vector<pii>(), x,aux);

	set<int> st;

	TRAV(it,aux) {
		int pdiv = get_val(*it);
		// DBG(pdiv);
		if(pdiv%2==0) st.insert(0);
		else {

			vector<pii> newvec(v);
			FOR0(i,newvec.size()) newvec[i].second -= (*it)[i].second;

			st.insert(solve(newvec));
		}
	}

	int ans = 0;
	while(true) {
		if(!st.count(ans)) {
			return mp[x] = ans;
		}
		++ans;
	}

	assert(false);
}

int main() {
	NSYNC;
	int n,m;
	cin >> n >> m >> k;
	if(!(n&1)) {
		cout << "Marsel\n";
		exit(0);
	}
	fact(m);

	// TRAV(it,facts) DBGP(*it);

	if(solve(facts)) cout << "Timur\n";
	else cout << "Marsel\n";

	return 0;
}

#include<iostream>
#include <algorithm>
#include <cmath>
#define mod 1000000000
#define maxn 1003
using namespace std;

#define fast_io ios_base::sync_with_stdio(0);cin.tie(0)
int ncr[maxn][maxn];

int main(int argc, char const *argv[])
{
  /* code */
int cases,n,m,k;
cin>>n>>m>>k;
int flag=0;   ///marsel win for flag0
if(n%2==0){
  ;
}else{
  for(int i=1;i<=sqrt(m)+1;i++){
    if(m%i==0){
      if(i>=k||m/(i)>=k)
      {
        flag=1;
        break;
      }
    }
  }
}

if(flag==0){
  cout<<"Marsel"<<endl;
}else{
  cout<<"Timur"<<endl;
}

return 0;

}

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>

using namespace std;

int main()
{
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	int n, m, k;

	cin >> n >> m >> k;

	if(!(n & 1))
		cout << "Marsel";
	else
	{
		bool found1 = false;
		vector<int> razl;

		while(m > 1)
		{
			bool found = false;
			for(int i = 2; i*i <= m; ++i)
				if(m%i == 0)
				{
					razl.push_back(i);
					m /= i;
					found = true;
					break;
				}
			if(!found)
			{
				razl.push_back(m);
				break;
			}
		}

		sort(razl.rbegin(), razl.rend());
		//for(int i = 0; i < razl.size(); ++i)
		//	cout << razl[i] << ' ';
		//cout << endl;
		m = (razl.size() > 0 ? razl[0] : 0);
		for(int i = 1; i < razl.size() - 1 && !found1; ++i)
		{
			m *= razl[i];
			if(m >= k)
				found1 = true;
		}
		if(m >= k)
			found1 = true;

		if(!found1)
			cout << "Marsel";
		else
			cout << "Timur";
	}

	return 0;
}

#include <bits/stdc++.h>
#define ll          long long int
#define uu          first
#define vv          second
#define pii         pair<int,int>
#define pll         pair<ll,ll>
#define tp          tuple<int,int,int>
#define fastio      ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
using namespace std;
const int INF = 1e9;
const ll MOD = 1e9 + 7;

const int N = 1e6 + 6;

int main() {
    int n , m , k;
    cin>>n>>m>>k;

    string one = "Timur" , two = "Marsel";
    if(n%2 ==0) {
        cout<<two<<'\n';
        return 0;
    }

    int div = 0;
    for(ll i = 2 ; i*i <= m ; i++) {
        if(m % i) continue;
        int div1 = i;
        int div2 = m/i;
        if(div1 >=k || div2 >= k) div = 1;
    }

    if(div) cout<<one<<'\n';
    else cout<<two<<'\n';
    return 0;

}

 #include<bits/stdc++.h>
    #define pb push_back
    #define sz(a) ll((a).size())
    #define   pr  pair<ll,ll>
    #define all(c) (c).begin(),(c).end()
    #define tr(c,i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
    #define SIZE 100002
    #define fi first
    #define se  second
    #define vi vector<ll>
    #define hell  1000000000+7
  //  #define M_PI      3.14159265358979323846
    using namespace std;

void sieve(int N) {
        bool isPrime[N+1];
        for(int i = 0; i <= N;++i) {
            isPrime[i] = true;
        }
        isPrime[0] = false;
        isPrime[1] = false;
        for(int i = 2; i * i <= N; ++i) {
             if(isPrime[i] == true) {                    //Mark all the multiples of i as composite numbers
                 for(int j = i * i; j <= N ;j += i)
                     isPrime[j] = false;
            }
        }
    }

typedef  long long int ll ;

ll d, x, y;
void extendedEuclid(ll A, ll B) {
    if(B == 0) {
        d = A;
        x = 1;
        y = 0;
    }
    else {
        extendedEuclid(B, A%B);
        ll temp = x;
        x = y;
        y = temp - (A/B)*y;
    }
}

ll modInverse(ll A, ll M)
{
    extendedEuclid(A,M);
    return (x%M+M)%M;    //x may be negative
}

    void machayenge(){
    ll n,m,k; cin>>n>>m>>k;
    bool flag=false;
    ll cl=m;
    for(ll i=2;i*i<=m;++i){
      if(m%i==0){  if(i>=k && (m/i)>= k)flag=true;}
    }

    if(m!=1 && m>=k) flag=true;

    //cout<<flag<<"%";
    if(n%2==0) cout<<"Marsel";
    else if(flag) cout<<"Timur";
    else cout<<"Marsel";

     }

    int main(){
     ios_base::sync_with_stdio(false);
       cin.tie(NULL);
          cout.tie(0);

//    cout<<5%3;
 machayenge();

    return 0;}

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <cmath>
#include <sstream>
#include <queue>

using namespace std;

#define TM 100010

int main() {

	int n, m, k;
	scanf(" %d %d %d", &n, &m , &k);
	if(n % 2 == 0) {
		cout << "Marsel" << endl;
	} else {

		int flag = false;
		for(int i = 2; i < TM && i < m; i++) {
			if(m % i == 0 && i > k) {
				flag = true;
			}
			else if(m % i == 0 && m/i > k) {
				flag = true;
			}
		}
		if(flag)cout << "Timur" << endl;
		else cout << "Marsel" << endl;

	}

	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>

using namespace std;

int Euler_Function(int N)
{
    int ans = N;
    for (int i = 2 ; i * i <= N ; i ++ )
        if ( N % i == 0 )
        {
            ans -= ans/i;
            while ( N % i == 0 )
                N /= i ;
        }
    if ( N != 1 )
        ans -= ans/N;
    return ans;
}

int Binary_ModPow(int a , int b , int m)
{
    int res = 1;
    while ( b )
    {
        if ( b & 1 )
            res = (res * a) % m , b -- ;
        else
            a = (a * a) % m , b >>= 1;
    }
    return res % m;
}

void Decomposition(int N , vector <int> &prime , vector <int> &pows)
{
    for (int i = 2 ; i * i <= N ; i ++ )
        if ( N % i == 0)
        {
            pows.push_back(0);
            while ( N % i == 0 )
            {
                N /= i;
                pows.back() ++ ;
                prime.push_back(i);
            }
        }
    if ( N != 1 )
    {
        prime.push_back(N);
        pows.push_back(1);
    }
}

int gcd (int a , int b)
{
    for (int save = a ; b ;
             save = a , a = b , b = save % b
    );
    return a;
}

int lcm(int a , int b)
{
    return a * b /
           gcd(a , b);
}

int Eratosphen(int n)
{
    int prime[100000000];
    memset(prime , true , sizeof (prime) );
    prime[0] = prime[1] = false;
    for (int i = 2 ; i * i <= n ; i ++ )
        if ( prime[i] )
            for (int j = 2 * i ; j <= n ; j += i )
                prime[j] = false;
    int ans = 0;
    for (int i = 1 ; i <= n ; i ++ )
        if ( prime[i] )
            ans ++ ;
    return ans;
}

void normalize(int &a ,int &b)
{
    int GCD = gcd ( a , b );
        a /= GCD;
        b /= GCD;
}

int System_Number(int a, int b)
{
    if ( a == 0 ) return 1;
        int ans = 0;
        for (; a ; a /= b , ans ++ );
    return ans;
}

void Get_Min_System(int a , int &Min)
{
    for (; a ; a /= 10 )
        Min = max ( a%10 + 1 , Min );
}

int Translate(int a , int system)
{
    int answer = 0 , Power = 1;
    for (; a ; Power *= system , a /= 10)
        answer += (a % 10) * Power;
    return answer;
}

long long n , m , k;

void main()
{
    cin >> n >> m >> k;
    if ( n % 2 == 0 ) printf("Marsel\n");
    else
    {
        for (int i = 1 ; i * i <= m ; i += 2 )
            if ( m % i == 0 && (m / i) >= k && i%2 == 1 )
            {
                printf("Timur\n");
                return;
            }
        printf("Marsel\n");
    }
    cin.get();
    cin.get();
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long

bool good(ll x, ll zn)
{
    if (x < zn) return false;
    ll bad = 0;
    ll i;
    for(i=2; i*i<=x; i++)
    {
            if (x%i==0 && i>=zn && i<zn+zn) bad++;
    }
    if (bad==0) return true;
    for(i = 2; i*i<=x; i++)
    {
        if (x%i==0) return false;
    }
    return true;
}

int main()
{
    ll n, m, k;
    cin>>n>>m>>k;
    ll i;

    if (n%2==0)
    {
        cout<<"Marsel";
        return 0;
    }

    if (m / 2<k)
    {
        cout<<"Marsel";
        return 0;
    }

    if (k == 1)
    {
        cout<<"Timur";
        return 0;
    }

    for(i = 2;i*i<=m; i++)
    {
        if (m%i==0)
        {
            ll rest = m/i;
          //  cout<<"rest = "<<rest<<endl;
            if (good(rest, k))
            {
              //  cout<<"rest = "<<rest<<endl;
                cout<<"Timur";
                return 0;
            }
        }
        /*
        if (m%i==0)
        {
            if ((i>=k && i<2*k) || ( m/i>=k && m/i<2*k && i!=1))
            {
              //  cout<<"i = "<<i<<endl;
            cout<<"Timur";
            return 0;
            }
        }
        */
    }
    cout<<"Marsel";
    return 0;
}

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#include <list>
#include <set>
#include <vector>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	if(m<2*k)
	{
		printf("Marsel");
		return 0;
	}
	if(n%2==0)
	{
		printf("Marsel");
		return 0;
	}
	else
	printf("Timur");

	return 0;
}

#include <stdio.h>
#include <math.h>
#define min(a,b) a<b? a:b
bool isPrime(int n){
    for (int i=2; i<=sqrt(n); i++)
        if (n%i==0) return false;
    return true;
}
int main(){
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    if (isPrime(m)) printf("Marsel");
    else{
        int cnt=0, mmin;
        while (m>=k){
            if (isPrime(m)) break;
            mmin=m;
            for (int i=1; i<=sqrt(m) ;i++)
                if (m%i==0){
                    if (i>=k) mmin=min(mmin,i);
                    if (m/i>=k) mmin=min(mmin,m/i);
                }
            cnt+=m/mmin;
            if (m==mmin){
                printf("Marsel");
                return 0;
            }
            else m=mmin;
        }
        n*=cnt;
        printf("%s",n%2 ? "Timur":"Marsel");
    }
    return 0;
}

 #include <algorithm>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <cmath>
 #include <set>
 #include <map>

 using namespace std;
 int main() {
    bool boolean = false;
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 2; i <= sqrt(m); i++)
        if (m % i == 0) {
            boolean = true;
            break;
        }
    if (boolean == false) { printf("Marsel"); return 0; }
    if (n % 2 == 1) { printf("Timur"); return 0; }
    printf("Marsel");
    return 0;
 }

#include <bits/stdc++.h>
using namespace std;
int main()
{
    long long n , m , k ;
    cin >> n >> m >> k ;
    if(n%2 == 0){
        return cout << "Marsel" , 0 ;
    }
    bool flag = false ;
    long long x = sqrt(m) ;
    for(long long i = 2 ;i <= x+1 ; i++){
        if(m%i==0&&m/i >= k ){
            if(m/i == k || (m/i)%k != 0){
                flag = true ;break;
            }
        }
    }
    if(flag == false)return cout << "Marsel" , 0 ;
    else {
        return cout << "Timur" , 0 ;
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int,int>;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
  int n,m,k;
  cin>>n>>m>>k;
  vector<int> del;
  for(int i = 1; i*i<=m;i++){
    if(m % i == 0){
      if(i>=k){
        del.push_back(i);
      }
      if(i>1&&m/i>=k&&i!=m/i){
        del.push_back(m/i);
      }
    }
  }
  sort(del.begin(),del.end());
  if(del.size() == 0){
    cout<<"Marsel";
  } else {
    cout<<"Timur";
  }
  return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
string ans = "Marsel";
if(n%2==1)
{
    int x;
    for(x=2;x<=m/k ; x++)
    {

        if(m%x==0)
        {
            ans = "Timur";
            break;
        }
        if(x*x > m/k)break;
    }
}
cout<<ans;
return 0;
}

#include <vector>
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

#define ll long long
#define REP(i, X, Y) for(int i = X;i < Y;i++)
#define rep(i, X) REP(i, 0, X)

int main(){
    long long n,m,k,res;
    vector<int> vec;
    while( cin>>n>>m>>k ){
    bool odd = (n&1);
    if(!odd || m < k){
        cout << "Marsel" << endl;
        continue;
    }

    for(int i = (k == 1)? 1:2;i*i <= m && i <= k;i++){
        if(m%i == 0) vec.push_back(i);
    }
    for(vector<int>::iterator iter = vec.begin();
                                iter < vec.end();
                                iter++){
        cout << *iter << endl;
        if( m/(*iter) >= k || *iter >= k) continue;
        vec.erase(iter);
    }
    if(!vec.empty()){
        cout << "Timur" << endl;
        continue;
    }else{
        cout << "Marsel" << endl;
        continue;
    }
    }
}

#include <bits/stdc++.h>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <algorithm>
typedef long long LL;
#define INF 0x3f3f3f3f
#define INF64 0x3f3f3f3f3f3f3f3f
using namespace std;
const int M = 200;
int n, m, k;
int main() {
	cin>>n>>m >>k;
	//cout<< pow(m, 0.5);
	if (n % 2 == 0) {
		printf("Marsel");
		return 0;
	} else {
		for (int i = 1; i <= min((int)pow(m,0.5), m - 1); i++) {
			if (m % i == 0 && ( i >= k || m / i >= k)) {
				printf("Timur");
				return 0;
			}
		}
		printf("Marsel");
	}
  	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/stack:67108864")

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <ctime>
#include <stack>
#include <queue>
#include <string>
#include <iomanip>
#include <sstream>
#include <cassert>
#include <iostream>

#include <cstdio>
#include <algorithm>

using namespace std;

#define forn(i, n) for(int i = 0; i < int( n ); ++i)
#define forv(i, v) forn(i, (v).size())

#define pb push_back
#define mp make_pair
#define fs first
#define sc second

#define all(v) (v).begin(), (v).end()
#define correct(x, y, n, m) ((x) >= 0 && (x) < (n) && (y) >= 0 && (y) < (m))

template <class T> T abs(T a) { return (a) > 0 ? (a) : -(a); }
template <class T> T sqr(T a) { return (a) * (a); }

typedef long double ld;
typedef pair <ld, ld> pt;
typedef pair <int, int> PII;
typedef vector <int> VI;
typedef long long LL;

const ld PI = 3.1415926535897932, EPS = 1E-9;
const int INF = 1000 * 1000 * 1000, NMAX = 10005;
const long long INF64=(long long)1E18;

const char d[]={ 'R', 'O', 'Y', 'G', 'B', 'I', 'V'};
LL n;

int main( )
{
        //freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout); //

        int n,m,k;
        cin>>n>>m>>k;

        bool f=false;

        for(int i=1;i*i<=m;++i)
        {
                if (m%i==0)
                {
                        if (m/i>=k || i>=k)
                        {
                                f=true;
                                break;
                        }
                }
        }

        if (!f)
        {
                cout<<"Marsel";
                return 0;
        }

        if (n%2==1)
                cout<<"Timur";
        else cout<<"Marsel";
        return 0;
}

#include <iostream>
#include <vector>
#include <math.h>
#include<algorithm>
#include<string>
#include <map>
#include <string>
#include <sstream>
#include <set>
#include <queue>

using namespace std;

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x, y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x, y, z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef long long ll;
typedef double ld;
typedef pair<ll, ll> pll;

int dps[1022], pk;

int solve(string s) {
    for (int i = 0; i < s.size(); i++) {
        dps[i] = 1;
    }
    for (int i = 1; i < s.size(); i++) {
        int maxi = 0;
        for (int j = i - 1; j >= 0; j--) {
            if (s[i] == s[j]) {
                int t = maxi;
                maxi = max(maxi, dps[j]);
                dps[j] = max(dps[j], t + 2);
            } else {
                maxi = max(maxi, dps[j]);
            }
        }
    }
    int ans = 0;
    for (int i = 0; i < s.size(); i++)
        ans = max(ans, dps[i]);
    return ans;
}

string lltos(int t) {
    stringstream ss;
    ss << t;
    string b;
    ss >> b;
    return b;
}

long long stollq(string t) {
    stringstream ss;
    ss << t;
    long long b;
    ss >> b;
    return b;
}

bool check(string t) {
    int p = 0;
    for (int i = 0; i < t.size(); i++)
        p += t[i] - '0';
    return p == 10;
}

bool check(long long x, long long y, long long z) {
    return (x + y > z && x + z > y && z + y > x);
}

long long modulo_Euclidian(long long a, long long b) {
    long long m = a % b;
    if (m < 0) {
        m = (b < 0) ? m - b : m + b;
    }
    return m;
}

bool is_prime(int n) {
    for (int i = 2; i <= sqrt(n); ++i) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

const int N = 2e5 + 2;

int n, m, k;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m >> k;
    if (n % 2 == 0)
        cout << "Marsel";
    else {
        for (int i = 2; i <= sqrt(m); i++) {
            if (m % i == 0 && 2 * k - 1 >= i && m / i >= k) {
                cout << "Timur";
                exit(0);
            }
        }
        cout << "Marsel";
    }

    return 0;
}

#include <bits/stdc++.h>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <algorithm>
typedef long long LL;
#define INF 0x3f3f3f3f
#define INF64 0x3f3f3f3f3f3f3f3f
using namespace std;
const int M = 200;
int n, m, k;
int main() {
	cin>>n>>m >>k;
	//cout<< pow(m, 0.5);
	if (n % 2 == 0) {
		printf("Marsel");
		return 0;
	} else {
		if (k == 1 && m > 1) {
			printf("Timur");
			return 0;
		}
		for (int i = 2; i*i< m; i++) {
			if (m % i == 0 &&
				( i >= k || m / i >= k)) {

				printf("Timur");
				return 0;
			}
		}
		printf("Marsel");
	}
  	return 0;
}

//#include "stdafx.h"
#include <string>
#include <vector>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
#include <cstdio>
#include <algorithm>
#pragma comment(linker, "/STACK:167772160")
using namespace std;
typedef long long    int64;
int n,m,i,j,k,v;
int main()
{
    //freopen("input.txt","r",stdin);
	cin>>n>>m>>k;
	if(n%2==0)cout<<"Marsel"<<endl;else
	{
		v=0;
		for(i=2;i*i<=m;i++)
			if(m%i==0)
			if(i>=k || m/i>=k)v++;

		if(v==0)cout<<"Marsel"<<endl;else cout<<"Timur"<<endl;
	}
}

/* Author: Praveen Kulkarni
 * test.cpp
 * 17:32 2018-12-02 17:32
 * Copyright (C) 2018 pkulkarni <pkulkarni@Praveens-MacBook-Air.local>
 * #include "test.h"
 */
#include <numeric>
#include <iomanip>
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <array>
#include <bitset>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

#define int long long
#define endl '\n'

template<class C> void mini(C &a4, C b4) { a4 = min(a4, b4); }
template<class C> void maxi(C &a4, C b4) { a4 = max(a4, b4); }

template<class L, class R> ostream &operator<<(ostream &os, pair<L,R> P) {
  return os << "(" << P.first << "," << P.second << ")";
}
template<class T> ostream &operator<<(ostream& os, vector<T> V) {
  os << "["; for (auto vv : V) os << vv << ","; return os << "]";
}
template<class K, class X> ostream &operator<<(ostream& os, map<K,X> V) {
  os << "["; for (auto vv : V) os << vv << ","; return os << "]";
}

using ii = pair<int, int>;
using vi = vector<int>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;

void write(bool res) {
  cout << (res ? "Timur" : "Marsel") << endl;
}

int32_t main() {
  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
  int n, m, k; cin >> n >> m >> k;
  if(n % 2 == 0) {
    write(false);
    return 0;
  }
  for(int i = 2; i * i <= m; ++i) {
    if(i >= k or (m / i) >= k) {
      write(true);
      return 0;
    }
  }
  write(false);
  return 0;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
template <typename X> ostream& operator << (ostream& x,const vector<X>& v){for(ll i=0;i<v.size();++i) x<<v[i]<<" ";return x;}
template <typename X> ostream& operator << (ostream& x,const set<X>& v){for(auto it:v) x<<it<<" ";return x;}
template <typename X, typename Y> ostream& operator << (ostream& x, const pair<X,Y>& v) {x<<v.ff<<" "<<v.ss;return x;}
template <typename T, typename S> ostream& operator << (ostream& os, const map<T, S>& v) { for (auto it : v) os << it.first << "=>" << it.second << endl; return os; }
struct pair_hash {inline std::size_t operator()(const std::pair<ll, ll> & v) const {return v.first*31+v.second;}};
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define speed ios_base::sync_with_stdio(false);cin.tie(NULL)
#define pb push_back
#define fr first
#define sc second
#define prnt(m) for(auto it = m.begin() ; it != m.end() ; ++it){cout<<*it<<endl;}
#define tra(it,m) for(auto it=m.begin();it!=m.end();++it)
#define DBG(x) cout<<"# # #     "<<x<<'\n';
#define fri(i,s,n) for(long long i=s;i<n;i++)
#define mod 1000000007
#define mod2  998244353
#define vct2 vector<vector<ll>>
#define vct vector<ll>
#define pll pair<ll,ll>
#define rz(n) resize(n)
#define all(v) v.begin(),v.end()
#define mkp make_pair
#define arrin(a,n) for(ll i = 0; i < n ; i++){cin>>a[i];}
#define arrout(a,n) for(ll i = 0;i < n; i++){cout<<a[i]<<" ";}
#define ex(s) cout<<s<<endl,exit(0);
#define infy 2e18
#define five 100005;
#define six 1000005;
//_______________________________________________________________________________________________________________
int main()
{
	ll n,m,k;
	cin>>n>>m>>k;
	swap(n,m);
	if((m%2)==0)
	{
		cout<<"Marsel"<<endl;
		return 0;
	}
	bool ff = false;
	for(ll i = 2 ; i*i <= n ; i++)
	{
		if((n%i)==0)
		{
			if(i>=k)
			{
				ff = true;
				if(((n/i)%2)==0)
				{
					cout<<"Timur"<<endl;
					return 0;
				}
			}
			ll xx = n/i;
			if(xx>=k)
			{
				ff = true;
				if((i%2)==0)
				{
					cout<<"Timur"<<endl;
					return 0;
				}
			}
		}
	}
	//a
	if(m==1 && ff){
		cout<<"Timur"<<endl;
		return 0;
	}
	if(m==1)
	{
		if((n%2)==0)
		{
			cout<<"Timur"<<endl;
			return 0;
		}
	}

	cout<<"Marsel"<<endl;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

int OO = 100000007;
int const MAX = 105;

vector<string> s;
int k;
map<int, int> me;
int SG(int x) {
	if (me.find(x) != me.end())
		return me[x];
	set<int> q;
	if (k == 1)
		return 1;
	for (int i = 2; i * i <= x; i++)
		if (x % i == 0) {
			if (x / i >= k) {
				if (i % 2)
					q.insert(SG(x / i));
				else
					q.insert(1);
			}
			if (i >= k) {
				if ((x / i) % 2)
					q.insert(SG(i));
				else
					q.insert(1);
			}
		}
	int w = 0;
	for (auto it : q) {
		if (it != w)
			return me[x] = w;
		w++;
	}
	return me[x] = w;
}

int main() {
	int n, m;
	cin >> n >> m >> k;
	if (n % 2 == 0) {
		cout << "Marsel";
		return 0;
	}
	if(SG(m))
		cout << "Timur";
	else
		cout << "Marsel";
	return 0;
}

#include <iostream>
#include <cmath>
using namespace std;
const char* s[]={"Timur","Marsel"};
bool isPrime(int n){
    for (int i=2; i<=sqrt(n); i++)
        if (n%i==0) return false;
    return true;
}
int main(){
    int n,m,k;
    bool ok=false;
    cin>>n>>m>>k;
    while (m>=k && !ok){
        int cnt=1;
        if (isPrime(m)){
            n*=cnt;
            break;
        }
        for (int i=k; i<=m; i++){
            if (m==i){
                ok=true;
                n*=cnt;
                break;
            }
            if(m%i==0){
                cnt=m/i;
                m=i;
                break;
            }
        }
    }
    cout<<(n%2 ? s[0]:s[1]);
    return 0;
}

#include <iostream>

using namespace std;

int n,m,k,ans;

int main() {
cin>>n>>m>>k;
if(k==1 && n%2==1) ans=1;
for(int i=2;i*i<=m;i++)
                       if(m%i==0 && m/i>=k && n%2==1) ans=1;
if(ans)cout<<"Timur";
else cout<<"Marsel";
return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define popb pop_back
#define all(A) A.begin(),A.end()
#define dic unordered_map

using namespace std;

int k;
bool solve(int n,int m){
	if(n>1) return (n&1)&solve(1,m);
	bool ans=true;
	for(int i=1;i*i<=m;i++){
		if(m%i==0){
			if(i>=k){
				ans&=solve(m/i,i);
			}
			if((m/i)!=i && (m/i)>=k && i!=1){
				ans&=solve(i,m/i);
			}
		}
	}
	return ~ans;
}
int main () {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n, m;
	cin>>n>>m>>k;
	if(solve(n,m)) cout<<"Timur\n";
	else cout<<"Marsel\n";
	return 0;
}

#include<iostream>
#include<cmath>

using namespace std;

int main() {
    int n,m,k;
    cin>>n>>m>>k;
    if(n%2==0) {
               cout<<"Marsel"<<endl;
               return 0;
    }
    if(k==1) {
             cout<<"Timur"<<endl;
             return 0;
    }
    for(int i=2;i<=sqrt(m);i++) {
            if(m%i==0) {
                       cout<<"Timur"<<endl;
                       return 0;
            }
    }
    cout<<"Marsel"<<endl;
    return 0;
}

#include <cstdlib>
#include <cmath>

#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
using namespace std;

//#define LOCAL

#ifdef LOCAL
#include <fstream>
ifstream cin("input.txt");
ofstream cout("output.txt");
#else
#include <iostream>
#endif

const int max_del = 1e5 + 100;

int n, m, k;
vector<int> del;
map<int, int> mp;
int dp[2][max_del], f[2][max_del];

int calc(int ost, int cur_del) {
	if (f[ost][cur_del])
		return dp[ost][cur_del];
	f[ost][cur_del] = 1;
	dp[ost][cur_del] = 1;
	int cr;
	if (ost == 0)
		cr = calc(1, cur_del);
	else
		cr = 0;
	for (int i = 0; i <= cur_del; ++i)
	if (del[cur_del] % del[i] == 0 && del[i] != 1 && (del[cur_del] / del[i]) >= k &&
		calc(del[i] % 2, mp[del[cur_del] / del[i]]) == ((cr + 1) % 2)) {
			dp[ost][cur_del] = 0;
			return 0;
	}
	return 1;
}

int main() {
	ios_base::sync_with_stdio(false);
	cin >> n >> m >> k;
	for (int i = 1; i * i <= m; ++i) {
		if (m % i != 0) continue;
		del.push_back(i);
		if (m != i * i)
			del.push_back(m / i);
	}
	sort(del.begin(), del.end());
	for (int i = 0; i < del.size(); ++i)
		mp[del[i]] = i;
	if (del.size() && calc(n % 2, del.size() - 1) == 0)
		cout << "Timur" << endl;
	else
		cout << "Marsel" << endl;
	return 0;
}

#include <iostream>

using namespace std;

int main( void ){

  int n,m,k;
  cin >> n >> m >> k;

  if( n & 1 ){
    for( int i = 1; i <= m; ++i ){
      if( ! ( m % i ) && m / i >= k ){
        cout << "Timur" << endl;
        return 0;
      }
    }
  }
  cout << "Marsel" << endl;

  return 0;
}

#include <iostream>
using namespace std;
int k;

int main(){
    int n,m;
    cin>>n>>m>>k;

    cout<< ((n%2)==0) ? "Marsel" : "Timur";
}

#include <bits/stdc++.h>
#define mod 1000000007
#define ll long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define endl '\n'

using namespace std;

int main()
{
    std::ios::sync_with_stdio(false);
    ll int n,m,k;
    cin>>n>>m>>k;
    if(n%2==0)
        cout<<"Marsel";
    else
    {
        for(ll int i=2;i<=sqrt(m);i++)
        {
            if(m%i==0)
            {

               if(i<k)
               {
                ll int temp=m/i;
                if(m%temp==0&&temp>=k)
                {
                cout<<"Timur";
                return 0;
                }
            }
            }
        }
        cout<<"Marsel";
    }

    return 0;
}

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	if(n&1) puts("Timur");
	else puts("Marsel");
	return 0;
}

#include <bits/stdc++.h>

#define mp(a,b) make_pair(a,b)

using namespace std;

typedef long long unsigned ll;

ll smallest_divisor(ll k, ll m)
{
//     for (ll i = 1; i * i < m; ++ i) {
//         if (m % i == 0) {
//             if (i >= k) {
//                 ll r = m / i;
//                 if (r >= k && r < m) {
//                     return r;
//                 }
//                 return i;
//             } else {
//                 ll r = m / i;
//                 if (r >= k && r < m) {
//                     return r;
//                 }
//             }
//         };
//     }

    for (ll i = 1; i < sqrt(m); i++)
    {
        if (m % i == 0)
        {
            if (i >= k) return i;
            // push the second divisor in the vector
            ll r = m / i;
            if (r >= k and r < m) return r;
        }
    }
    return 0;
}

int main()
{
    ll n, m, k;

    cin >> n >> m >> k;

    // for (ll i = 1; i <= 341; ++ i) {
    //     cout << "smallest divisor of 200 from " << i << " is " << smallest_divisor(i, 341) << endl;
    // }

    if (n % 2 == 0) cout << "Marsel" << endl;
    else {
        if (smallest_divisor(k, m)) {
            cout << "Timur" << endl;
        } else {
            cout << "Marsel" << endl;
        }
    }
}

#include <iostream>
#include <vector>
#include <conio.h>

#include <string>
#include <map>
#include <algorithm>
#include <time.h>
#include <math.h>
using namespace std;

typedef long long LL;
typedef vector<int> VI;

#define REP(i,n) for (LL i=0; i<n; i++)
#define FOR(i,x,y) for (LL i=x; i<=y; i++)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))

bool f(char t)
{
    if (t == 'a' || t == 'e' || t == 'i' || t == 'o' || t == 'u') return true;
    return false;
}

int main()
{
    LL n,m,k;
    cin>>n>>m>>k;
    if (n%2==0 || m<2*k || m==2 || m ==3){cout<<"Marsel"; return 0;}

    FOR(i,2,int(sqrt(double(m))))
    {
        if (m%i==0){cout<<"Timur"; return 0;}
    }
    cout<<"Marsel";
    //system("pause");
}

#include <iostream>
using namespace std;
int n, m, k;
int fun() {
	if(n&1 == 0) return 1;
	for(int i = 2; i*i <= m; i++) {
		if(m % i == 0 && m/i >= k) {
			return 0;
		}
	}
	return 1;
}
int main() {
	cin >> n >> m >> k;
	if(fun()) printf("Marsel\n");
	else printf("Timur\n");
}

#include <bits/stdc++.h>
using namespace std;

int main() {
	long long n, m, k, c,h,s ;
	vector <long long> v;
	cin>>n>>m>>k;
	h=0;
	c=0;

	if (m<16){
		for(int i=k; i<(m/2)+1;i++){
		if(m%i==0){

			c++;
			break;
		}
	}
	}

	else{
		for(long long i=1; i<sqrt(m)+3;i++){
			if(m%i==0){
				v.push_back(i);

			}

		}
		s=v.size();
		if (v[s-1]>k-1) c++;
		else{
			for(long long i=0;i<s;i++){
				if(m/v[i]>k-1){
					c++;
					break;
				}
			}
		}
	}
	if(c==0) cout<<"Marsel";
	else{
		if(n%2==0) cout<<"Marsel";
		else cout<<"Timur";
	}
	return 0;
}

#include <iostream>
#include <cstdio>
#include <utility>
#include <memory>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cmath>

#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define LL long long
#define VI vector<int>
#define X first
#define Y second
#define sz(_v) ((int)_v.size())
#define all(_v) ((_v).begin(),(_v).end())
#define FOR(i,a,b) for (int i(a); i<=(b); i++)
#define rep(i,a) FOR(i,1,a)
#define rept(i,a) FOR(i,0,a-1)
#define INF 999999999

using namespace std;

int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    VI d;
    for (int i=1; i*i<=m; i++) if (!(m%i)) d.pb(i),d.pb(m/i);
    if (sz(d)>=2 && d.back()==d[sz(d)-2]) d.pop_back();
    if (k!=1 && sz(d)==2) printf("Marsel\n");
    else if (n%2)
    {
        printf("Timur\n");
    }
    else printf("Marsel\n");
    return 0;
}

#include <cstdio>
#include <cmath>

int main(){

    long n, m, k; scanf("%ld %ld %ld\n", &n, &m, &k);
    if(n % 2 == 0){puts("Marsel"); return 0;}
    else{
        bool possible(0);
        for(long p = 1; p <= 1 + sqrt(m); p++){
            if(m % p > 0){continue;}
            if((k <= (m / p) && p > 1) || ((k <= p) && m < p)){possible = 1; break;}
        }

        puts(possible ? "Timur" : "Marsel");
    }

    return 0;
}

#include<cstdio>
using namespace std;
int main()
{
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	//printf("-1");
	if(!n^1)
	{
		printf("Marsel");
		return 0;
	}
	for(int i=2;i*i<=m;i++)
	{
		if(m%i==0&&(i>=k||m/i>=k))
		{
			printf("Timur");
			return 0;
		}
	}
	printf("Marsel");
}

#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
int main()
{
    int n, m, k;
    cin>> n>> m>> k;
    if (n == 1)
    {
          cout<< "Timur";
          return 0;
    }
    if (n == 4)
    {
          cout<< "Marsel";
          return 0;
    }
    srand((unsigned int)time(NULL));
    if (int(rand()%2)) cout<< "Timur"; else cout<< "Marsel";
//    system("pause");
    return 0;
}

#include <iostream>

using namespace std;

long long N, M, K;

int main() {
    cin >> N >> M >> K;

    int mult = 1;
    long long ans = 0ll;

    if (K == 1 && M != 1)
        ans ++;

    for (int i = 2; i * i <= M; i ++) {
        while (M % i == 0 && (M / i) >= K) {
            M /= i;
            ans += mult;
            mult *= i;
        }
    }

    cout << ((ans * N) % 2 == 0 ? "Marsel" : "Timur") << endl;
    return (0);
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
    ll n,m,k;
    cin>>n>>m>>k;
    if(n%2==0){
        cout<<"Marsel";
    }
    else {
            int flag=0;
        for(int i=2;i<=sqrt(m);i++){
            if(m%i==0){
                if(i>=k||m/i>=k) {
                    flag=1;
                    break;
                }
            }
        }
        if(flag==1) cout<<"Timur";
        else cout<<"Marsel";
    }
}

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

int main()
{
	long long a,b,c,d=0,e;
	cin>>a>>b>>c;
	for(e=c;e*e<b;e++) if(b%e==0)
	{d++;break;}
	d*=a;
	if(d%2==0) printf("Marsel");
	else printf("Timur");
}

#include <cstdio>
#include <cmath>
using namespace std;
int main() {
	int n, m, k, i, j;
	scanf("%d%d%d", &n, &m, &k);
	j = floor(sqrt(m));
	for (i = 2; i <= j; ++i)
		if (m % i == 0) break;
	if (i > j || m / i < k) printf("Marsel\n");
	else if (n & 1) printf("Timur\n");
	else printf("Marsel\n");
	return 0;
}

#include<bits/stdc++.h>
#include<time.h>
#include<stdlib.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#define pb push_back
#define mp make_pair
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define pll pair<ll,ll>
#define vll vector<ll,ll>
#define all(a) (a).begin(),(a).end()
#define ff first
#define ss second
#define sz(x) (ll)x.size()
#define hell 1000000007
#define repf(i,a,b) for(ll i=a;i<b;i++)
#define repb(i,a,b) for(ll i=a;i>b;i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define gcd(a,b) __gcd((a),(b))
#define EPS 1e-12
#define lcm(a,b) ((a)*(b))/__gcd((a),(b))
using namespace std;

int32_t main()
{
	ll n,m,k,i;
	cin>>n>>m>>k;
	vector<ll> v;
	for(i=1;i<=sqrt(m);i++)
	if(m%i==0)
	{
		v.pb(i);
		if(m/i!=i)
			v.pb(m/i);
	}
	sort(all(v));
	ll l=lbnd(v.begin(),v.end(),k)-v.begin();
	ll z=v[l]*n;
	if(z%2==0)
		cout<<"Marsel\n";
	else
		cout<<"Timur\n";
	return 0;
}

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#include <list>
#include <set>
#include <vector>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	if(m<2*k)
	{
		printf("Marsel");
		return 0;
	}
	if(n%2==0)
	{
		printf("Marsel");
		return 0;
	}
	else
	printf("Timur");

	return 0;
}

#include<bits/stdc++.h>
using namespace std;
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/hash_policy.hpp>
//#pragma comment(linker, "/STACK:102400000,102400000")
using namespace __gnu_pbds;
#define _for(i,a,b) for(int i=(a);i<(b);++i)
#define ms(a) memset(a,0,sizeof(a))
#define ms_inf(a) memset(a,0x3f,sizeof(a))
#define ms_ninf(a) memset(a,0xcf,sizeof(a))
#define pb push_back
#define mp make_pair
#define fast ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
//#define lc (o<<1)
//#define rc (o<<1|1)
//#include<ext/pb_ds/priority_queue.hpp>
//typedef __gnu_pbds::priority_queue<no> heap;  //��ƫ��
typedef long long ll;
typedef unsigned long long ull;
ull MOD=212370440130137957ll;
int mod=1e9+7;
ll INF=1e18;
const int maxn=2e5+10;
const int maxl=260;
const double PI=acos(-1.0);
const double eps=1e-8;
int n,m,k;
map<int,int>sg;
vector<int>v;
vector<int>so[maxn];
map<int,int>id;
int s(int x)
{
	if(x<k)return 0;
	if(sg.count(x))return sg[x];
	int u=id[x];
	if(so[u].size()==0)return sg[x]=0;
	vector<int>tm;bool h0=0;
	for(auto&e:so[u])
	{
		int y=s(e);
		int ti=x/e;if((ti&1)&&y)tm.pb(y);else h0=1;
	}
	if(!h0)return sg[x]=0;
	sort(tm.begin(),tm.end());
	tm.erase(unique(tm.begin(),tm.end()),tm.end());
	_for(t,0,tm.size())
	{
		if(t+1!=tm[t])return sg[x]=t+1;
	}
}
int main()
{
	fast;cin>>n>>m>>k;;
	if(!(n&1))return cout<<"Marsel",0;
	n=m;
	for(int i=1;i*i<=n;++i)
	{
		if(n%i==0)
		{
			v.pb(i);
			if(i*i<n)v.pb(n/i);
		}
	}
	sort(v.begin(),v.end());
//	for(auto&w:v)cout<<w<<" ";
	_for(t,0,v.size())
	{
		id[v[t]]=t;
		_for(i,0,t)
		{
			if(v[t]%v[i]==0&&v[i]>=k)so[t].pb(v[i]);
		}
	}
	int u=s(n);
	if(u)cout<<"Timur";else cout<<"Marsel";
}

#include <iostream>
#include <cstdio>
#include <cmath>

using namespace std;

int main()
{
	int n , m , k;
	cin >> n >> m >>  k;
	int sz = sqrt(m);
	bool f = 0;
	if( k == 1 ) {
		if( n != 1 ) f = 1;
	}
	for( int i = 2 ; i<= sz ;i++ ) 	if( m % i == 0 && (m /i)>= k ) f=1;
	if(!f)  cout<<"Marsel\n";
	if(f) {
		if( n % 2 == 0 ) printf("Marsel\n");
		else printf("Timur\n");
	}
	return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define int long long

int k;
int winner(int x) {
	if(x%2 == 0) return 1;
	if(x == 1) return 0;
	vector <int> v;
	for (int i = 1; i * i <= x; i++) {
		if (x % i == 0) {
			v.push_back(i);
			if (i != x / i) v.push_back(x/i);
		}
	}
	for(int i = 0; i < v.size(); i++) {
		if(x != v[i] && v[i] >= k && !winner(v[i]))
			return 1;
	}
	return 0;
}

void main() {
	int n, m;
	cin >> n >> m >> k;

	if(n%2 == 0) {
		cout << "Marsel" << endl;
		return;
	}
	cout << (winner(m)?"Timur":"Marsel") << endl;
	return;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
	long long n, m, k, c;
	cin>>n>>m>>k;
	c=0;
	for(long long i=k; i<sqrt(m+1);i++){
		if(m%i==0){
			c++;
			break;
		}
	}
	if(c==0) cout<<"Marsel";
	else if(n%2==0) cout<<"Marsel";
	else cout<<"Timur";
	return 0;
}

#include <iostream>
#include <cstdio>
#include <string.h>
#include <cmath>

using namespace std;

int main()
{

    int n,m,k;
    cin>>n>>m>>k;

    if(n%2==0){
               printf("Marsel\r\n");
               }
    else{
         bool flag=false;
         int lim=(int)sqrt(m);
         for(int i=2; i<=lim; i++){
                 if(m%i==0 && m/i >=k){
                            printf("Timur\r\n");
                            flag=true;
                            break;
                            }
                            }

    if(flag==false){
                   printf("Marsel\r\n");
                   }
                   }

    return 0;
}

#include <iostream>
#include <cmath>

using namespace std;

int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    if(n%2==0||k==m)cout<<"Marsel"<<endl;
    else
    {
        if(m%2==0&&(k<=2||k<=m/2))
        {
            cout<<"Timur"<<endl;
        }
        /*
        else if(k==1)
        {
            cout<<"Timur"<<endl;
        }
        */
        else
        {
            bool b=false;
            int l,c;
            c=ceil(sqrt(m));
            for(l=1;l<=c;l++)
            {
                if(m%l==0&&(k<=l||k<=m/l))
                {
                    cout<<"Timur"<<endl;
                    b=true;
                    break;
                }
            }
            if(b==false)cout<<"Marsel"<<endl;
        }
    }
    return 0;
}

#include <string>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <queue>
#include <iostream>
#include <sstream>
#include <stack>
#include <deque>
#include <cmath>
#include <memory.h>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <utility>
using namespace std;

typedef vector < int > vi;
typedef vector < string > vs;
typedef vector < bool > vb;
#define FOR(i,q,w) for (int i=q;i<w; i++)
#define MP make_pair
#define PB push_back
typedef long long ll;
const int INF = 1000000000;
const int MOD = 1000000007;

int n,m,k;
bool DP[1000];

int main()
{
        cin >> n >> m >> k;

        vector <int> P;
        for (int i = 1; i*i<=m; i++)
                if (m % i==0)
                {
                        P.PB(i);
                        if (i*i != m)
                                P.PB(m/i);
                }

        sort(P.begin(), P.end());

        FOR (i,0,P.size())
        {
                DP[i] = false;
                FOR (j,0,i)
                        if (P[i] % P[j] == 0)
                        {
                                if (P[j] >= k)
                                {
                                        int p = DP[j];
                                        int pp = P[i]/P[j];
                                        bool r = false;
                                        if (p == 0)
                                                r = false;
                                        else
                                        {
                                                if (pp % 2 == 0)
                                                        r = false;
                                                else r = true;
                                        }
                                        if (r==false)
                                                DP[i] = true;
                                }
                        }
        }

        if (DP[P.size()-1]==0)
                cout << "Marsel" << endl;
        else cout << "Timur" << endl;

        cin >> n;
        return 0;
}

#include <bits/stdc++.h>
using namespace std;
int n,m,k;
map<int,int>mp;
int dfs(int x){
	if (mp.find(x)!=mp.end()) return mp[x];
	set<int>S;
	int m=sqrt(x+0.5);
	for (int i=1;i<=m;i++){
		if (x%i==0){
			if (i>=k){
				int tmp=x/i;
				if (tmp&1){
					int res=dfs(i);
					if (res==0) return mp[x]=1;
				}
				else return mp[x]=1;
			}
			if (x/i>=k&&i!=1){
				if (i&1){
					int res=dfs(x/i);
					if (res==0) return mp[x]=1;
				}
				else return mp[x]=1;
			}
		}
	}
	return mp[x]=0;
}
int main(){
	scanf("%d%d%d",&n,&m,&k);
	if (n&1){
		if (k==1) puts(n==1?"Marsel":"Timur");
		else puts(dfs(m)?"Timur":"Marsel");
	}
	else puts("Marsel");
	return 0;
}

//sumit mamtani
typedef long long ll;
#include <iomanip>
#include <fstream>
#include <iostream>
#include <string>
#include <complex>
#include <math.h>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <stdio.h>
#include <stack>
#include <algorithm>
#include <list>
#define M 1000000007
#define X 998244353
#include <memory.h>
#define sd(x) scanf("%d",&x)
#define slld(x) scanf("%lld",&x)
#define ss(x) scanf("%s",x)
#define pa pair<int,int>
#define  INF 100000000
#define eps 1e-9

#define SSTR( x ) static_cast< std::ostringstream & >( \
        ( std::ostringstream() << std::dec << x ) ).str()

using namespace std;

ll n,k,m;
int main(){

    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m>>k;
    if(n%2==0){
        cout<<"Marsel"<<endl;
    }
    else{
        ll s=sqrt(m);
        s++;
        for(ll i=2;i<=s;i++){
            if(m%i==0){
                if(i>=k || (m/i)>=k){
                    cout<<"Timur"<<endl;
                    return 0;
                }
            }
        }
        cout<<"Marsel"<<endl;
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define sz(a) ((int)a.size())
#define EACH(i, a) for (auto& i : a)
#define FOR(i, a, b) for (decay<decltype(a)>::type i = (a), i##_n = (b); i < i##_n; i++)
#define ROF(i, a, b) for (decay<decltype(a)>::type i = (a) - 1, i##_n = (b); i >= i##_n; i--)
#define all(vec) (vec).begin(), (vec).end()
#define rev(vec) (vec).rbegin(), (vec).rend()
#define quit(x) do { cout << (x) << "\n"; return; } while (0)

#ifdef yuki
#define debug(x...) do { cout << "["#x"] -> "; err(x); } while (0)
template <class T>
inline void _E(const T& x) { cout << x; }
inline void _E(const double& x) {
  string str = to_string(x);
  cout << str.substr(0, str.find('.')) + str.substr(str.find('.'), 4);
}
inline void _E(const long double& x) { _E((double)x); }
template <class T>
inline void _E(const vector<T>& vec) {
  for (auto it = begin(vec), en = end(vec); it != en; it++) {
    cout << (it != begin(vec) ? " " : ""); _E(*it);
  }
}
inline void err() { cout.flush(); }
template <class T, class... U>
inline void err(const T& arg, const U&... args) {
  cout << "["; _E(arg); cout << (sizeof...(args) ? "], " : "]\n"); err(args...);
}
#else
#define debug(...) do {} while (0)
#endif

template <class T, class U>
inline bool chkmax(T& a, U b) { return (a < b) ? (a = b, true) : false; }
template <class T, class U>
inline bool chkmin(T& a, U b) { return (a > b) ? (a = b, true) : false; }

template <class T>
inline vector<T> mapping(vector<T> vec) {
  sort(all(vec)), vec.erase(unique(all(vec)), end(vec));
  return vec;
}

template <class T, class U>
inline int mapping(T* st, T* en, U* result) {
  int len = en - st;
  FOR(i, 0, len) result[i] = *(st + i);
  sort(result, result + len);
  return unique(result, result + len) - result;
}

typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

void solve();
int main(int argc, char **argv) {
#ifdef yuki
  if (argc > 1) assert(freopen(argv[1], "r", stdin));
  cerr.setf(ios_base::fixed), cerr.precision(4);
#endif
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  int T = 1;
  // cin >> T;
  FOR(Case, 1, T + 1) {
    solve();
  }
  double times = (clock() * 1.0 / CLOCKS_PER_SEC);
  debug(times);
}

// ***************************************************************************

void solve() {
  int n, m, k; cin >> n >> m >> k;
  if (~n & 1) quit("Marsel");

  for (int i = 2; i <= m / i; i++) {
    if (m % i == 0) {
      int v = m / i;
      if (v >= k) quit("Timur");
    }
  }
  quit("Marsel");
}

#include <iostream>
#include <math.h>
using namespace std;
int n, m, k;
int main(){

    int i, ok=0, dd;
    cin>>n>>m>>k;
    if(n%2==0) cout<<"Marsel"; //imita
    else{
        //cauti sa imparti pe cel impar in nr par de logs/ ii anulezi pe toti (h curenta nu mai poate fi impartita)
        //
        if((m%2==0)&&(2<=m/k)) ok=1;

        for(i=3; i<=sqrt(m); i++)
            if(m%i==0){
               dd=i; if(m/dd< 2*k) ok=1;
               dd=m/i; if(m/dd< 2*k) ok=1;
        }

       /* for(i=2; (i<=m/k)&&(!ok); i++)
           if(m%i==0){
                if(i%2==0) ok=1; //imparti in nr par
                if(m/i< 2*k) ok=1; //se anuleaza
           }*/
        if(ok) cout<<"Timur";
        else cout<<"Marsel";
    }
    return 0;
}

#include <stdio.h>
#include <iostream>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <math.h>
#include <algorithm>

using namespace std;

#define file "cooling"
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;

const int MAXN = 1e5+100;
const double EPS = 1e-9;
const ll INF = 1000000000+5;

int n,m,k;
map<pii,int> list;

int pr[MAXN];
set<int> st;
int cnt = 0;

int del[MAXN];
int sz = 0;

void gen(int a)
{
	for(int i=1;i<cnt;i++)
	{
		if(1ll*a*pr[i]<=m)
		{
			if(m%(a*pr[i])==0)
			{
				if(st.count(a*pr[i])==0)
				{
					if(a*pr[i]>=k)
					{
						st.insert(a*pr[i]);
						del[sz++] = a*pr[i];
					}
					gen(a*pr[i]);
				}
			}
		}
	}
}

int grandi(int a,int b)
{
	if(a<k)
	{
		return 0;
	}
	int ans;
	for(int j=0;j<sz;j++)
	{
		int j2 = del[j];

		if(j2>=a) break;
		int num = a/j2;

		if(list.find(mp(j2,num))==list.end())
		{
			ans = grandi(j2,num);
			list[mp(j2,num)] = ans;
		}
		else ans = list[mp(j2,num)];

		if(!ans)
		{
			if(b%2==1) return 1;
		}

	}

	return 0;
}

int main()
{
	//freopen(file".in","r",stdin); freopen(file".out","w",stdout);
	#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);
	freopen("output.txt","w",stdout);
	#endif

	cin>>n>>m>>k;

	int m2 = m;
	pr[cnt++] = 1;
	for(int i=2;i*i<=m2;i++)
	{
		if(m2%i==0)
		{
			pr[cnt++] = i;
			while(m2%i==0)
			{
				m2/=i;
			}
		}
	}

	if(m2>1) pr[cnt++] = m2;

	if(1>=k)
	{
		st.insert(1);
		del[sz++] = 1;
	}
	gen(1);

	//sort(del,del+sz);

	int ans = grandi(m,n);

	if(ans) printf("Timur");
	else printf("Marsel");
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main() {
    int n, m, k;
    cin >> n >> m >> k;

    bool fl = (k == 1 && m > 1);
    for(int i = 2; i * i < m; i++) {
        if(m % i == 0) {
            if(m / i >= k)
                fl = true;
        }
    }

    if(n % 2 == 0 || !fl)
        cout << "Marsel";
    else
        cout << "Timur";

}

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define ll long long

using namespace std;

int n, m, k;
bool ok;

int main()
{

	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	cin >> n >> m >> k;

	ok = false;

	if (k == 1)
		ok = true;

	for (int i = 2; i * i <= m; i++)
	{
		if (m % i == 0 && m/i >= k)
		{
			ok = true;
			break;
		}
	}

	if (!ok)
	{
		if (n % 2)
			cout << "Marsel";
		else
			cout << "Timur";

		return 0;
	}

	if (n % 2 == 0)
			cout << "Marsel";
		else
			cout << "Timur";

	return 0;
}

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;

map<int, int> ma;

int sg(int x,int k){
	if(ma.find(x) != ma.end())
		return ma[x];
	if (x/k < 2)
		return ma[x] = 0;
	for (int i = 2; i * i <= x / k; i++){
		if(x % i ==0){
			int y = sg(x / i, k);
			int tmp = 0;
			if (i % 2)
				tmp = y;
			if (tmp == 0)
				return ma[x] = 1;
			y = sg(i, k);
			tmp = 0;
			if (x / i % 2)
				tmp = y;
			if (tmp == 0)
				return ma[x] = 1;
		}
	}
	return ma[x] = 0;
}

int main(){
	int n, m, k; cin >> n >> m >>k;
	ma.clear();
	int res = sg(m, k);
	if (n % 2 == 0)
		res = 0;
	if (res > 0)
		printf("Timur\n");
	else
		printf("Marsel\n");
	return 0;
}

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
    int a,b,c;
    cin >> a >> b >> c;
    if (a%2==0){
       cout << "Marsel"; return 0;

    } else {
        for (int i=2;i<=sqrt(b);i++){
            if (b%i==0){
                cout << "Timur";
                return 0;
            }
        }
        cout << "Marsel";
    }
    return 0;
}

#include<cstdio>
using namespace std;
int main(){
	char name[2][10]={"Timur", "Marsel"};
	int n,m,k;
	if(n%2){
		if(m>=k*2) puts(name[0]);
		else puts(name[1]);
	}else {
		puts(name[1]);
	}
}

#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
#include <string>
#include <sstream>
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <utility>
#include <numeric>
#include <limits.h>
#include <iterator>
#include <iomanip>
#define REP(x,n)  for(x=0;x<(int)(n);x++)

using namespace std;

#define REP(x,n)  for(x=0;x<(int)(n);x++)
#define EACH(itr, cont) for(typeof((cont).begin()) itr = (cont).begin(); itr != (cont).end(); ++itr)
#define ALL(X)    (X).begin(),(X).end()

typedef long long LL;
map<int, int> d;
int k;

bool get(int m) {
    for (int i = k; i <= sqrt(m); ++i) {
        if (m % i == 0) return true;
    }
    return false;
}

int main(int argc, char** argv) {
    cin.sync_with_stdio(false);
    cout << setprecision(16);
    int n, m;
    cin >> n >> m >> k;
    if (n & 1) {
        if (get(m)) cout << "Timur";
        else cout << "Marsel";
    } else {
        cout << "Marsel";
    }
}

#include<bits/stdc++.h>
using namespace std;

int n,m,k;

map<int,int> memo;

int dp(int x){
	if(x < k) return 0;
	if(memo.find(x) != memo.end()) return memo[x];
	int ret = 0;
	for(int i=1;i*i<=x;i++){
		if(x%i == 0){
			int now = i;
			int jadi = x/i;
			if(jadi % 2 == 0) return memo[x] = 1;
			if(now!=x && now >= k){
				ret = max(ret,1-dp(now));
//				printf("DARI %d KE %d\n",x,now);
			}
			swap(now,jadi);
			if(jadi % 2 == 0) return memo[x] = 1;
			if(now == x || now < k) continue;
			ret = max(ret,1-dp(now));
//			printf("DARI %d KE %d\n",x,now);
		}
	}
	return memo[x] = ret;
}

int main(){
	scanf("%d%d%d",&n,&m,&k);
	if(n%2 == 0){
		printf("Marsel\n");
		return 0;
	}
	int win = dp(m);
	if(win) printf("Timur\n");
	else printf("Marsel\n");
	return 0;
}

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>

typedef long long ll;
using namespace std;
const int maxn=2e4+10;
//string str[100010];
bool win[maxn];
int a[maxn];
void init(){
	win[1]=1;
	win[2]=1;
}
int main()
{

	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	int time=m/k;
	if(m/k<2){
		printf("Marsel");
	}
	else if(m/k==2){
		if(n&1)
			printf("Timur");
		else
			printf("Marsel");
	}
	else{
		printf("Marsel");
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main()
{
    long long n , m , k ;
    cin >> n >> m >> k ;
    if(n%2 == 0){
        return cout << "Marsel" , 0 ;
    }
    bool flag = false ;
    long long x = sqrt(m) ;
    for(long long i = 2 ;i <= x+1 ; i++){
        if(m%i==0){
            if(m/i < k)break ;
            else {
                flag = true ;
                break ;
            }
        }
    }
    if(flag == false)cout << "Marsel"  ;
    else {
        cout << "Timur" ;
    }
    return 0;
}

#include <iostream>
#include <string>
#include <cmath>
using namespace std;

__int64 n,m,k;

int main()
{
#ifndef ONLINE_JUDGE
        freopen("input.txt","r",stdin);
        freopen("output.txt","w",stdout);
#endif
    cin >> n >> m >> k;
    __int64 i;

    if(n%2==0){cout << "Marsel";return 0;}
    double p=sqrt(m);
    int flag=-1;

    for(i=2;i<=p+1;i++)
    {
        if(m%i==0 && m/i>=k){flag=1;break;}
    }

    if(flag==-1){cout << "Marsel";return 0;}

    cout << "Timur";
    return 0;
}

#include<bits/stdc++.h>

using namespace std;

int main ()
{
   long long n, m, k;
    cin >> n >> m >> k;
    int b = 0;
    if((n)% 10 % 2 == 0)
    {
        cout << "Marsel";
    return 0;
    }
    if(m == k)
    {
        cout << "Marsel";
    return 0;
    }
    for(int i = k; i <= m / k + 1; i ++)
    {
        if(m % i == 0 && i >= k)
        {
            cout << i;
            cout << "Timur";
        return 0;
        }
    }
    /*while(true)
    {
        for(int i = (m / 2) + 1; i >= k; i --)
        {
            if(m % i == 0 && m / i >= k)
            {
                m /= k;
                b ++;
                break;
            }
        }
            break;
    }
    b = (b % 10) * (n % 10);
    if(b % 2 == 0)
        cout << "Marsel";
    else cout << "Timur";*/
    cout << "Marsel";
return 0;
}

// cfc.cpp : �������̨Ӧ�ó������ڵ㡣
//

//#include "stdafx.h"
#include"iostream"
#include"cmath"
#include"stdio.h"
#include "algorithm"
using namespace std;

bool modd(int m,int k)
{
	int n,i;
	n = m;
	for(i = 2;i*i<=n;i++)
	{
		if(m%i==0&&(i>=k||m/i>=k))
		{
			return true;
		}
	}
	return false;
}

int main()
{
	int n,m,k;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF)
	{
		if(n%2==0)
		{
			printf("Marsel\n");
		}
		if(k==1)
		{
			if(m>1)
			{
				printf("Timur\n");
			}
			else
			{
				printf("Marsel\n");
			}
		}
		int i = 2;
		if(modd(m,k))
		{
			printf("Timur\n");
		}
		else
		{
			printf("Marsel\n");
		}
	}
	return 0;
}

#include<cstdio>
using namespace std;
int main()
{
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	//printf("-1");
	if(!n^1)
	{
		printf("Marsel");
		return 0;
	}
	for(int i=2;i*i<=m;i++)
	{
		if(m%i==0&&(i>=k||m/i>=k))
		{
			printf("Timur");
			return 0;
		}
	}
	printf("Marsel");
}

#include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#include "callable.hpp/callable.hpp"
#endif
#define endl '\n'
using namespace std;
using ll = long long;
int n, m, k;
map<int, bool> memo;
bool win(int m) {
    if(not memo.count(m)) {
        bool ans = false;
        for(int i = 2; i * i <= m; i++) {
            ans |= m % i == 0 and i >= k and (m / i % 2 == 0 or not win(i));
            ans |= m % i == 0 and m / i >= k and (i % 2 == 0 or not win(m / i));
        }
        memo[m] = ans;
    }
    return memo[m];
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n >> m >> k;
    if(n % 2 == 0) {
        cout << "Marsel" << endl;
    } else {
        cout << (win(m) ? "Timur" : "Marsel") << endl;
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
vector<int> divit;
int k, n, m;
short int memo[32000][34][2];

void win(int l, int turn, int p, int num) {
    if (divit[l] < k) {
        memo[l][turn][(p + 1) % 2] = 1;
        memo[l][turn][p] = 0;
        return;
    }
    if (divit[l] == k) {
        memo[l][turn][(p + 1) % 2] = 0;
        memo[l][turn][p] = 1;
        return;
    }
    if (memo[l][turn][p] != -1) return;
    for (int i = 0; i < divit.size(); i++) {
        if (divit[l] % divit[i] != 0) continue;
        int t = divit[l] / divit[i];
        if(t==1) {
            if(k==1) {memo[divit.size()][turn][(p+1)%2]=0;memo[divit.size()][turn][p]=1;}
            else {memo[divit.size()][turn][(p+1)%2]=1;memo[divit.size()][turn][p]=0;}
            continue;
        }
        int ele = lower_bound(divit.begin(), divit.end(), t) - divit.begin();
        if (t <= k) win(ele, turn, p, num);
            //if(t <k  ) {memo[ele][turn][(p+1)%2]=1;memo[ele][turn][p]=0;continue;}
            //if(t==k) {memo[ele][turn][(p+1)%2]=0;memo[ele][turn][p]=1;continue;}
        else {
            p += num % 2;
            p %= 2;
            win(ele, turn + 1, p, t);
        }
    }
}

int main() {
   // freopen("in", "r", stdin);
    int tc = 0;
    while (scanf("%d %d %d", &n, &m, &k) != EOF) {
       // printf("Test case  %d ", ++tc);
        if (m <= k) {
            printf("Marsel\n");
            continue;
        }
        divit.clear();
        memset(memo, -1, sizeof memo);
        for (int i = 2; i <= sqrt(m) + 1; i++)
            if (m % i == 0) divit.push_back(i);
        if (m != 2) {
            int s = divit.size();
            if (s>0 && m == (m / divit[s - 1])*(m / divit[s - 1])) s--;
            for (int i = s - 1; i >= 0; i--)
                divit.push_back(m / divit[i]);
            divit.push_back(m);
        }
        // for(int i=0;i<divit.size();i++)printf("%d ",divit[i]);
        //  printf("\n");
        win(divit.size() - 1, 1, 0, n);
        bool test = 0;
        for (int i = 0; i <= divit.size(); i++) {
            if (test) break;
            for (int k = 1; k <= 32; k++) {
                if (test) break;
                if (memo[i][k][0] == 1) {
                    printf("Timur\n");
                    test = 1;
                }
            }
        }
        if (!test)
            printf("Marsel\n");
    }
    return 0;

}

#include<bits/stdc++.h>
#define ll long long
#define inf (ll)1000000000000000000
#define mod 1000000007
#define maxn 2010

using namespace std;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	ll n,m,k;
	cin>>n>>m>>k;
	if(n%2==0)
	{
		cout<<"Marsel";
	}else if(m==1)
	{
		cout<<"Marsel";
	}else if(k==1)
	{
		cout<<"Timur";
	}else
	{
		vector<ll> factors;
		for(int i=2;i<=sqrt(m);i++)
		{
			if(m%i==0)
			{
				if(m/i!=i)
				{
					factors.push_back(i);
					factors.push_back(m/i);
				}else
				{
					factors.push_back(i);
				}
			}
		}
		factors.push_back(m);
		for(int i=0;i<factors.size();i++)
		{
			if(factors[i]%2&&factors[i]<=m/k)
			{
				cout<<"Timur";
				return 0;
			}
		}
		cout<<"Marsel";
	}
}

#include <bits/stdc++.h>

using namespace std;
bool check =false;
long long n,m,k,i,cnt=0;
int main()
{

    cin>>n>>m>>k;
    cnt=0;
    while(1)
    {

            for(i=k;i<=sqrt(m)+190 && i<m ;i++)
            {
                if(m%i==0)
                {
                    check=true;
                    m=i;
                }
            }

             if(n%2==1)
                cnt++;

            if(check==false)
            {
                goto label;
            }

            check=false;

    }

    label:if( cnt%2==1)
    {
        cout<<"Timur"<<endl;
        return 0;
    }

    else
    {
        cout<<"Marsel"<<endl;
    }
    return 0;
}

#include <stdio.h>
int main()
{
	int n, m, k, i;
	scanf("%d%d%d", &n, &m, &k);
	if(n&1)
	{
		for(i=2; i*i<=m; i++)
			if(m%i==0)
			{
				if(m/i>=k)
					printf("Timur");
				else
					printf("Marsel");
				return 0;
			}
		if(k==1)
			printf("Timur");
		else
			printf("Marsel");
	}
	else
		printf("Marsel");
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
	int n, m, k, c;
	cin>>n>>m>>k;
	c=0;
	for(int i=k; i<(m/2)+1;i++){
		if(m%i==0){
			c++;
			break;
		}
	}
	if(c==0) cout<<"Marcel";
	else if(n%2==0) cout<<"Marcel";
	else cout<<"Timur";
	return 0;
}

/****************************************
**     Solution by Bekzhan Kassenov    **
****************************************/

#include <bits/stdc++.h>

using namespace std;

#define F first
#define S second
#define MP make_pair
#define all(x) (x).begin(), (x).end()

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const int LIM = 1000 * 1000 * 10;

template <typename T>
inline T sqr(T n) {
    return n * n;
}

int n, m, k;
map <int, int> f;

int grundy(int n) {
    if (f.count(n)) {
        return f[n];
    }

    if (n < k) {
        return 0;
    }

    vector <int> temp;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            int x = 0, cnt = 0;

            if (i >= k) {
                x = i, cnt = n / i;
                if (cnt & 1) {
                    temp.push_back(grundy(x));
                } else {
                    temp.push_back(0);
                }
            }

            if (n / i >= k) {
                x = n / i, cnt = i;
                if (cnt & 1) {
                    temp.push_back(grundy(x));
                } else {
                    temp.push_back(0);
                }
            }
        }
    }

    sort(all(temp));
    temp.resize(unique(all(temp)) - temp.begin());

    f[n] = -1;

    for (int i = 0; ; i++) {
        if (!binary_search(all(temp), i)) {
            f[n] = i;
            break;
        }
    }

    //printf("f[%d]=%d\n", n, f[n]);

    return f[n];
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif

    scanf("%d%d%d", &m, &n, &k);

    int x = 0;

    if (m & 1) {
        x = grundy(n);
    }

    if (x != 0) {
        puts("Timur");
    } else {
        puts("Marsel");
    }

    return 0;
}

#include <bits/stdc++.h>

using namespace std;
bool check =false;
long long n,m,k,i,cnt=0;
int main()
{
    cin>>n>>m>>k;

    while(1)
    {
       // cout<<"jvdfi\n";
            for(i=k;i<=sqrt(m) ;i++)
            {
                if(m%i==0)
                {
                    check=true;
                    m=i;
                }
            }

            if(check==false)
            {
                goto label;
            }

            check=false;

            cnt++;

            if(n%2==0)
            {
                cnt++;
            }

           // cout<<"jvdfi\n";
    }

    label:if( cnt%2==1)
    {
        cout<<"Timur";
        return 0;
    }

    else
    {
        cout<<"Marsel";
    }
    return 0;
}

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <cstdio>

using namespace std;

map <int,int> mp;
int n,m,k;

int cal(int x){
  if(mp.find(x)!=mp.end()) return mp[x];
  set <int> s;
  for(int i=2;i*i<=x;++i)
    if(x%i==0){
       if(i>=k && (x/i)>=2) {
          if((x/i)%2==0)  s.insert(0); else s.insert(cal(i));
       }
       if((x/i)>=k && (i)>=2) {
          if(i%2==0) s.insert(0); else s.insert(cal(x/i));
       }
    }
  int r = 0;
  while(s.find(r)!=s.end()) ++r;
  mp[x] = r;
  return r;
}

int main(){
   scanf("%d%d%d",&n,&m,&k);
   if(n%2==0) printf("Marsel\n");
   else {
      int x = cal(n);
      if(x) printf("Marsel\n");
      else printf("Timur\n");
   }
   return 0;
}

#include<bits/stdc++.h>

using namespace std;

int n,m,k;

int f(int x) {
    set<int>ase;

    if(x%2==0 && x/2 >= k) ase.insert(0);
    int sq = sqrt(x);
    for(int d=3; d<=sq; d+=2) {
        if(x%d) continue;
        int q = x/d;
        if(q >= k) ase.insert(f(q));
        if(d >= k) ase.insert(f(d));
    }
    if(1 >= k && x%2) ase.insert(0);

    int mex = 0;
    for(auto it : ase) {
        if(it == mex) mex++;
        else return mex;
    }
    return mex;
}

int main() {
    scanf("%d %d %d", &n,&m,&k);
    if(n%2==0) printf("Marsel\n");
    else {
        if(f(m)) printf("Timur\n");
        else printf("Marsel\n");
    }
}

///830273749 999999937 1

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>

using namespace std;

int Euler_Function(int N)
{
    int ans = N;
    for (int i = 2 ; i * i <= N ; i ++ )
        if ( N % i == 0 )
        {
            ans -= ans/i;
            while ( N % i == 0 )
                N /= i ;
        }
    if ( N != 1 )
        ans -= ans/N;
    return ans;
}

int Binary_ModPow(int a , int b , int m)
{
    int res = 1;
    while ( b )
    {
        if ( b & 1 )
            res = (res * a) % m , b -- ;
        else
            a = (a * a) % m , b >>= 1;
    }
    return res % m;
}

void Decomposition(int N , vector <int> &prime , vector <int> &pows)
{
    for (int i = 2 ; i * i <= N ; i ++ )
        if ( N % i == 0)
        {
            pows.push_back(0);
            while ( N % i == 0 )
            {
                N /= i;
                pows.back() ++ ;
                prime.push_back(i);
            }
        }
    if ( N != 1 )
    {
        prime.push_back(N);
        pows.push_back(1);
    }
}

int gcd (int a , int b)
{
    for (int save = a ; b ;
             save = a , a = b , b = save % b
    );
    return a;
}

int lcm(int a , int b)
{
    return a * b /
           gcd(a , b);
}

int Eratosphen(int n)
{
    int prime[100000000];
    memset(prime , true , sizeof (prime) );
    prime[0] = prime[1] = false;
    for (int i = 2 ; i * i <= n ; i ++ )
        if ( prime[i] )
            for (int j = 2 * i ; j <= n ; j += i )
                prime[j] = false;
    int ans = 0;
    for (int i = 1 ; i <= n ; i ++ )
        if ( prime[i] )
            ans ++ ;
    return ans;
}

void normalize(int &a ,int &b)
{
    int GCD = gcd ( a , b );
        a /= GCD;
        b /= GCD;
}

int System_Number(int a, int b)
{
    if ( a == 0 ) return 1;
        int ans = 0;
        for (; a ; a /= b , ans ++ );
    return ans;
}

void Get_Min_System(int a , int &Min)
{
    for (; a ; a /= 10 )
        Min = max ( a%10 + 1 , Min );
}

int Translate(int a , int system)
{
    int answer = 0 , Power = 1;
    for (; a ; Power *= system , a /= 10)
        answer += (a % 10) * Power;
    return answer;
}

long long n , m , k;

void main()
{
    cin >> n >> m >> k;
    if ( n % 2 == 0 ) printf("Marsel\n");
    else
    {
        if ( k == 1 ) printf("Timur\n");
        else
        {
        for (int i = 2 ; i * i <= m ; i ++ )
            if ( m % i == 0 && (m / i) >= k  )
            {
                printf("Timur\n");
                return;
            }
        printf("Marsel\n");
        }
    }//225 187 20
    cin.get();
    cin.get();
}

#define _CRT_SECURE_NO_WARNINGS

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <list>
#include <set>
#include <tuple>
#include<iterator>
#include<numeric>
#include <utility>
using namespace std;

#ifdef LUNAWYLL
#define dbg(x) cout << #x << " = " << (x) << endl;
#define dbg2(a, b) cout << #a << " = " << (a) << "; " \
        << #b << " = " <<(b) << endl;
#define dbgt(a) cout << (a) << endl;
#else
#define dbg(...) (void(1))
#define dbg2(...) (void(1))
#define dbgt(...) (void(1))
#endif
#define endl "\n"

#define all(v) (v.begin()), (v.end())

void task();

int main() {

    /*
    freopen("input.txt", "w", stdout);
    cout << string(100000, '1');
    return 0;
    cout << "500 500" << endl;
    srand(unsigned(time(0)));
    for (int i = 0; i < 500; ++i) {
    for (int j = 0; j < 500; ++j)
    cout << rand() << ' ';
    cout << endl;
    }
    return 0;
    // */
#ifdef LUNAWYLL
    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
#endif

    task();

#ifdef LUNAWYLL
    cout << "\n---------------------\n";
    cout << clock() * 1000 / CLOCKS_PER_SEC << "ms";
#endif
    return 0;
}

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vector<int> > vvi;
typedef vector<vector<long long> > vvll;
typedef vector<long long> vll;
typedef long long int llint;

const long long INF = (long long)1e18;
const int N = (int)2e5 + 10;
const int MODULO = (int)1e9 + 7;

void task() {
    int n, m, k;
    scanf("%d %d %d", &n, &m, &k);
    if (n % 2 == 0){
        printf("Marsel");
    } else{
        for (int i = 2; i*i < m; ++i){
            if (m % i == 0 && (i >= k || m/i >= k)){
                printf("Timur");
                return;
            }
        }
        if (k == 1 && m > 1)
            printf("Timur");
        else
            printf("Marsel");
    }
    return;
}

#include <cstdio>

using namespace std;
int n,m,k;

bool can()
{
 for (int i=2; i*i<=m; i++)
  if (m % i == 0 && m / i >= k) return 1;
 return 0;
}

bool solve()
{
 if (!can()) return 0;
 if (n % 2 == 0) return 0;
 return 1;
}

int main() {
 scanf("%d%d%d",&n,&m,&k);
 puts(solve()?"Timur":"Marsel");
 return 0;
}

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main() {
    long long n, m, k, i;
    while (scanf("%lld%lld%lld", &n, &m, &k) != EOF) {
        bool flag = 0;
        if (n % 2 == 1) {
            for (i = k; i < m; i++) {
                if (m % i == 0) {
                    flag = 1;
                    break;
                }
            }
        }
        if (flag) printf("Timur\n");
        else printf("Marsel\n");
    }
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,a,b=0,c=0,d=0;
    cin>>n>>m>>k;vector<long long>vec;bool hna=false;
    if (n%2==0){
        cout<<"Marsel"<<endl;
    }
    else{
        for (int i=k;i<m;i++){
                for (int j=2;j<m;j++){
            if (i*j==m){
                hna=true;
                break;
            }
        }
        }
        if (hna&&m!=1){
           cout<<"Timur"<<endl;
        }
        else{
        cout<<"Marsel"<<endl;

        }
    }
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;
int n,m,k;
bool div ()
{
 for(int i=2; i<sqrt(m)+1;i++)
    if (m% i==0)
      { if (k<=i || k<=m/i) return 1;}
    return 0;
}
int main ()
{

  cin>>n>>m>>k;
  if (n%2==0)
    cout<<"Marsel";
  else if (div())
    cout<<"Timur";
  else cout<<"Marsel";
}

#include<cstdio>
#include<cstring>
#define maxn 110
using namespace std;
int n,m,k;
bool flag;
bool isPrime(int x)
{
    for(int i=2;i*i<=x;i++)
    {
        if(x%i==0) {
            if(x/i>=k) flag=true;
            return false;
        }
    }
    return true;
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        if(n&1){
            bool flag=false;
            for(int i=2;i*i<=m;i++)
                if(m%i==0)
                    if(i>k || m/i>k) {
                        flag=true;
                        break;
                    }
            if(flag) printf("Timur\n"); else printf("Marsel\n");
        }else printf("Marsel\n");
    }
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <cmath>
#include <sstream>
#include <queue>

using namespace std;

#define TM 100010

int main() {

	int n, m, k;
	scanf(" %d %d %d", &n, &m , &k);
	if(n % 2 == 0) {
		cout << "Marsel" << endl;
	} else {

		int flag = false;
		for(int i = 2; i < TM; i++) {
			if(m % i == 0 && i > k) {
				flag = true;
			}
			else if(m % i == 0 && m/i > k) {
				flag = true;
			}
		}
		if(flag)cout << "Timur" << endl;
		else cout << "Marsel" << endl;

	}

	return 0;
}

#include <iostream>

using namespace std;

int main(){
	int n, m, k, least = 2e9,t;
	cin >> n >> m >> k;

	for(int i = 2; 1ll * i * i <= m; ++i){
		if(m % i == 0){
			if(i < least && i >= k) least = i;
			t = m / i;
			if(t < least && t >= k) least = t;
		}
	}
	if(k == 1) least = 1;

	if(n % 2 == 0 || least == 2e9) cout << "Marsel";
	else cout << "Timur";

	return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

#define inp_s     ios_base::sync_with_stdio(false)
#define DRT()     int test_case;cin>>test_case;while(test_case--)

#define VI        vector<int>
#define VS        vector<string>
#define VLL       vector<LL>
#define PII       pair<int,int>
#define all(c)    c.begin(),c.end()
#define sz(c)     (int)c.size()
#define clr(c)    c.clear()
#define pb        push_back
#define mp        make_pair

#define cin(x)     scanf("%d",&x)

#define FOR(i,a,b)      for(int i=(int)(a);i<(int)(b);i++)
#define RFOR(i,a,b)     for(int i=(int)(b)-1;i>=(int)(a);i--)

#define MOD       1000000007
#define EPS       1E-10

#define PI  acos(-1)

#define CASE(x)   cout << "Case #" << x << ": ";

int main()
{
    int n,m,k;
    cin >> n >> m >> k;
    if(n%2 == 0) cout << "Marsel" << endl;
    else
    {
        int poss = 0;
        for(int i = 1; i*i <= m; i++)
        {
            if(m%i) continue;
            if(m/i >= k && i != 1)
                poss = 1;
        }
        if(poss) cout << "Timur" << endl;
        else cout << "Marsel" << endl;
    }
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

void rwFile() {
    freopen("INP.inp", "r", stdin);
    freopen("OUT.out", "w", stdout);
}

void solveC_Multiplicity() {
    const int maxN = 1e3 + 5;
    const int MOD = 1e9 + 7;
    vector<int> div[maxN];
    int Size[maxN];
    memset(div, 0, sizeof(div));
    memset(Size, 0, sizeof(Size));
    for (int i = 2; i < maxN; i++) {
        for (int j = i; j < maxN; j += i) {
            div[j].push_back(i);
            Size[j]++;
        }
    }
    int n; cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++) cin >> arr[i];
    long long res[maxN];
    memset(res, 0, sizeof(res));
    for (int i = 0; i < n; i++) {
        int t = arr[i];
        for (int j = Size[t] - 1; j >= 0; j--) {
            //cout << div[t][j] << '\n';
            res[div[t][j]] += res[div[t][j] - 1];
            res[div[t][j]] %= MOD;
        }
        res[1]++;
    }
    long long ans = 0;
    for (int i = 0; i <= n; i++) ans = (ans + res[i]) % MOD;
    //for (int i = 0; i <= n; i++) cout << Size[i];
    //for (int i = 0; i <= n; i++) cout << res[i] << ' ';
    cout << ans;
}

const long long MOD = 1e9 + 9;

long long Pow(long long b, long long e = MOD - 2) {
    if (e == 0) return 1LL;
    long long x = Pow(b, e / 2);
    if (e % 2 == 0) return x * x % MOD;
    return (x * x % MOD) * b % MOD;
}

void solveA_AlternatingSum() {
    long long n, a, b, k;
    cin >> n >> a >> b >> k;
    int s[k];
    string ss; cin >> ss;
    for (int i = 0; i < k; i++) {
        if (ss[i] == '+') s[i] = 1;
        else s[i] = -1;
    }
    if (Pow(a, k) == Pow(b, k)) {
        long long tot = 0;
        for (int i = 0; i < k; i++) {
            tot += s[i] * Pow(b, i) * Pow(a, k - 1 - i) % MOD;
            tot %= MOD;
        }
        long long res = tot * (n + 1) / k * Pow(a, n + 1 - k) % MOD;
        res = (res + MOD) % MOD;
        cout << res;
        return;
    }
    //if (b > a) swap(a, b);
    long long res = 0;
    long long tmp = (Pow(a, n + 1) - Pow(b, n + 1) + MOD) % MOD;
    //cout << tmp << ' ';
    tmp = tmp * Pow((Pow(a, k) - Pow(b, k) + MOD) % MOD) % MOD;
    //cout << tmp << " ";
    for (int i = 0; i < k; i++) {
        long long temp = Pow(b, i) * Pow(a, k - 1 - i) % MOD;
        temp = temp * tmp % MOD;
        if (s[i] == -1) temp = MOD - temp;
        res = (res + temp) % MOD;
    }
    cout << res;
}

long long GCD, X, Y;
void extendedEuclid(long long A, long long B) {
    if (B == 0) {
        GCD = A;
        X = 1;
        Y = 0;
    }
    else {
        extendedEuclid(B, A % B);
        long long temp = X;
        X = Y;
        Y = temp - (A / B) * Y;
    }
}

long long gcd(long long a, long long b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}

void solveC_Line() {
    long long a, b, c;
    cin >> a >> b >> c;
    long long A = abs(a), B = abs(b), C = abs(c);
    if (C % gcd(A, B) != 0) {
        cout << -1;
        return;
    }
    extendedEuclid(A, B);
    if (a < 0) X = -X;
    if (b < 0) Y = -Y;
    long long tmp = -c / gcd(A, B);
    cout << X * tmp << " " << Y * tmp;
}

const long long MOD1 = 1e9 + 7;

long long Pow1(long long b, long long e = MOD1 - 2) {
    if (e == 0) return 1LL;
    long long x = Pow1(b, e / 2);
    if (e % 2 == 0) return x * x % MOD1;
    return (x * x % MOD1) * b % MOD1;
}

const int maxN = 3e6 + 1;
int prime[maxN];
long long F[maxN];

long long Ff(long long tmp) {
    long long add = 0;
    long long imod2 = (MOD1 + 1) / 2;
    while (tmp != 1) {
        int p = prime[tmp];
        long long nn = (imod2 * tmp % MOD1) * (p - 1) % MOD1;
        add = (add + nn) % MOD1;
        tmp /= p;
    }
    return add;
}

void solveD_MyPrettyGirlNoora() {
    for (int i = 2; i * i < maxN; i++) {
        if (prime[i] == 0) {
            for (int j = i * i; j < maxN; j += i) {
                if (prime[j] != 0) prime[j] = min(prime[j], i);
                else prime[j] = i;
            }
        }
    }
    for (int i = 2; i < maxN; i++) {
        if (prime[i] == 0) prime[i] = i;
    }
    //for (int i = 2; i < 100; i++) if (prime[i] == i) cout << i  << '\n';
    //long long imod2 = (MOD1 + 1) / 2;
    F[1] = 0;
    for (long long i = 2; i < maxN; i++) {
        F[i] = F[i / prime[i]] + (i * (prime[i] - 1) / 2 % MOD1);
        F[i] %= MOD1;
    }
    long long t, l, r;
    cin >> t >> l >> r;
    long long T = 1;
    long long res = 0;
    for (int i = l; i <= r; i++) {
        //cout << add << ' ';
        res = (res + T * F[i]) % MOD1;
        res %= MOD1;
        T = T * t % MOD1;
    }
    cout << res;
}

void solveC_VasilyTheBearAndSequence() {
    int n; cin >> n;
    int arr[n];
    int check[32];
    for (int i = 0; i < 32; i++) check[i] = 4294967295;
    vector<int> res[32];
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
        int tmp = arr[i];
        int c = 0;
        while (tmp != 0) {
            if (tmp % 2 == 1) {
                check[c] &= arr[i];
                res[c].push_back(arr[i]);
            }
            c++;
            tmp /= 2;
        }
    }
    long long pow2[32];
    pow2[0] = 1;
    for (int i = 1; i < 32; i++) pow2[i] = 2 * pow2[i - 1];
    for (int i= 31; i >= 0; i--) {
        if (check[i] == pow2[i]) {
            cout << res[i].size() << '\n';
            for (int j : res[i]) cout << j << ' ';
            break;
        }
    }
}

void solveC_BeaverGame() {
    long long n, m, k;
    cin >> n >> m >> k;
    int fmove = 0;
    for (int i = 1; i * i <= m; i++) {
        if (m % i != 0) continue;
        if (i >= k || m / i >= k) {
            fmove = 1;
            break;
        }
    }
    if (k == 1 && m != 1) fmove = 1;
    if (fmove == 0) {
        cout << "Marsel";
        return;
    }
    if (n % 2 == 1) cout << "Timur";
    else cout << "Marsel";
}

void solveD_IceSculptures() {
    int n; cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++) cin >> arr[i];
    if (n == 4) {
        long long res = 0;
        for (int i = 0; i < n; i++) res += arr[i];
        cout << res;
        return;
    }
    long long res = 0;
    for (int i = 1; i * i <= n; i++) {
        if (n % i != 0) continue;
        for (int j = 0; j < i; j++) {
            long long tmp = 0;
            for (int k = 0; j + k * i < n; k++) tmp += arr[j + k * i];
            res = max(res, tmp);
        }
        if (i == 1 || i == 2) continue;
        for (int j = 0; j < n / i; j++) {
            long long tmp = 0;
            for (int k = 0; j + k * n / i < n; k++) tmp += arr[j + k * n / i];
            res = max(res, tmp);
        }
    }
    cout << res;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(nullptr); cout.tie(nullptr);
    //rwFile();
    ///solveC_Multiplicity();
    ///solveA_AlternatingSum();
    ///solveC_Line();
    ///solveD_MyPrettyGirlNoora();
    ///solveC_VasilyTheBearAndSequence();
    solveC_BeaverGame();
    ///solveD_IceSculptures();
}

#include <bits/stdc++.h>
using namespace std;
map<int, int> factor;
int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	int n, m, k;
	cin >> n >> m >> k;
	if(n % 2 == 0 or m <= k) {
		cout << "Marsel" << endl;
		return 0;
	}
	bool flag = 0;
	for(int i = 2; i*i <= m; ++i)
		if(m % i == 0)
			if(m / i >= k)
				flag = 1;
	if(flag) cout << "Timur" << endl;
	else cout << "Marsel" << endl;
	return 0;
}

/*
***************************************************************
Author           : Ishan Dutta
Email            : ishandutta2007@gmail.com
Facebook         : http://www.facebook.com/ishan.dutta
Blog             : tessellationsoftechnology.wordpress.com
Topcoder Handle  : Ishandutta2007
Codeforces Handle: ishandutta2007
Codechef Username: ishandutta2007
Spoj Username    : ishandutta2007
UVA Username     : ishandutta2007
***************************************************************
*/
/* ***************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/\_/---Headers---\_/\_/\_/\_/\_/\_/\_/\_/
/* ***************************************************************** */

//C headers
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<cstdio>
#include<ctime>
#include<cctype>
#include<cassert>
#include<climits>
#include<cerrno>
#include<cfloat>
#include<ciso646>
#include<clocale>
#include<csetjmp>
#include<csignal>
#include<cstdarg>
#include<cstddef>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cwchar>
#include<cwctype>

//containers
#include<vector>
#include<list>
#include<map>
#include<queue>
#include<deque>
#include<set>
#include<complex>
#include<string>
#include<stack>
#include<bitset>
#include<istream>
#include<valarray>

//IOs
#include<iostream>
#include<sstream>
#include<iomanip>
#include<fstream>
#include<exception>
#include<ios>
#include<iosfwd>
#include<ostream>
#include<iterator>
#include<stdexcept>
#include<streambuf>

//algorithm & miscellaneous
#include<algorithm>
#include<functional>
#include<numeric>
#include<utility>
#include<limits>
#include<locale>
#include<memory>
#include<new>

/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/---Frequently used macros---\_/\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */

#define MOD 1000000007
#define INF 1000000000

/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/\_/\_/\_/---Shorthands---\_/\_/\_/\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */

#define ll long long
#define F first
#define S second
#define pb push_back

#define SZ(c) (c).size()
#define reset(x) memset((x),0,sizeof(x));
#define negset(x) memset((x),-1,sizeof(x));
#define set(x) memset((x),1,sizeof(x));

#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort(ALL(x))
#define REVERSE(c) reverse(ALL(c))

#define FOR(i,a,b) for(int i=(int)(a);i<=(int)(b);i++)
#define REP(i,n) FOR(i,0,(n-1))

#define FORD(i,a,b) for(int i=(int)(a);i>=(int)(b);i--)
#define REPD(i,n) FOR(i,(n-1),0)

#define tst int t;scanf("%d",&t);while(t--)
#define s(x) scanf("%d",&x)
#define sl(x) scanf("%lld",&x)
#define ss(x) scanf("%s",x)

#define p(x) printf("%d",x)
#define pl(x) printf("%lld",x)
#define ps(x) printf("%s",x)

#define pn(x) printf("%d\n",x)
#define pln(x) printf("%lld\n",x)
#define psn(x) printf("%s\n",x)

#define sp system("PAUSE")

/* ****************************************************************** */
// \_/\_/\_/\_/\_/---Fast IO using getchar_unlocked---\_/\_/\_/\_/\_/
/* ****************************************************************** */
/*
int gi(){
   int c = 'a';
   while (!(c >= '0' && c <= '9') && c != '-') c = getchar_unlocked();//();//
   int c2;
   if (c != '-')
     c2 = c;
   else
     c2 = '0';
   int res = 0;
   while((c2 >= '0' && c2 <= '9')){
     res = (res << 3) + (res << 1) + (c2 - '0');
     c2 = getchar_unlocked();//();//
   }
   return res * (c == '-' ? -1 : 1);
}
*/
using namespace std;
/* ****************************************************************** */
// \_/\_/\_/\_/\_/\_/---Actual Code Starts Here---\_/\_/\_/\_/\_/\_/
/* ****************************************************************** */
int n,m,k;
bool fact(){
  int s=int(sqrt(k));
  for(int i=2;i<=min(s,k/m);i++)
      if(k%i==0)return true;
  return false;
}
int main(){
  s(n);s(m);s(k);
  if(n&1 && fact())cout<<"Timur";
  else cout<<"Marsel";
//sp;
  return 0;
}