#!/usr/bin/env python3
import random
import sys
import os
from heapq import *

BOUND = 1000000

gen = {}

gen['empty'] = lambda args: empty(int(args[0]))
def empty(n):
    return n, []

gen['only_hires'] = lambda args: only_hires(int(args[0]))
def only_hires(n):
    return n, []

gen['nested'] = lambda args: nested(int(args[0]))
def nested(n):
    l = 0
    r = n-1
    arr = []
    while l < r:
        arr.append((l,r))
        l += 1
        r -= 1
    return n, arr

gen['nested_alternating'] = lambda args: nested_alternating(int(args[0]), args[1] == 'left')
def nested_alternating(n, p):
    l = 0
    r = n-1
    arr = []
    p = True
    while l < r:
        arr.append((l,r))
        if p:
            l += 1
        else:
            r -= 1
        p = not p
    return n, arr

gen['leaning_right'] = lambda args: leaning_right(int(args[0]))
def leaning_right(n):
    l = 0
    r = n-1
    arr = []
    while l < r:
        arr.append((l,r))
        l += 1
    return n, arr

gen['leaning_left'] = lambda args: leaning_left(int(args[0]))
def leaning_left(n):
    l = 0
    r = n-1
    arr = []
    while l < r:
        arr.append((l,r))
        r -= 1
    return n, arr

gen['random_tree'] = lambda args: random_tree(int(args[0]))
def random_tree(n):
    if n == 1:
        return n, []

    seq = [ random.randint(0,n-1) for _ in range(n-2) ]
    deg = [1]*n
    for v in seq:
        deg[v] += 1

    ones = []
    for i, d in enumerate(deg):
        if d == 1:
            ones.append(i)

    heapify(ones)
    es = []
    for u in seq:
        v = heappop(ones)
        es.append((u,v))
        deg[u] -= 1
        deg[v] -= 1
        if deg[u] == 1:
            heappush(ones, u)

    u = 0
    while deg[u] != 1: u += 1
    v = u+1
    while deg[v] != 1: v += 1

    es.append((u,v))

    adj = [ [] for _ in range(n) ]
    for (u,v) in es:
        adj[u].append(v)
        adj[v].append(u)

    id = [None]*n
    id_at = [0]
    def dfs(cur, parent):
        id[cur] = id_at[0]
        id_at[0] += 1
        order = [cur]
        for v in adj[cur]:
            if v != parent:
                order.append(v)
        random.shuffle(order)
        for v in order:
            if v != cur:
                dfs(v, cur)
    
    dfs(0, -1)

    return n, [ (id[a], id[b]) for (a,b) in es ]

gen['random_tree_plus_edge'] = lambda args: random_tree_plus_edge(int(args[0]))
def random_tree_plus_edge(n):
    _, es = random_tree(n)
    while True:
        a = random.randint(0,n-1)
        b = random.randint(0,n-1)
        if a != b:
            break
    es.append((a,b))
    return n, es

gen['random_pairs'] = lambda args: random_pairs(int(args[0]), int(args[1]))
def random_pairs(n, m):
    es = []
    for i in range(m):
        while True:
            a = random.randint(0,n-1)
            b = random.randint(0,n-1)
            if a != b:
                break
        es.append((a,b))
    return n, es

def choose_k(k, l, r):
    s = set()
    while len(s) < k:
        s.add(random.randint(l, r))
    return list(sorted(s))

gen['recursive'] = lambda args: recursive(int(args[0]))
def recursive(n):
    es = []
    def rec(l, r):
        if r-l+1 <= 2:
            return
        cnt = random.randint(1, min(10, r-l-1))
        last = l
        for x in choose_k(cnt, l+1, r-1):
            es.append((last, x))
            rec(last, x)
            last = x
        es.append((last, r))
        rec(last, r)
    rec(0, n-1)
    return n, es

gen['recursive_bipartite'] = lambda args: recursive_bipartite(int(args[0]))
def recursive_bipartite(n):
    es = []
    def rec(l, r):
        if r-l-1 < 2:
            return
        cnt = random.randint(2, min(10, r-l-1))//2*2
        last = l
        for x in choose_k(cnt, l+1, r-1):
            es.append((last, x))
            rec(last, x)
            last = x
        es.append((last, r))
        rec(last, r)
    rec(0, n-1)
    return n, es


random.seed(int(sys.argv[-1]))
method = sys.argv[1]
n, es = gen[method](sys.argv[2:-1])

fire = [0] * n
hire = [0] * n
for (a,b) in es:
    if a > b:
        a,b = b,a
    hire[a] += 1
    fire[b] += 1

random.shuffle(es)
for (a,b) in es:
    if a > b:
        a,b = b,a
    add = random.randint(0, BOUND - max(hire[a], fire[b]))
    hire[a] += add
    fire[b] += add

if method == 'only_hires':
    for i in range(n):
        hire[i] = random.randint(0, BOUND)

sys.stdout.write('%d\n' % n)
for i in range(n):
    sys.stdout.write('%d %d\n' % (fire[i], hire[i]))