#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

void slv(int a, int b, bool DEBUG = false) {
    int A = a, B = b;
    string L, R;
    {
        while (a) {
            L += (char)('0' + a % 2);
            a /= 2;
        }
        while (b) {
            R += (char)('0' + b % 2);
            b /= 2;
        }
    }

    int n = 1, s = 0;
    vector<vector<pair<int, int>>> g(100);
    while (L.size() == R.size() and !L.empty() and L.back() == R.back()) {
        g[n - 1].emplace_back(n, L.back() - '0');
        L.pop_back();
        R.pop_back();
        n += 1, s += 1;
    }

    if (!R.empty()) {
        while (L.size() < R.size()) {
            L.push_back('0');
        }
        reverse(L.begin(), L.end());
        reverse(R.begin(), R.end());
        if (L.size() == 1) {
            g[n - 1].emplace_back(n, 0);
            g[n - 1].emplace_back(n, 1);
            n += 1;
        } else {
            // ゴール作った
            n += 1;
            int l = n - 1, r = l;
            assert(L[0] == '0' and R[0] == '1');

            {
                int mx = 0;
                for (int i = 1; i < R.size(); ++i) {
                    if (R[i] == '1') {
                        mx = max(mx, (int)R.size() - 1 - i);
                        break;
                    }
                }
                for (int i = 1; i < L.size(); ++i) {
                    if (L[i] == '0') {
                        mx = max(mx, (int)L.size() - i - 1);
                        break;
                    }
                }
                for (int i = 0; i < mx; ++i) {
                    g[n - 1].emplace_back(n, 0);
                    g[n - 1].emplace_back(n, 1);
                    r += 1, n += 1;
                }
            }
            // r制約気にする方
            {
                g[s].emplace_back(n, 1);
                n += 1;
                int cur = n - 1;
                for (int i = 1; i < R.size(); ++i) {
                    if (R[i] == '1') {
                        g[cur].emplace_back(r - (R.size() - 1 - i), 0);
                    }
                    int to = (i == R.size() - 1 ? r : n);
                    if (to == n) {
                        n += 1;
                    }
                    g[cur].emplace_back(to, R[i] - '0');
                    cur = to;
                }
            }
            // l制約気にする方
            if (s != 0) {
                g[s].emplace_back(n, 0);
                n += 1;
                int cur = n - 1;
                for (int i = 1; i < L.size(); ++i) {
                    if (L[i] == '0') {
                        g[cur].emplace_back(r - (L.size() - 1 - i), 1);
                    }
                    int to = (i == L.size() - 1 ? r : n);
                    if (to == n) {
                        n += 1;
                    }
                    g[cur].emplace_back(to, L[i] - '0');
                    cur = to;
                }
            } else {
                int cur = s;
                for (int i = 1; i < L.size(); ++i) {
                    if (i + 1 != L.size()) {
                        if (L[i] == '0') {
                            g[cur].emplace_back(r - (L.size() - 1 - i), 1);
                            if (cur != s) {
                                g[cur].emplace_back(n, 0);
                                cur = n;
                                n += 1;
                            }
                        } else {
                            g[cur].emplace_back(n, 1);
                            cur = n;
                            n += 1;
                        }
                    } else {
                        g[cur].emplace_back(r, 1);
                        if (L.back() == '0') g[cur].emplace_back(r, 0);
                    }
                }
            }
        }
    }

    if (!DEBUG) {
        cout << n << "\n";
        for (int i = 0; i < n; ++i) {
            cout << g[i].size();
            for (auto [v, w] : g[i]) {
                cout << ' ' << v + 1 << ' ' << w;
            }
            cout << '\n';
        }
    } else {
        vector<int> v;
        auto dfs = [&](auto dfs, int s, int cur) -> void {
            for (auto [to, w] : g[s]) {
                dfs(dfs, to, cur * 2 + w);
            }
            if (g[s].size() == 0) {
                v.push_back(cur);
            }
        };
        dfs(dfs, 0, 0);
        sort(v.begin(), v.end());
        for (int i = 0; i < v.size(); ++i) {
            cout << v[i] << ' ';
        }
        cout << endl;
        for (int i = 0; i < v.size(); ++i) {
            assert(v[i] == A + i);
        }
    }
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q = 0;
    if (q) {
        for (int i = 0; i < q; ++i) {
            int l = myRand(15) + 1, r = myRand(15) + 1;
            if (l > r) swap(l, r);
            cout << l << ' ' << r << endl;
            slv(l, r, true);
            cout << endl;
        }
    } else {
        int l, r;
        cin >> l >> r;
        slv(l, r);
    }
}