#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <queue>
#include <cmath>
#include <algorithm>
#include <tuple>
#include <iomanip>
#include <stdio.h>
#include <numeric>
#include <map>
#include <bitset>
#include <set>
#include <stack>
#include <queue>

/*
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("section-anchors")
#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
#pragma GCC optimize("vpt")
#pragma GCC optimize("rename-registers")
#pragma GCC optimize("move-loop-invariants")
#pragma GCC optimize("unswitch-loops")
#pragma GCC optimize("function-sections")
#pragma GCC optimize("data-sections")
#pragma GCC optimize("branch-target-load-optimize")
#pragma GCC optimize("branch-target-load-optimize2")
#pragma GCC optimize("btr-bb-exclusive")
*/

#define int long long
#define ll long long
#define ull unsigned long long
#define all(a) a.begin(), a.end()
#define pii pair<int, int>
#define pb push_back
#define ld long double


using namespace std;

const int INF = 1e13;
//const int mod = 2600000069;
//const int p = 179;

int n, m;
vector<vector<pii>> g;
vector<int> pos;
vector<int> p;
vector<bool> ban;
pii u;

void euler(int v) {
    stack<int> s;
    s.push(v);
    while (!s.empty()) {
        v = s.top();
        while (pos[v] != g[v].size() && ban[g[v][pos[v]].second]) {
            pos[v]++;
        }
        if (pos[v] == g[v].size()) {
            p.pb(v);
            s.pop();
            continue;
        }
        u = g[v][pos[v]];
        ban[u.second] = 1;
        s.push(u.first);
        pos[v]++;
    }
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    freopen("painting.in", "r", stdin);
    freopen("painting.out", "w", stdout);
//    cin >> n >> m;
//    g.resize(n);
//    pos.assign(n, 0);
//    ban.assign(m, 0);
//    int a, b;
//    for (int i = 0; i < m; i++) {
//        cin >> a >> b;
//        a--;b--;
//        g[a].pb({b, i});
//        g[b].pb({a, i});
//    }
//    euler(0);
//    for (auto k : p) cout << k << " ";
    cin >> n >> m;
    g.resize(2 * n + 2);
    pos.assign(2 * n + 2, 0);
    vector<pii> c;
    c.resize(m);
    int ind = 0;
    vector<bool> used(2 * n + 2, 0);
    for (int i = 0; i < m; i++) {
        cin >> c[i].first >> c[i].second;
        c[i].first--;
        c[i].second--;
        g[c[i].first].pb({n + c[i].second, ind});
        g[n + c[i].second].pb({c[i].first, ind});
        ind++;
//        if (!used[c[i].first]) {
        g[c[i].first].pb({2 * n, ind});
        g[2 * n].pb({c[i].first, ind});
        ind++;
//        }
//        if (!used[c[i].second + n]) {
        g[c[i].second + n].pb({2 * n + 1, ind});
        g[2 * n + 1].pb({c[i].second + n, ind});
        ind++;
//        }
    }
//    if (m == 1) {
//        cout << "M";
//        return 0;
//    }
    if (g[2 * n].size() % 2) {
        g[2 * n].pb({2 * n + 1, ind});
        g[2 * n + 1].pb({2 * n, ind});
        ind++;
    }
    for (int i = 0; i < 2 * n + 2; i++) {
        sort(all(g[i]));
    }
    ban.assign(ind, 0);
    euler(2 * n);
    int ps = p.size();
    map<pii, string> ans;
    bool color = 0;
//    ans[{p[0], p[ps - 1]}] = (color ? "M" : "W");
//    ans[{p[ps - 1], p[0]}] = (color ? "M" : "W");
//    color = !color;
    for (int i = 1; i < ps; i++) {
        if (p[i] >= 2 * n || p[i - 1] >=  2 * n) continue;
        ans[{p[i], p[i - 1]}] = (color ? "M" : "W");
        ans[{p[i - 1], p[i]}] = (color ? "M" : "W");
//        cout << p[i - 1] << " " << p[i] << " " << color << "\n";
        color = !color;
    }
//    cout << "Here\n";
//    for (auto k : p) cout << k << " ";
//    cout << "\n";
    for (auto k : c) {
        cout << ans[{k.first, k.second + n}];
    }
}
/*
2 2
 2 1
 1 2

 3 5
 1 2
 2 3
 1 3
 2 1
 1 1
*/