#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);
    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> used1(n, 0), used2(n, 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 (!used1[c[i].first]) {
            g[c[i].first].pb({2 * n, ind});
            g[2 * n].pb({c[i].first, ind});
            ind++;
        }
        if (!used2[c[i].second]) {
            g[c[i].second].pb({2 * n + 1, ind});
            g[2 * n + 1].pb({c[i].second, ind});
            ind++;
        }
    }
    ban.assign(ind, 0);
    int start = -1;
    for (int i = 0; i < 2 * n + 2; i++) {
        if (g[i].size() % 2) {start = i; continue;}
        if (start == -1 && g[i].size()) start = i;
    }
    euler(start);
    int ps = p.size();
    map<pii, string> ans;
    bool color = 0;
    cout << ps << "\n";
    for (int i = 0; i < ps - 1; i++) {
        if (p[i] >= 2 * n || p[i + 1] >= 2 * n) continue;
        if (p[i + 1] >= n) {
            ans[{p[i], p[i + 1] - n}] = (color ? "M" : "W");
            cout << "first: " << p[i] << " " << p[i + 1] - n << "\n";
        }
        if (p[i] >= n) {
            ans[{p[i + 1], p[i] - n}] = (color ? "M" : "W");
            cout << "second: " << p[i] - n << " " << p[i + 1] << "\n";
        }
        color = !color;
    }
    if (p[ps - 1] >= n) {
        ans[{p[0], p[ps - 1] - n}] = (color ? "M" : "W");
        cout << p[0] << " " << p[ps - 1] << "\n";
    }
    if (p[0] >= n) {
        ans[{p[ps - 1], p[0] - n}] = (color ? "M" : "W");
        cout << p[ps - 1] << " " << p[0] - n << "\n";
    }
    if (p[0] >= n && p[ps - 1] >= n) {
        ans[{p[ps - 1], p[0]}]
    }
    cout << "\n";
    for (auto k: c) {
        cout << k.first << " " << k.second << "\n";
        cout << ans[k];
    }
}
/*
 2 2
 2 1
 1 2
*/