#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 <random>
#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")


void exper() {
  for (int N = 4; N <= 25; N += 3) {
    // [2, N]
    vector<int> dp(1<<(N-1), -1);
    vector<int> prv(1<<(N-1), -1);
    prv.back() = -2;
    for (int p = 1<<(N-1); --p; ) if (~prv[p]) {
      const int a = 2 + (31 - __builtin_clz(p));
      // for (int b = 2; b < a; ++b) if (p & 1<<(b-2)) for (int c = 2; c < b; ++c) if (p & 1<<(c-2)) {
      for (int b = a; --b >= 2; ) if (p & 1<<(b-2)) for (int c = b; --c >= 2; ) if (p & 1<<(c-2)) {
        if (a < b + c && a*a > b*b + c*c) {
          const int pp = p ^ 1<<(a-2) ^ 1<<(b-2) ^ 1<<(c-2);
          if (chmax(dp[pp], dp[p] + 1)) {
            prv[pp] = p;
          }
        }
      }
    }
    const int pm = max_element(dp.begin(), dp.end()) - dp.begin();
    cerr << N << ": " << dp[pm] << endl;
    for (int p = pm; p < (1<<(N-1)) - 1; ) {
      const int pp = p;
      p = prv[pp];
      const int a = 2 + (31 - __builtin_clz(pp ^ p));
      const int b = 2 + (31 - __builtin_clz(pp ^ p ^ 1<<(a-2)));
      const int c = 2 + (31 - __builtin_clz(pp ^ p ^ 1<<(a-2) ^ 1<<(b-2)));
      cerr << a << " " << b << " " << c << endl;
    }
  }
}
/*
4: 0
4 3 2
7: 1
5 4 2
7 6 3
10: 2
7 6 3
8 5 4
10 9 2
13: 3
9 7 3
10 6 5
11 8 4
13 12 2
16: 4
10 9 4
11 8 5
12 7 6
14 13 3
16 15 2
19: 5
12 11 4
13 9 5
14 8 7
15 10 6
17 16 3
19 18 2
22: 6
14 11 4
15 10 6
16 9 8
17 13 5
18 12 7
20 19 3
22 21 2
25: 7
15 14 5
16 13 6
17 11 7
18 10 9
19 12 8
22 21 3
23 20 4
25 24 2
*/


/*
  a+d  , a  , c  
  a+d+1, a+1, c+1
  
  d < c
  2d vs 2c+1
  tightest: max
*/
vector<vector<Int>> solve(int N) {
  assert(N % 3 == 1);
  const int K = (N - 1) / 3;
  vector<vector<Int>> ret;
  for (Int a = N, c = K + 1; c > 1; ) {
    const Int b = sqrtl(a*a - c*c - 1);
    const Int d = a - b;
    for (Int i = 0; i < d; ++i) {
      ret.push_back({a - i, b - i, c - i});
    }
    a -= 2 * d;
    c -= d;
  }
  return ret;
}

void stress() {
  for (int N = 1; N <= 1000; N += 3) {
    const auto ans = solve(N);
    if (N <= 25) {
      cout << N << ": " << ans << endl;
    }
    for (const auto &tri : ans) {
      assert(tri[0] < tri[1] + tri[2]);
      assert(tri[0]*tri[0] > tri[1]*tri[1] + tri[2]*tri[2]);
    }
  }
}

int main() {
  // exper();
  // stress();
  
  int N;
  for (; ~scanf("%d", &N); ) {
    for (; N % 3 != 1; --N) {}
    const auto ans = solve(N);
    printf("%d\n", (int)ans.size());
    for (const auto &tri : ans) {
      printf("%lld %lld %lld\n", tri[0], tri[1], tri[2]);
    }
  }
  return 0;
}