#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


template <class Func> struct MaxLiChaoTree {
  using TX = typename Func::TX;
  using TY = typename Func::TY;
  struct Node {
    int l, r;
    Func f;
  };
  vector<Node> nodes;

  const TX XL, XR;
  int rt;
  MaxLiChaoTree() : XL(0), XR(0), rt(-1) {}
  // [L, R)
  MaxLiChaoTree(TX XL_, TX XR_) : XL(XL_), XR(XR_), rt(-1) {}
  bool empty() const {
    return (!~rt);
  }
  // Add f to the whole [L, R).
  void add(Func f) {
    int *u = &rt;
    for (TX xL = XL, xR = XR; ; ) {
      if (!~*u) { *u = nodes.size(); nodes.push_back({-1, -1, f}); return; }
      const TX xMid = xL + (xR - xL) / 2;
      if (nodes[*u].f(xMid) < f(xMid)) swap(nodes[*u].f, f);
      if (xL + 1 == xR) return;
      if (nodes[*u].f(xL) < f(xL)) {
        u = &nodes[*u].l; xR = xMid;
      } else if (nodes[*u].f(xR) < f(xR)) {
        u = &nodes[*u].r; xL = xMid;
      } else {
        return;
      }
    }
  }
  // Get max at x.
  TY operator()(TX x) const {
    assert(XL <= x); assert(x < XR);
    assert(!empty());
    int u = rt;
    TY maxY = nodes[u].f(x);
    for (TX xL = XL, xR = XR; ; ) {
      const TX xMid = xL + (xR - xL) / 2;
      if (x < xMid) {
        u = nodes[u].l; xR = xMid;
      } else {
        u = nodes[u].r; xL = xMid;
      }
      if (!~u) break;
      const TY y = nodes[u].f(x);
      if (maxY < y) maxY = y;
    }
    return maxY;
  }
};

// y = p x + q
struct Line {
  using TX = Int;
  using TY = pair<Int, int>;
  Int p, q;
  int id;
  Line(Int p_, Int q_, int id_) : p(p_), q(q_), id(id_) {}
  TY operator()(TX x) const {
    return make_pair(p * x + q, id);
  }
};


using Op = pair<int, pair<int, int>>;
inline Op O(int t, int l = -1, int r = -1) {
  return Op(t, make_pair(l, r));
}

int N, Subtask;
vector<Int> A;

bool isDone(const vector<Int> &as) {
  for (int i = 0; i < N; ++i) if (as[i] < 0) return false;
  return true;
}
void apply(vector<Int> &as, const Op &op) {
  const int l = op.second.first;
  const int r = op.second.second;
  switch (op.first) {
    case 1: {
      for (int i = 0; i < N; ++i) as[i] *= -1;
    } break;
    case 2: {
      for (int i = l + 1; i < r; ++i) as[i] += as[i - 1];
    } break;
    case 3: {
      for (int i = r - 1; --i >= l; ) as[i] += as[i + 1];
    } break;
    default: assert(false);
  }
}
bool check(const vector<Op> &ops) {
  auto as = A;
  for (const Op &op : ops) apply(as, op);
  return isDone(as);
}
void reverse(vector<Op> &ops) {
  for (Op &op : ops) if (op.first != 1) {
    const int l = op.second.first;
    const int r = op.second.second;
    op.first ^= 2 ^ 3;
    op.second = make_pair(N - r, N - l);
  }
}

