#include <array>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

struct interval {
	int l, r;
};

string make_binary(int x) {
	string res;
	while (x > 0) {
		res += '0' + x % 2;
		x /= 2;
	}
	reverse(res.begin(), res.end());
	return res;
}

vector<interval> interval_decomposition(int L, int R) {
	vector<interval> res;
	auto dfs = [&](auto& self, int s, int t) -> void {
		if (L <= s && t <= R) {
			res.push_back(interval{s, t});
			return;
		}
		if (R <= s || t <= L) {
			return;
		}
		self(self, s, (s + t) / 2);
		self(self, (s + t) / 2, t);
	};
	int maxR = 1;
	while (maxR < R) {
		maxR *= 2;
	}
	dfs(dfs, 0, maxR);
	return res;
}

struct edge {
	int t, c;
};

int main() {
	// step #1. input
	int L, R;
	cin >> L >> R;
	R++;

	// step #2. decompose to intervals
	vector<interval> ivls = interval_decomposition(L, R);
	int Z = ivls.size();

	// step #3. make trie
	vector<array<int, 2> > trie;
	trie.push_back({-1, -1});
	vector<int> lastpos(Z, -1);
	vector<int> nextcode(Z, -1);
	vector<int> level(Z, -1);
	int max_level = 0;
	for (int i = 0; i < Z; i++) {
		interval p = ivls[i];
		string prefix = make_binary(p.l);
		level[i] = 31 - __builtin_clz(p.r - p.l);
		nextcode[i] = int(prefix[int(prefix.size()) - level[i] - 1] - '0');
		prefix = prefix.substr(0, int(prefix.size()) - level[i] - 1);
		int pos = 0;
		for (int j = 0; j < int(prefix.size()); j++) {
			int c = int(prefix[j] - '0');
			if (trie[pos][c] != -1) {
				pos = trie[pos][c];
			} else {
				trie[pos][c] = trie.size();
				pos = trie.size();
				trie.push_back({-1, -1});
			}
		}
		lastpos[i] = pos;
		max_level = max(max_level, level[i]);
	}

	// step #4. make graph
	vector<vector<edge> > G(trie.size() + max_level + 1);
	for (int i = 0; i < int(trie.size()); i++) {
		for (int j = 0; j < 2; j++) {
			if (trie[i][j] != -1) {
				G[i].push_back(edge{trie[i][j], j});
			}
		}
	}
	for (int i = 0; i < Z; i++) {
		int nextpos = int(trie.size()) + max_level - level[i];
		G[lastpos[i]].push_back(edge{nextpos, nextcode[i]});
	}
	for (int i = 0; i < max_level; i++) {
		G[int(trie.size()) + i].push_back(edge{int(trie.size()) + i + 1, 0});
		G[int(trie.size()) + i].push_back(edge{int(trie.size()) + i + 1, 1});
	}

	// step #5. output
	cout << G.size() << endl;
	for (int i = 0; i < int(G.size()); i++) {
		cout << G[i].size();
		for (edge e : G[i]) {
			cout << ' ' << e.t + 1 << ' ' << e.c;
		}
		cout << endl;
	}

	return 0;
}