Stone game

/* please kill me */
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,fma")
#define ios ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ordered_set tree<pair<long long, long long>, null_type,less<pair<long long, long long>>, rb_tree_tag,tree_order_statistics_node_update>
#define mp(a, b) make_pair(a, b)
#define emplace(a) emplace_back(a)
#define sqrt(a) sqrtl(a)
#define ll long long
#define ulli unsigned long long int
#define all(v) v.begin(), v.end()
#define pii pair<int, int>
#define plli pair<ll, int>
#define s second
#define f first
const ll mod = 1e9 + 7;

/*      ADDITIONAL
ulli factorial(ulli x){
    ulli ans = 1;
    FOR(i, 2, x){
        ans *= i;
    }
    return ans;
}
ulli binocoeff(ulli n, ulli x){
    ulli ans = 1;
    for(int i = n - x + 1; i <= n; i++){
        ans *= i;
    }
    ans /= factorial(x);
    return ans;
}

ll binpow(ll a, ll b, ll m){
    if(b == 0) return 1;
    if(b % 2 == 1) return a * binpow(a, b - 1, m) % m;
    else return binpow(a * a % m, b / 2, m);
}

void primeSieve(long n){
    bool prime[1000001];//<-
    //initalize in global
    prime[1] = false;
    prime[2] = true;
    for(long i = 3; i <= n; i += 2){
        prime[i] = true;
    }
    for(long i = 2; i * i <= n; i++){
        if(prime[i]){
            for(long j = i * i; j <= n; j += 2 * i){
                prime[j] = false;
            }
        }
    }
}

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

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

void lcs(ll n, ll m, ll x){
    ll A[101], B[101], C[101];//in global
    ll dp[n + 1][m + 1][x + 1];
    FOR(i, 1, n + 1){
        FOR(j, 1, m + 1){
            FOR(k, 1, x + 1){
                if(i == 0 || j == 0 || k == 0) dp[i][j][k] = 0;
                else if(A[i - 1] == B[j - 1]) dp[i][j][k] = dp[i - 1][j - 1][k - 1] + 1;
                else dp[i][j][k] = max(dp[i - 1][j][k], max(dp[i][j - 1][k], dp[i][j][k - 1]));
            }
        }
    }
    cout << dp[n][m][x] << "\n";
}

void LIS(vector<int> const& a){
    int n = a.size();
    vector<int> d(n, 1);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (a[j] < a[i])
                d[i] = max(d[i], d[j] + 1);
        }
    }
    int ans = d[0];
    for (int i = 1; i < n; i++) {
        ans = max(ans, d[i]);
    }
    cout << ans;
}

void bfs(int node){
    q.push(node);
    visited[node] = 1;
    while(!q.empty()){
        curr = q.front();
        q.pop();
        for(auto i : arr[curr]){
            if(!visited[i]){
                q.push(i);
                visited[i] = 1;
                ancs[i] = curr;
            }
        }

    }
}

void printPath(int v){
    if(v == 0){
        cout << cnt - 1 << "\n";
        return;
    }
    cnt++;
    printPath(ancs[v]);
    cout << v << " ";
}
void dfs(int node){
    visited[node] = 1;
    for(auto i : v[node]){
        if(!visited[i]){
            dfs(i);
        }
    }
}

int frsLower(vector<int>&v, int x){
    int l = 0, r = v.size() - 1, best = -1;
    while(l <= r){
        int mid = l + (r - l) / 2;
        if(v[mid] <= x){
            best = mid;
            l = mid + 1;
        }else r = mid - 1;
    }
    return best;
}



void dijkstra(int s, vector<int> & d, vector<int> & p) {
    ///const int INF = 1000000000; < --------
    ///vector<vector<pair<int, int>>> adj; <- INITIALIZE IN GLOBAL
    int n = adj.size();
    d.assign(n, INF);
    p.assign(n, -1);
    vector<bool> u(n, false);

    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int v = -1;
        for (int j = 0; j < n; j++) {
            if (!u[j] && (v == -1 || d[j] < d[v]))
                v = j;
        }

        if (d[v] == INF)
            break;

        u[v] = true;
        for (auto edge : adj[v]) {
            int to = edge.first;
            int len = edge.second;

            if (d[v] + len < d[to]) {
                d[to] = d[v] + len;
                p[to] = v;
            }
        }
    }
}

void bellmanford()
{
    vector<int> d(n, INF);
    d[v] = 0;
    vector<int> p(n, -1);

    for (;;) {
        bool any = false;
        for (Edge e : edges)
            if (d[e.a] < INF)
                if (d[e.b] > d[e.a] + e.cost) {
                    d[e.b] = d[e.a] + e.cost;
                    p[e.b] = e.a;
                    any = true;
                }
        if (!any)
            break;
    }

    if (d[t] == INF)
        cout << "No path from " << v << " to " << t << ".";
    else {
        vector<int> path;
        for (int cur = t; cur != -1; cur = p[cur])
            path.push_back(cur);
        reverse(path.begin(), path.end());

        cout << "Path from " << v << " to " << t << ": ";
        for (int u : path)
            cout << u << ' ';
    }
}

*/

