#include <bits/stdc++.h>
#define rep(i, l, r) for(int i = (l); i <= (r); i++)
#define per(i, r, l) for(int i = (r); i >= (l); i--)
#define mem(a, b) memset(a, b, sizeof a)
#define For(i, l, r) for(int i = (l), i##e = (r); i < i##e; i++)
#define pb push_back
#define eb emplace_back
#define SZ(x) int(x.size())
#define all(x) x.begin(), x.end()

using namespace std;
using ll = long long;

template<class T> inline T& cmin(T& a, const T& b) { if(b < a) a = b; return a; }
template<class T> inline T& cmax(T& a, const T& b) { if(a < b) a = b; return a; }
template<class... Args> void print(Args&&... args) {
    ((cout << args << ' '), ...);
}
template<class... Args> void println(Args&&... args) {
    print(args...), cout << endl;
}

const int N = 2e5 + 8;

int n, a[N];
vector<tuple<int, int, int>> ans;

struct pt { ll x, y; };
struct {
    int p;
    pt s[N];
    ll cross3(pt a, pt b, pt c) {
        return (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
    };
    void push(pt a) {
        while(p >= 2 && cross3(s[p - 1], s[p], a) <= 0) p--;
        s[++p] = a;
    }
    int query(ll k) {
        int l = 1, r = p;
        while(l < r) {
            int m = l + r >> 1;
            s[m].y - s[m + 1].y < (s[m].x - s[m + 1].x) * k ? r = m : l = m + 1;
        }
        return s[l].x;
    }
} A;

bool solve0() {
    bool A = 1, B = 1;
    rep(i, 1, n) A &= a[i] >= 0, B &= a[i] <= 0;
    if(A) return 1;
    if(B) return ans.eb(1, 0, 0), 1;
    return 0;
}
bool solve1() {
    int sum = 0; bool ok = 1;
    rep(i, 1, n) sum += a[i], ok &= sum >= 0;
    if(ok) return ans.eb(2, 1, n), 1;
    return 0;
}
bool solve2() {
    int sum = 0; bool ok = 1;
    rep(i, 1, n) sum += a[i], ok &= sum <= 0;
    if(ok) return ans.eb(1, 0, 0), ans.eb(2, 1, n), 1;
    int suf[N] = {};
    per(i, n, 1) suf[i] = min(suf[i + 1] + a[i], 0);
    ll sum1 = 0, sum2 = 0;
    rep(i, 1, n) {
        sum1 += a[i], sum2 += sum1;
        if(sum2 < 0) break;
        if(sum2 + suf[i + 1] >= 0)
            return ans.eb(2, 1, i), ans.eb(2, 1, n), 1;
    }
    int pre[N] = {};
    ll p[N] = {};
    per(i, n, 1) p[i] = p[i + 1] + a[i];
    rep(i, 1, n) pre[i] = pre[i - 1] + a[i], p[i + 1] += p[i];
    int lim = n + 1;
    rep(i, 1, n) if(pre[i] < 0) { lim = i; break; }
    rep(r, 1, n) {
        ll s = p[r + 1] - p[r];
        A.push({r - 1, p[r - 1]});
        int x = A.query(s);
        if(x < lim & p[x] - x * s <= p[r] - r * s + suf[r + 1])
            return ans.eb(3, x + 1, r), ans.eb(2, 1, n), 1;
    }
    A.p = 0;
    return 0;
}
bool solve3() {
    int sum = 0, mx = 0, pos = 0;
    per(i, n, 1) {
        sum -= a[i];
        if(sum > mx) mx = sum, pos = i;
    }
    if((n - pos + 1) * 2 >= n)
        return ans.eb(1, 0, 0), ans.eb(2, pos, n), ans.eb(3, 1, n), 1;
    return ans.eb(3, 1, pos), ans.eb(3, 1, pos), ans.eb(2, 1, n), 1;
}
int main() {
    cin.tie(0)->sync_with_stdio(0);
    int g;
    cin >> n >> g;
    rep(i, 1, n) cin >> a[i];
    auto foo = [&](auto solve, int need) {
        rep(i, 0, 1) {
            if(solve()) {
                println(SZ(ans));
                for(auto [t, l, r] : ans) if(t == 1) println(1);
                else if(!i) println(t, l, r);
                else println(t ^ 1, n + 1 - r, n + 1 - l);
                exit(0);
            }
            if(!need) break;
            reverse(a + 1, a + n + 1);
        }
    };
    foo(solve0, 0), foo(solve1, 1), foo(solve2, 1), foo(solve3, 0);
}