// Biblioteczki
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <numeric>
using namespace std;

// Typy proste
typedef unsigned int        UI;
typedef long long           LL;
typedef unsigned long long  ULL;

// Pary
typedef pair<int, int>  PI;
#define MP              make_pair
#define ST              first
#define ND              second

// Vectory
typedef vector<int>  VI;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<VI>   VVI;
typedef vector<PI>   VPI;
#define VT           vector<T>
#define VVT          vector<VT >
#define PB           push_back
#define SIZE(v)      (int(v.size()))
#define ALL(v)       v.begin(), v.end()

// Pętle
#define LOOP(i, a, b)  for (int i = (a); i < (int)(b); ++i)
#define FOREACH(x, v)  for (auto x: v)
#define REP(i, n)      LOOP(i, 0, n)

// Stałe
const int INF = 1e9+9;
const double EPS = 1e-9;

// Grafy
#define ET   Edge<T>
#define GT   Graph<T>
#define VE   vector<ET*>
#define VVE  vector<VE > 
#define PVTVE pair<VT, VE >

// Geometria
#define VP vector<Point>
#define ISZERO(x) abs(x) < EPS

// Inne
#define MOD(a, m) (a % m + m) % m
#define TEMPL template <typename T>
#define NP nullptr
#define BETWEEN(x, a, b) (((a) <= x && x <= (b)) || ((b) <= x && x <= (a)))

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Biblioteczki
#include <string>
#include <map>
#include <set>
#include <list>
#include <bitset>
#include <stack>
#include <queue>

// Vectory
typedef vector<UI>      VUI;
typedef vector<LL>      VLL;
typedef vector<ULL>     VULL;

// Pary
typedef pair<double, double>  PD;
typedef pair<string, string>  PS;
typedef pair<UI, UI>          PUI;
typedef pair<LL, LL>          PLL;
typedef pair<ULL, ULL>        PULL;

// Pętle
#define DLOOP(i, a, b)  for (int i = (a); i <= (b); ++i)
#define RLOOP(i, a, b)  for (int i = (a); i >= (b); --i)
#define TESTS(t)        int t; cin >> t; REP(i, t) 

// Stałe
const LL LLINF = 1e18+9;

// Konwersja char na int i odwrotnie
#define CTOI(c) (int(c))
#define ITOC(x) (char(x))

// I/O
#define FASTIO()  ios_base::sync_with_stdio(0); cin.tie(NULL);
TEMPL void printTab(VT &v) {
    cout << "[";
    REP(i, v.size())
        cout << (i ? ", " : "") << v[i];
    cout << "]\n";
}
TEMPL void readTab(VT &v) {
    int n;
    cin >> n;
    v.resize(n);
    REP(i, n) cin >> v[i];
}

// Debugowanie
#ifdef DEBUGGING
#define DEBUG(x) cout << #x << ": " << x << endl;
#else
#define DEBUG(x) 
#endif

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

VLL possible;
VI answer;
VI used;
VLL oldField(101);
VLL field(101);


void fun(LL x) {
	REP(i, possible.size()) {
		while (x >= possible[i]) {
			x -= possible[i];
			answer.PB(i);
		}
		if (x == 0) break;
	}
}

void genPossible(int d) {
	possible.clear();
	
	LOOP(i, 0, 101) {
		oldField[i] = 0;
	}
	
	oldField[50] = 1;
	
	REP(i, d) {
		LOOP(j, 1, 100) {
			field[j] = oldField[j-1] + oldField[j] + oldField[j+1];
		}
		
		LOOP(j, 0, 101) {
			oldField[j] = field[j];
		}
	}
	
	LOOP(i, 50, 101) {
		if (field[i] != 0 && (possible.empty() || possible[possible.size()-1] != field[i])) {
			possible.PB(field[i]);
		}
	}
}

void cutFlowers() {
	cout << 1000*101 << endl;
	
	LOOP(i, 0, 1000) {
		LOOP(j, -50, 51) {
			if (j == 0) {
				cout << j << " " << i*2 << " 1" << endl;
			} else {
				cout << j << " " << i*2 << " 0" << endl;
			}
		}
	}
	
}

void harvest(int id) {
	int tmp = used[id];
	used[id] += 2;
	
	/*if (used[id] > 1900) {
		while(true) {
			id++;
		}
	}*/
	
	cout << id << " " << tmp << endl;
}

void inf() {
	int x = 0;
	while(true) {
		x++;
	}
}

int main() {
	FASTIO();
	
	int D = 40;
	
	genPossible(D);
	
	LOOP(i, 1, possible.size()) {
		if (possible[i] >= possible[i-1]) {
			inf();
		}
	}
	
	LL K;
	
	cin >> K;
		
	
	fun(K);
	
	int H = answer.size();
	cutFlowers();
	cout << H << " " << D << endl;
	
	REP(i, H) {
		used.PB(0);
	}
	
	REP(i, H) {
		harvest(answer[i]);
	}

}