/*      SEGMENT TREE
int arr[100005], st[400005];
long gcd(long a, long b){
   return b == 0 ? a : gcd(b, a % b);
}

void build(int v, int l, int r){
    if(l == r) st[v] = arr[l];
    else{
        long long m = (l + r) / 2;
        build(2 * v, l, m);
        build(2 * v + 1, m + 1, r);
        st[v] = gcd(st[2 * v], st[2 * v + 1]);///<-
        ///dont forget to change above ------------\
    }
}

void update(int v, int l, int r, int qind, int val){
    if(l == r) st[v] = val;
    else{
        long long m = (l + r) / 2;
        if(qind <= m) update(2 * v, l, m, qind, val);
        else update(2 * v + 1, m + 1, r, qind, val);
        st[v] = gcd(st[2 * v], st[2 * v + 1]);
    }
}
int find_gcd(int v, int l, int r, int ql, int qr){
    if(l > qr || r < ql) return 1;
    if(ql <= l && r <= qr) return st[v];
    long long m = (l + r) /2;
    int fr = find_gcd(2 * v, l, m, ql, qr);
    int sc = find_gcd(2 * v + 1, m + 1, r, ql, qr);
    return gcd(fr, sc);
}
int find_min(int v, int l, int r, int ql, int qr){
    if(l > qr || r < ql) return INT_MAX;
    if(ql <= l && r <= qr) return st[v];
    long long m = (l + r) /2;
    int fr = find_min(2 * v, l, m, ql, qr);
    int sc = find_min(2 * v + 1, m + 1, r, ql, qr);
    return min(fr, sc);
}
int find_max(int v, int l, int r, int ql, int qr){
    if(l > qr || r < ql) return INT_MIN;
    if(ql <= l && r <= qr) return st[v];
    long long m = (l + r) /2;
    int fr = find_max(2 * v, l, m, ql, qr);
    int sc = find_max(2 * v + 1, m + 1, r, ql, qr);
    return max(fr, sc);
}*/

/*      LAZY SEGMENT TREE

int a[1001], st[4004], lazy[4004];
void build(int v, int l, int r){
    if(l == r) st[v] = a[l];
    else{
        ll mid = (l + r) / 2;
        build(2 * v, l, mid);
        build(2 * v + 1, mid + 1, r);
        st[v] = st[2 * v] + st[2 * v + 1];
    }
}

void push(int v, int l, int r){
    if(lazy[v] == -1) return;
    ll mid = (l + r) / 2;
    st[2 * v] += (mid - l + 1) * lazy[v];
    st[2 * v + 1] += (r - mid) * lazy[v];
    lazy[2 * v] = lazy[2 * v + 1] = lazy[v];
    lazy[v] = -1;
}

void lazy_update(int v, int l, int r, int ql, int qr, int val){
    if(qr < l || r < ql) return;
    if(l != r) push(v, l, r);
    if(ql <= l && r <= qr){
        lazy[v] = val;
        st[v] += val * (r - l + 1);
        return;
    }
    ll mid = (l + r) / 2;
    lazy_update(2 * v, l, mid, ql, qr, val);
    lazy_update(2 * v + 1, mid + 1, r, ql, qr, val);
    st[v] = st[2 * v] + st[2 * v + 1];
}

int query(int v, int l, int r, int ql, int qr){
    if(qr < l || r < ql) return 0;
    if(ql <= l && r <= qr) return st[v];
    else{
        ll mid = (l + r) / 2;
        int fr = query(2 * v, l, mid, ql, qr);
        int sc = query(2 * v + 1, mid + 1, r, ql, qr);
        return (fr + sc);
    }
}
    ///DONT FORGOR TO MEMSET LAZY ARR WITH -1
}*/

