#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cassert>

using namespace std;

struct Card {
  int q, p;
};

typedef vector<Card> VC;
typedef vector<int> VI;

const int MAXT = 20;
const int MAXN = 50000;

int num_cases = MAXT;

//assumes card pictures are from 0 to 2n-1 (n = v.size())
void dump(VC& v) {
  cout << v.size() << endl;
  for (auto c : v)
    cout << c.p+1 << ' ' << c.q+1 << endl;
  cout << endl;
  --num_cases;
}

void scramble(VC& v) {
  int n = v.size();
  VI c(2*n);

  for (int i = 0; i < 2*n; ++i)
    c[i] = i;

  for (int i = 2*n-1; i > 0; --i)
    swap(c[i], c[rand()%(i+1)]);

  for (int i = 0; i < n; ++i) {
    if (rand()&1) swap(v[i].p, v[i].q);
    v[i].p = c[v[i].p];
    v[i].q = c[v[i].q];
  }
}

void cycle(int n) {
  VC v(n);
  for (int i = 0; i < n; ++i) {
    v[i].p = i;
    v[i].q = (i+1)%n;
  }

  scramble(v);
  dump(v);
}

void path(int n) {
  VC v(n);
 
  for (int i = 0; i < n; ++i) {
    v[i].p = i;
    v[i].q = i+1;
  }

  scramble(v);
  dump(v);
}

void isolated(int n) {
  VC v(n);

  for (int i = 0; i < n; ++i)
    v[i].p = v[i].q = i;

  dump(v);
}

void same(int n) {
  VC v(n);
  for (int i = 0; i < n; ++i)
    v[i].p = v[i].q = 0;

  dump(v);
}

void disjoint(int n) {
  VC v(n);
  for (int i = 0; i < n; ++i) {
    v[i].p = 2*i;
    v[i].q = 2*i+1;
  }

  scramble(v);
  dump(v);
}

void star(int n) {
  VC v(n);

  for (int i = 0; i < n; ++i) {
    v[i].p = 0;
    v[i].q = i+1;
  }

  scramble(v);
  dump(v);
}

void identical(int n) {
  VC v(n);

  for (int i = 0; i < n; ++i) {
    v[i].p = 0;
    v[i].q = 2*n-1;
  }

  scramble(v);
  dump(v);
}

//a cycle of length n-1, plus one duplicate
void almost(int n) {
  assert(n > 1);
  VC v(n);

  for (int i = 0; i < n; ++i) {
    v[i].p = i%(n-1);
    v[i].q = (i+1)%(n-1);
  }

  scramble(v);
  dump(v);
}

//cycle of length n-1, plus one more disjoint card
void barely(int n) {
  VC v(n);
  for (int i = 0; i < n-1; ++i) {
    v[i].p = i;
    v[i].q = (i+1)%(n-1);
  }
  v[n-1].p = v[n-1].q = n-1;
  scramble(v);
  dump(v);
}

//two disjoint cycles
void twocycle(int n) {
  int k = n/2;

  VC v(n);
  for (int i = 0; i < k; ++i) {
    v[i].p = i;
    v[i].q = (i+1)%k;
  }

  for (int i = k; i < n; ++i) {
    v[i].p = i;
    v[i].q = i+1;
  }

  v[n-1].q = k;

  scramble(v);
  dump(v);
}

//random_yes, generated by assigning the first picture of card i to i
//and the other to a random card, then scrambling
void rand_yes(int n) {
  VC v(n);
  for (int i = 0; i < n; ++i) {
    v[i].p = i;
    v[i].q = rand()%n;
  }

  scramble(v);
  dump(v);
}

//random no: card i from 0 to n-2 is given picture i%(n-1) and a random picture
//mod n-1, so there are not enough pictures. The last card is given pictures n-1, n
//so the number of pictures is ok
void rand_no(int n) {
  assert(n > 1);
  VC v(n);
  for (int i = 0; i < n-1; ++i) {
    v[i].p = i%(n-2);
    v[i].q = (i+1)%(n-2);
  }
  v[n-1].p = n-1;
  v[n-1].q = n;

  scramble(v);
  dump(v);
}

int main() {
  cout << num_cases << endl;

  cycle(3);
  cycle(MAXN);

  path(2);
  path(MAXN);

  isolated(2);
  isolated(MAXN);

  same(1);
  same(2);

  disjoint(10);
  disjoint(MAXN);
  
  star(3);
  star(MAXN);

  identical(3);
  identical(MAXN);

  almost(MAXN);
  almost(MAXN);

  twocycle(10);
  twocycle(MAXN);

  barely(MAXN);
  barely(MAXN);
  
  return 0;
}