#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using namespace std;

using ll = long long;

const int MAX_LOG = 20;

int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(long long t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int botbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int botbit(long long a) { return a == 0 ? 64 : __builtin_ctzll(a); }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(long long t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
long long MSK(int n) { return (1LL << n) - 1; }

bool check(int L, int R, int n, const vector<vector<pair<int, int>>>& G) {
    vector<map<int, int>> dp(n);
    dp[0][0] = 1;
    vector<int> indeg(n, 0);
    for (int i = 0; i < n - 1; i++) {
        if (G[i].empty()) return false;
        for (auto [a, v] : G[i]) indeg[a]++;
    }
    if (not G[n - 1].empty()) return false;
    if (indeg[0] != 0) return false;
    for (int i = 1; i < n; i++) {
        if (indeg[i] == 0) {
            return false;
        }
    }

    for (int i = 0; i < n; i++) {
        for (auto [key, val] : dp[i]) {
            if (i > 0 and key == 0) return false;
            for (auto [a, v] : G[i]) {
                dp[a][key << 1 | v] += val;
            }
        }
    }
    if (int(dp[n - 1].size()) > R - L) return false;
    for (int i = L; i < R; i++) {
        if (dp[n - 1][i] != 1) {
            return false;
        }
    }
    return true;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    int L, R;
    cin >> L >> R;
    R++;

    vector<tuple<int, int, int>> es;
    vector<vector<pair<int, int>>> from(MAX_LOG);
    int s = 0, nxt = 1;
    auto dfs = [&](auto self, int l, int r, int cur) -> void {
        if (r <= l) return;
        int top = topbit(r - l);
        int m = (l + r) >> 1;
        if (L <= l and m <= R) {
            from[top - 1].emplace_back(cur, 0);
        } else if (not(m <= L or R <= l)) {
            es.emplace_back(cur, nxt++, 0);
            self(self, l, m, nxt - 1);
        }
        if (L <= m and r <= R) {
            from[top - 1].emplace_back(cur, 1);
        } else if (not(r <= L or R <= m)) {
            es.emplace_back(cur, nxt++, 1);
            self(self, m, r, nxt - 1);
        }
    };
    for (int i = 0; i < MAX_LOG; i++) {
        int l = 1 << i, r = 1 << (i + 1);
        if (r <= L or R <= l) continue;
        if (L <= l and r <= R) {
            from[i].emplace_back(s, 1);
            continue;
        }
        es.emplace_back(s, nxt++, 1);
        dfs(dfs, l, r, nxt - 1);
    }
    int maxi = -1;
    for (int i = MAX_LOG - 1; i >= 0; i--) {
        if (not from[i].empty()) {
            maxi = i;
            break;
        }
    }
    assert(maxi != -1);
    for (int i = maxi; i >= 0; i--) {
        for (auto [c, v] : from[i]) es.emplace_back(c, nxt, v);
        if (i - 1 >= 0) {
            es.emplace_back(nxt, nxt + 1, 0);
            es.emplace_back(nxt, nxt + 1, 1);
        }
        nxt++;
    }

    int n = nxt;
    vector<vector<pair<int, int>>> G(n);
    for (auto [a, b, c] : es) G[a].emplace_back(b, c);

#ifdef LOCAL
    assert(check(L, R, n, G));
#endif
    cout << n << "\n";
    for (int i = 0; i < n; i++) {
        cout << G[i].size();
        for (auto [a, v] : G[i]) cout << " " << a + 1 << " " << v;
        cout << "\n";
    }
    return 0;
}