/*      SPARSE TABLE
const int K = 25;
int st[K + 1][100001];
int log2_floor(unsigned long long i) {
    return i ? __builtin_clzll(1) - __builtin_clzll(i) : -1;
}
void STBuildRMQ(){
    for(int i = 1; i <= K; i++){
        for(int j = 1; j + (1 << i) < 7; j++){
            st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
        }
    }
}
*/

/*      INT128 FUNCS
__int128 read() {
    __int128 x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}
void print(__int128 shit){
    if (shit < 0) {
        putchar('-');
        shit = -shit;
    }
    if (shit > 9) print(shit / 10);
    putchar(shit % 10 + '0');
}

_int128 binpow(_int128 a, __int128 b, __int128 m){
    if(b == 0) return 1;
    if(b % 2 == 1) return a * binpow(a, b - 1, m) % m;
    else return binpow(a * a % m, b / 2, m);
}

bool cmp(__int128 x, __int128 y) { return x > y; }
*/



void solve(){
    int a, b;
    cin >> a >> b;
    if (a == 0 || b == 0){
        cout << "Uolevi";
        return;
    }
    if(a == 1 && b == 1){
        cout << "Maija";
        return;
    }else cout << "Uolevi";
}

int main(){
    ios;
    int t = 1;
    //cin >> t;
    while(t--) solve();
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: WRONG ANSWER

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: WRONG ANSWER

Test 9

Verdict: ACCEPTED

Test 10

Verdict: WRONG ANSWER

Test 11

Verdict: ACCEPTED

Test 12

Verdict: WRONG ANSWER

Test 13

Verdict: WRONG ANSWER

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: ACCEPTED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: WRONG ANSWER

Test 19

Verdict: ACCEPTED

Test 20

Verdict: WRONG ANSWER

Test 21

Verdict: ACCEPTED

Test 22

Verdict: WRONG ANSWER

Test 23

Verdict: WRONG ANSWER

Test 24

Verdict: ACCEPTED

Test 25

Verdict: ACCEPTED

Test 26

Verdict: WRONG ANSWER

Test 27

Verdict: ACCEPTED

Test 28

Verdict: WRONG ANSWER

Test 29

Verdict: ACCEPTED

Test 30

Verdict: WRONG ANSWER

Test 31

Verdict: ACCEPTED

Test 32

Verdict: WRONG ANSWER

Test 33

Verdict: WRONG ANSWER

Test 34

Verdict: ACCEPTED

Test 35

Verdict: ACCEPTED

Test 36

Verdict: WRONG ANSWER

Test 37

Verdict: ACCEPTED

Test 38

Verdict: WRONG ANSWER

Test 39

Verdict: ACCEPTED

Test 40

Verdict: WRONG ANSWER

Test 41

Verdict: ACCEPTED

Test 42

Verdict: WRONG ANSWER

Test 43

Verdict: WRONG ANSWER

Test 44

Verdict: ACCEPTED

Test 45

Verdict: ACCEPTED

Test 46

Verdict: WRONG ANSWER

Test 47

Verdict: ACCEPTED

Test 48

Verdict: WRONG ANSWER

Test 49

Verdict: ACCEPTED

Test 50

Verdict: WRONG ANSWER

Test 51

Verdict: ACCEPTED

Test 52

Verdict: WRONG ANSWER

Test 53

Verdict: WRONG ANSWER

Test 54

Verdict: ACCEPTED

Test 55

Verdict: ACCEPTED

Test 56

Verdict: ACCEPTED

Test 57

Verdict: WRONG ANSWER

Test 58

Verdict: WRONG ANSWER

Test 59

Verdict: ACCEPTED

Test 60

Verdict: WRONG ANSWER