#include <bits/stdc++.h>
using namespace std;
//template <class T> int size(const T &x) { return x.size(); }
#define rep(i,a,b) for (auto i=(a); i<(b); ++i)
#define iter(it,c) for (auto it = (c).begin(); it != (c).end(); ++it)
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<vi> vvi;
typedef long long ll;
const int INF = 2147483647;

int m_left;

int rand(int a, int b) {
    return rand() % (b-a+1) + a;
}

double bias;
vi rand_n_sorted(int a, int b, int n) {
    set<int> found;
    while (found.size() < n) {
        if (rand() * 1.0 / RAND_MAX < bias) {
            int d = rand(0,2),
                s = rand(0,1);

            int x = s == 0 ? a + d : b - d;
            if (a <= x && x <= b) {
                found.insert(x);
            }
        } else {
            found.insert(rand(a,b));
        }
    }
    return vi(found.begin(), found.end());
}

set<int> used_ids;
int new_id() {
    while (true) {
        int x = rand(1, 1000000000);
        if (used_ids.insert(x).second) {
            return x;
        }
    }
}

int main(int argc, char *argv[]) {
    int n = atoi(argv[1]);
    m_left = atoi(argv[2]);
    bias = atof(argv[3]);
    bool priority = strcmp(argv[4], "priority") == 0;
    srand(atoi(argv[argc-1]));

    vi color(n);
    rep(i,0,n) {
        color[i] = rand() % 2;
    }

    vii edges;
    vector<ii> intervals_v = {{0,n-1}};
    priority_queue<tuple<int,int,int,int> > intervals_p;
    intervals_p.push({ n, rand(), 0, n-1 });
    vector<vi> registrations(n);

    while (m_left) {
        int l, r;
        if (priority) {
            if (intervals_p.empty()) break;
            l = get<2>(intervals_p.top());
            r = get<3>(intervals_p.top());
            intervals_p.pop();
        } else {
            if (intervals_v.empty()) break;
            int idx = rand() % intervals_v.size();
            l = intervals_v[idx].first;
            r = intervals_v[idx].second;
            swap(intervals_v[idx], intervals_v.back());
            intervals_v.pop_back();
        }

        vi sel;
        rep(tries,0,10) {

            int count = m_left == 1 || r-l+1 == 1 || rand() % 50 == 0 ? 1 :
                m_left == 2 || r-l+1 == 2 || rand() % 2 == 0 ? 2 :
                3;

            sel = rand_n_sorted(l,r, count);

            bool ok = true;
            rep(i,0,sel.size()) {
                rep(j,i+1,sel.size()) {
                    if (color[sel[i]] == color[sel[j]]) {
                        ok = false;
                    }
                }
            }
            if (ok) {
                break;
            }
        }

        m_left -= sel.size();

        rep(i,0,sel.size()) {
            rep(j,i+1,sel.size()) {
                if (color[sel[i]] != color[sel[j]]) {
                    edges.push_back(ii(sel[i],sel[j]));
                }
            }
        }

        sel.push_back(r);
        reverse(sel.begin(), sel.end());
        sel.push_back(l);
        reverse(sel.begin(), sel.end());

        set<ii> ivs;
        for (int i = 0; i+1 < sel.size(); i++) {
            int a = sel[i],
                b = sel[i+1];
            ivs.insert({a,b});
        }
        iter(it,ivs) {
            if (it->first < it->second) {
                if (priority) {
                    intervals_p.push({  it->second-it->first+1, rand(), it->first, it->second });
                } else {
                    intervals_v.push_back(*it);
                }
            }
        }
    }

    vi fire(n), hire(n);

    iter(it,edges) {
        hire[it->first]++;
        fire[it->second]++;
    }

    random_shuffle(edges.begin(), edges.end());
    iter(it,edges) {
        int rem = 1000000 - max(hire[it->first], fire[it->second]);
        int add = rand() % (rem+1);
        hire[it->first] += add;
        fire[it->second] += add;
    }

    cout << n << endl;
    rep(i,0,n) {
        cout << fire[i] << " " << hire[i] << endl;
    }

    return 0;
}