vector<Op> solve() {
  // 0?
  if (check({})) return {};
  
  // 1?
  for (const Op op : {O(1), O(2, 0, N), O(3, 0, N)}) {
    if (check({op})) return {op};
  }
  
  // 2?
  for (const Op op : {O(2, 0, N), O(3, 0, N)}) {
    if (check({O(1), op})) return {O(1), op};
  }
  for (int dir = 0; dir < 2; ++dir) {
    vector<Int> B(N + 1), C(N + 2);
    for (int i = 0; i < N; ++i) B[i + 1] = B[i] + A[i];
    for (int i = 0; i <= N; ++i) C[i + 1] = C[i] + B[i];
    
    // O(2, 0, r), O(2, 0, N)
    /*
      0 <= i <= r: (C[i+1] - C[1])
      r <= i <= N: (C[r+1] - C[1]) + (B[i] - B[r])
    */
    {
      vector<Int> head(N + 1);
      head[0] = C[1] - C[1];
      for (int r = 1; r <= N; ++r) head[r] = min(head[r - 1], C[r + 1] - C[1]);
      int im = N;
      for (int r = N; r >= 0; --r) {
        if (B[im] > B[r]) im = r;
        if (head[r] >= 0 &&
            (C[r + 1] - C[1]) + (B[im] - B[r]) >= 0) {
          vector<Op> ops{O(2, 0, r), O(2, 0, N)};
          assert(check(ops));
          if (dir) reverse(ops);
          return ops;
        }
      }
    }
    
    // O(3, l, r), O(2, 0, N)
    /*
      0 <= i <= l: B[i]
      l <= i <= r: B[l] + (i - l) B[r] - (C[i] - C[l])
      r <= i <= N: B[l] + (r - l) B[r] - (C[r] - C[l]) + (B[i] - B[r])
    */
    {
      auto brute = [&]() -> pair<int, int> {
        for (int l = 0; l <= N; ++l) for (int r = l; r <= N; ++r) {
          if (check({O(3, l, r), O(2, 0, N)})) return make_pair(l, r);
        }
        return make_pair(-1, -1);
      };
      auto slow = [&]() -> pair<int, int> {
        vector<Int> head(N + 1);
        head[0] = B[0];
        for (int l = 1; l <= N; ++l) head[l] = min(head[l - 1], B[l]);
        for (int r = N; r >= 0; --r) {
          int im0 = r, im1 = r;
          for (int i = r; i <= N; ++i) if (B[im1] > B[i]) im1 = i;
          for (int l = r; l >= 0; --l) {
            if (im0 * B[r] - C[im0] > l * B[r] - C[l]) im0 = l;
            if (head[l] >= 0 &&
                B[l] + (im0 - l) * B[r] - (C[im0] - C[l]) >= 0 &&
                B[l] + (r - l) * B[r] - (C[r] - C[l]) + (B[im1] - B[r]) >= 0) {
              return make_pair(l, r);
            }
          }
        }
        return make_pair(-1, -1);
      };
      auto fast = [&]() -> pair<int, int> {
        int badL = N + 1;
        for (int l = 0; l <= N; ++l) if (B[l] < 0) {
          badL = l;
          break;
        }
        vector<Int> tail(N + 1);
        tail[N] = B[N];
        for (int r = N; --r >= 0; ) tail[r] = min(B[r], tail[r + 1]);
        const Int minB = *min_element(B.begin(), B.end());
        const Int maxB = *max_element(B.begin(), B.end());
        // f(B[r]) = B[l] - (l B[r] - C[l])
        // g(B[r]) = - (i B[r] - C[i])
        MaxLiChaoTree<Line> f(minB, maxB + 1), g(minB, maxB + 1);
        for (int r = 0; r <= N; ++r) {
          {
            const int l = r;
            if (l < badL) f.add(Line(-l, B[l] + C[l], l));
          }
          {
            const int i = r;
            g.add(Line(-i, C[i], i));
          }
          if (!f.empty()) {
            const int l = f(B[r]).second;
#ifdef LOCAL
for(int i=0;i<=l;++i)assert(B[l]+(i-l)*B[r]-(C[i]-C[l])>=0);
for(int i=l;i<=r&&i<badL;++i)assert(B[l]+(i-l)*B[r]-(C[i]-C[l])>=0);
#endif
            if (B[l] - l * B[r] + C[l] - g(B[r]).first >= 0 &&
                B[l] + (r - l) * B[r] - (C[r] - C[l]) + (tail[r] - B[r]) >= 0) {
              return make_pair(l, r);
            }
          }
        }
        return make_pair(-1, -1);
      };
      // const auto res = slow();
      const auto res = fast();
#ifdef LOCAL
const auto brt=brute();
if(~brt.first&&!~res.first){
 cerr<<A<<" "<<B<<" "<<C<<": "<<brt<<" "<<slow()<<" "<<res<<endl;
 assert(false);
}
#endif
      if (~res.first) {
        vector<Op> ops{O(3, res.first, res.second), O(2, 0, N)};
        assert(check(ops));
        if (dir) reverse(ops);
        return ops;
      }
    }
    
    reverse(A.begin(), A.end());
  }
  
  // 3
  {
    vector<Op> ops;
    vector<Int> B(N + 1, 0);
    for (int i = 0; i < N; ++i) B[i + 1] = B[i] + A[i];
    int i0 = 0, i1 = 0;
    for (int i = 0; i <= N; ++i) {
      if (B[i0] > B[i]) i0 = i;
      if (B[i1] < B[i]) i1 = i;
    }
    if (i0 > i1) {
      ops.push_back(O(1));
      swap(i0, i1);
    }
    ops.push_back(O(3, 0, i1));
    ops.push_back(O(2, 0, N));
    assert(check(ops));
    return ops;
  }
}

int main() {
  for (; ~scanf("%d%d", &N, &Subtask); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld", &A[i]);
    }
    
    const auto ans = solve();
    printf("%d\n", (int)ans.size());
    for (const Op &op : ans) {
      if (op.first == 1) {
        puts("1");
      } else {
        printf("%d %d %d\n", op.first, op.second.first + 1, op.second.second);
      }
    }
  }
  return 0;
}