#include <bits/stdc++.h>

using LL = long long;

constexpr int B = 100;
constexpr int inf32 = (int)(1e9) + 9;

template <typename T>
struct Dinic {
    struct Edge { int v, nxt; T w; };
    std::vector<int> head;
    std::vector<Edge> edge;
    int src, dst;      
    /// @brief create a graph with n + 2 nodes, src = n, dst = n + 1
    /// @param n number of nodes you need
    Dinic(int n): src(n), dst(n + 1), head(n + 2, -1) {} 
    /// @brief  create a empty graph with n nodes, src and dst are specified
    /// @param  n  number of all nodes.
    /// @param  src  start node.
    /// @param  dst  target node.
    Dinic(int n, int src, int dst): src(src), dst(dst), head(n, -1) {} 
    /// @brief append t nodes
    /// @param t number of nodes you need to append
    /// @return return the start index
    int new_node(int t = 1) {
        int size = head.size();
        head.resize(size + t, -1);
        return size;
    }
    void add_edge(int u, int v, T w) {
        edge.push_back({ .v = v, .nxt = head[u], .w = w });
        head[u] = edge.size() - 1;
        edge.push_back({ .v = u, .nxt = head[v], .w = 0 });
        head[v] = edge.size() - 1;
    }
    T flow() {
        std::vector<int> level;
        const std::function<bool()> bfs = [&]() -> bool {
            level = std::vector<int>(head.size(), -1);
            std::queue<int> que;
            que.push(src);
            level[src] = 0;
            while (que.size()) {
                int u = que.front();
                que.pop();
                for (int id = head[u]; id != -1; id = edge[id].nxt) {
                    int v = edge[id].v;
                    T w = edge[id].w;
                    if (w > 0 && level[v] == -1) {
                        level[v] = level[u] + 1;
                        que.push(v);
                    }
                }
            }
            return level[dst] != -1;
        };
        std::vector<int> _head;
        const std::function<T(int u, T flow)> dfs = [&](int u, T flow) -> T {
            if (u == dst) return flow;
            T rest = flow;
            for (int id = _head[u]; rest && (_head[u] = id) != -1; id = edge[id].nxt) {
                int v = edge[id].v;
                T w = edge[id].w;
                if (w > 0 && level[v] == level[u] + 1) {
                    T cur = dfs(v, std::min(rest, w));
                    rest -= cur;
                    edge[id].w -= cur;
                    edge[id ^ 1].w += cur;
                }
            }
            return flow - rest;
        };
        T flow = 0;
        while (bfs()) {
            _head = head;
            flow += dfs(src, inf32);
        }
        return flow;
    }
};

bool check(LL n, int k) {
    Dinic<int> dinic(2 * k);
    for (int i = 0; i < k; i++) {
        dinic.add_edge(dinic.src, i, 1);
        dinic.add_edge(k + i, dinic.dst, 1);
    }
    for (int i = 0; i < k; i++) for (int j = 0; j < k; j++)
        if ((n - j) % (i + 1) == 0) dinic.add_edge(i, k + j, 1);
    return dinic.flow() == k;
}

int main() {
    LL n;
    scanf("%lld", &n);
    if (n + 1 <= B * 2) {
        puts("2");
        printf("%lld ", n + 1); 
        for (int i = 0; i <= n; i++) printf("%d ", check(n, i));
        puts("");
    }
    else {
        puts("63");
        puts("1 0");
        for (int i = 1; i <= 60; i++)
            printf("2 %d %d\n", i + 1, i + 1);
        std::vector<int> ans;
        for (int i = 0; i < B; i++) ans.push_back(check(n, i));
        LL m = n + 1 - 2 * B;
        for (int i = 0; i <= 60; i++) if (m >> i & 1) ans.push_back(2 + i);
        for (int i = B - 1; i >= 0; i--) ans.push_back(ans[i]);
        printf("%lu ", ans.size());
        for (int x : ans) printf("%d ", x);
        puts("");
    }
    return 0;
}