#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


const int V = 2000;

vector<vector<int>> solve(int N) {
  vector<vector<int>> ans;
  int head = 1;
  auto add = [&](vector<int> xs) -> void {
    assert(xs.size() == 8);
    for (int &x : xs) {
      x = (~x) ? (head + x) : V;
    }
    ans.push_back(xs);
  };
  if (N <= 2) {
    add({0,1, 2,3, 4,5, 6,7});
  } else if (N <= 4) {
    add({0,1, 2,3, 4,5, 6,7});
    add({1,2, 1,3, 5,6, 5,7});
  } else if (N <= 8) {
    add({0,1, 2,3, 4,5, 6,7});
    add({1,2, 1,3, 5,6, 5,7});
    add({3,4, 3,5, 3,6, 3,7});
  } else {
    switch (N % 10) {
      case 7: case 8: {
        add({0,1, 2,3, 4,5, 6,7});
        add({1,2, 1,3, 5,6, 5,7});
        add({3,4, 3,5, 3,6, 3,7});
        head += 7;
      } break;
      case 9: case 0: case 1: {
        //
      } break;
      case 2: case 3: {
        add({0,1, 3,4, 6,7,  9,10});
        add({1,2, 4,5, 7,8, 10,11});
        add({2,3, 2,4, 2,5, 11,12});
        add({5,6, 5,7, 5,8, -1,-1});
        add({8,9, 8,10, 8,11, 8,12});
        head += 12;
      } break;
      case 4: case 5: case 6: {
        add({0,1, 4,5,  8, 9, 12,13});
        add({1,2, 5,6,  9,10, 13,14});
        add({2,3, 6,7, 10,11, 14,15});
        add({ 3, 4,  3, 5,  3, 6,  3, 7});
        add({ 7, 8,  7, 9,  7,10,  7,11});
        add({11,12, 11,13, 11,14, 11,15});
        head += 15;
      } break;
      default: assert(false);
    }
    for (; head < N; ) {
      add({0,1,                 2,3, 4,5, 7, 8});
      add({1,2, 1,3,                 5,6, 8, 9});
      add({3,4, 3,5, 3,6,                 9,10});
      add({6,7, 6,8, 6,9, 6,10,               });
      head += 10;
    }
  }
  return ans;
}

void judge(int N, const vector<vector<int>> &ans) {
  vector<vector<int>> mem(V + 1);
  for (int u = 1; u <= V; ++u) {
    mem[u] = {u};
  }
  for (const auto &step : ans) {
    vector<int> tmp[4];
    for (int i = 0; i < 4; ++i) {
      const int u = step[i << 1 | 0];
      const int v = step[i << 1 | 1];
      tmp[i].insert(tmp[i].end(), mem[u].begin(), mem[u].end());
      tmp[i].insert(tmp[i].end(), mem[v].begin(), mem[v].end());
    }
    for (int i = 0; i < 4; ++i) {
      const int v = step[i << 1 | 1];
      mem[v] = tmp[i];
    }
  }
  for (int u = 1; u <= N; ++u) {
    assert((int)mem[u].size() == u);
    for (int i = 1; i <= u; ++i) {
      assert(mem[u][i - 1] == i);
    }
  }
}

int main() {
#ifdef LOCAL
  for (int N = 1; N <= 30; ++N) {
    const auto ans = solve(N);
    cerr << N << ": " << ans.size() << endl;
    judge(N, ans);
  }
#endif
  
  int N;
  for (; ~scanf("%d", &N); ) {
    const auto ans = solve(N);
    printf("%d\n", (int)ans.size());
    for (const auto &step : ans) {
      for (int i = 0; i < 4; ++i) {
        const int u = step[i << 1 | 0];
        const int v = step[i << 1 | 1];
        printf("%d %d %d\n", v, u, v);
      }
    }
#ifdef LOCAL
judge(N,ans);
#endif
  }
  return 0;
}