#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; }


constexpr Int LIM = 1'000'000'000'000'000'000LL;

int N, G;
vector<Int> A;

using Op = pair<int, pair<int, int>>;
constexpr Op OP1(1, make_pair(-1, -1));
vector<Op> ans;

void apply(vector<Int> &as, const Op &op) {
  if (op.first == 1) {
    for (int i = 0; i < N; ++i) {
      as[i] = -as[i];
    }
  } else {
    const int l = op.second.first;
    const int r = op.second.second;
    assert(0 <= l); assert(l < r); assert(r <= N);
    if (op.first == 2) {
      for (int i = l + 1; i < r; ++i) as[i] += as[i - 1];
      for (int i = l + 1; i < r; ++i) as[i] = min(max(as[i], -LIM), +LIM);
    } else if (op.first == 3) {
      for (int i = r - 1; --i >= l; ) as[i] += as[i + 1];
      for (int i = r - 1; --i >= l; ) as[i] = min(max(as[i], -LIM), +LIM);
    } else {
      assert(false);
    }
  }
}

bool isGood(const vector<Int> &as) {
  for (int i = 0; i < N; ++i) if (as[i] < 0) return false;
  return true;
}


namespace sub1 {
bool run(const vector<Int> &as) {
  if (isGood(as)) {
    return true;
  }
  int l = N, r = -1;
  for (int i = 0; i < N; ++i) if (as[i] < 0) {
    chmin(l, i);
    chmax(r, i);
  }
  ++r;
  assert(l < r);
  {
    auto bs = as;
    apply(bs, OP1);
    if (isGood(bs)) {
      ans.push_back(OP1);
      return true;
    }
  }
  for (const Op &op : {Op(2, make_pair(0, r)), Op(3, make_pair(l, N))}) {
    auto bs = as;
    apply(bs, op);
    if (isGood(bs)) {
      ans.push_back(op);
      return true;
    }
  }
  return false;
}
}  // sub1


namespace sub2 {
void run() {
  auto as = A;
  for (int o = 2; !isGood(as); o ^= 1) {
    Int sum = 0;
    for (int i = 0; i < N; ++i) sum += as[i];
    if (sum < 0) {
      apply(as, OP1);
      ans.push_back(OP1);
    }
    const Op op(o, make_pair(0, N));
    apply(as, op);
    ans.push_back(op);
  }
}
}  // sub2


namespace sub5 {
void run() {
  auto as = A;
  for (; !isGood(as); ) {
    int r = N;
    Int sum = 0;
    for (int i = 0; i < N; ++i) {
      sum += as[i];
      if (sum < 0) {
        r = i;
        break;
      }
    }
    const Op op(2, make_pair(0, r));
    apply(as, op);
    ans.push_back(op);
  }
}
}  // sub5


namespace sub7 {
void dfs(const vector<Int> &as, const vector<Op> &ops) {
  if (ans.size() <= ops.size()) return;
  if (isGood(as)) {
    ans = ops;
    return;
  }
  if (ans.size() <= ops.size() + 1) return;
  {
    auto save = ans;
    ans = ops;
    const bool res = sub1::run(as);
    if (res) {
      return;
    }
    ans = save;
  }
  if (ans.size() <= ops.size() + 2) return;
  {
    auto bs = as;
    apply(bs, OP1);
    auto oops = ops; oops.push_back(OP1);
    dfs(bs, oops);
  }
  if (ans.size() <= ops.size() + 2) return;
  for (int l = 0; l < N; ) {
    int r = N;
    Int sum = 0;
    for (int i = l; i < N; ++i) {
      sum += as[i];
      if (sum < 0) {
        r = i;
        break;
      }
    }
    if (l < r) {
      for (const int o : {2}) {
        const Op op(o, make_pair(l, r));
        auto bs = as;
        apply(bs, op);
        auto oops = ops; oops.push_back(op);
        dfs(bs, oops);
  if (ans.size() <= ops.size() + 2) return;
      }
    }
    l = r + 1;
if(ops.size()>=1)break;
  }
  for (int r = N; r > 0; ) {
    int l = 0;
    Int sum = 0;
    for (int i = r; --i >= 0; ) {
      sum += as[i];
      if (sum < 0) {
        l = i + 1;
        break;
      }
    }
    if (l < r) {
      for (const int o : {3}) {
        const Op op(o, make_pair(l, r));
        auto bs = as;
        apply(bs, op);
        auto oops = ops; oops.push_back(op);
        dfs(bs, oops);
  if (ans.size() <= ops.size() + 2) return;
      }
    }
    r = l - 1;
if(ops.size()>=1)break;
  }
}
void run() {
  const bool res = sub1::run(A);
  if (res) return;
  sub2::run();
  dfs(A, {});
}
}  // sub7


int main() {
  for (; ~scanf("%d%d", &N, &G); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld", &A[i]);
    }
    
    ans.clear();
    
    if (G == 1) {
      sub1::run(A);
    } else if (G == 5 || G == 6) {
      sub5::run();
    } else if (G == 2 || G == 3 || G == 4) {
      sub2::run();
// if(ans.size()==4)cerr<<A<<": "<<ans<<endl;
    } else {
      sub7::run();
    }
    
    printf("%d\n", (int)ans.size());
    for (const Op &op : ans) {
      printf("%d", op.first);
      if (op.first != 1) {
        printf(" %d %d", op.second.first + 1, op.second.second);
      }
      puts("");
    }
  }
  return 0;
}