import java.io.*;
import java.util.*;

public class AntiNaiveKruskal {
    public static void main(String[] args) {
        int n = 5000;
        int m = 25000;
        boolean invertHeight = args.length > 0 && args[0].equals("invert");
        Random r = new Random(72374345);


        // heights are all unique
        // 0 and 1 are two maxima
        // the optimum answer is second to minimum
        int[] h = new int[n];
        h[0] = 1000000;
        h[1] = 999999;
        h[n - 2] = 0;
        h[n - 1] = 1;
        boolean[] used = new boolean[1000000];
        for (int i = 2; i < n - 2; ++i) {
            int w;
            do {
                w = r.nextInt(2, 999999);
            } while (used[w]);
            used[w] = true;
            h[i] = w;
        }

        System.out.println(n + " " + m);
        for (int i = 0; i < n; ++i) {
            System.out.print(invertHeight ? (1000000 - h[i]) : h[i]);
            if (i + 1 == n) {
                System.out.println();
            } else {
                System.out.print(" ");
            }
        }

        // all but two edges connect odd vertices with odd ones, even with even ones
        int seeded = r.nextInt(m - 1);
        Set<String> edges = new HashSet<>();
        for (int i = 0; i < m; ++i) {
            if (i == seeded) {
                System.out.println((n - 2) + " " + (n - 1));
            } else if (i == seeded + 1) {
                System.out.println((n - 3) + " " + n);
            } else {
                int n1, n2;
                do {
                    n1 = i % 2 + 2 * r.nextInt(n / 2) + 1;
                    n2 = i % 2 + 2 * r.nextInt(n / 2) + 1;
                } while (n1 == n2 || edges.contains(Math.min(n1, n2) + " " + Math.max(n1, n2)));
                edges.add(Math.min(n1, n2) + " " + Math.max(n1, n2));
                System.out.println(Math.min(n1, n2) + " " + Math.max(n1, n2));
            }
        }
    }
}