#include <bits/stdc++.h>

using namespace std;

using int64 = long long;
const int mod = 1e9 + 7;
// const int mod = 998244353;

const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;

struct IoSetup {
  IoSetup() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    cerr << fixed << setprecision(10);
  }
} iosetup;


template< typename T1, typename T2 >
ostream &operator<<(ostream &os, const pair< T1, T2 > &p) {
  os << p.first << " " << p.second;
  return os;
}

template< typename T1, typename T2 >
istream &operator>>(istream &is, pair< T1, T2 > &p) {
  is >> p.first >> p.second;
  return is;
}

template< typename T >
ostream &operator<<(ostream &os, const vector< T > &v) {
  for(int i = 0; i < (int) v.size(); i++) {
    os << v[i] << (i + 1 != v.size() ? " " : "");
  }
  return os;
}

template< typename T >
istream &operator>>(istream &is, vector< T > &v) {
  for(T &in : v) is >> in;
  return is;
}

template< typename T1, typename T2 >
inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template< typename T1, typename T2 >
inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

template< typename T = int64 >
vector< T > make_v(size_t a) {
  return vector< T >(a);
}

template< typename T, typename... Ts >
auto make_v(size_t a, Ts... ts) {
  return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));
}

template< typename T, typename V >
typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {
  t = v;
}

template< typename T, typename V >
typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {
  for(auto &e : t) fill_v(e, v);
}

template< typename F >
struct FixPoint : F {
  FixPoint(F &&f) : F(forward< F >(f)) {}

  template< typename... Args >
  decltype(auto) operator()(Args &&... args) const {
    return F::operator()(*this, forward< Args >(args)...);
  }
};

template< typename F >
inline decltype(auto) MFP(F &&f) {
  return FixPoint< F >{forward< F >(f)};
}

int main() {
  int64 N, K;
  cin >> N >> K;

  if(N < K * 2 - 1) {
    cout << -1 << endl;
    return 0;
  }

  set< int64 > latte, malta, beet;
  for(int i = 0; i < N; i++) latte.emplace(K + i);
  for(int i = 0; i < N; i++) malta.emplace(K + N + i);
  for(int i = 0; i < N; i++) beet.emplace(K + N + N + i);

  while(latte.size()) {
    int64 ft = *latte.begin();
    latte.erase(latte.begin());
    int64 back = *beet.begin();
    beet.erase(beet.begin());
    auto mid = malta.upper_bound(back - ft);
    assert(mid != begin(malta));
    --mid;

    cout << ft << " " << *mid << " " << back << endl;
    assert(ft + *mid <= back);
    assert(mid != end(malta));
    mid = malta.erase(mid);

    while(mid != end(malta)) {
      ft = *latte.begin();
      latte.erase(ft);
      auto pos = beet.lower_bound(ft + *mid);


      cout << ft << " " << *mid << " " << *pos << endl;
      assert(ft + *mid <= *pos);


      assert(pos != end(beet));
      beet.erase(pos);
      mid = malta.erase(mid);

    }
    //cout << "end" << endl;


  }


  /*
  int K = 4;
  int N = 7;
  vector< int > tap;
  for(int i = 0; i < 3 * N; i++) {
    tap.emplace_back(K + i);
  }
  auto dp = make_v< int64 >(1 << tap.size());
  fill_v(dp, -1);
  auto rec = MFP([&](auto rec, int i) -> bool {
    if(i == (1 << tap.size()) - 1) return true;
    if(~dp[i]) return dp[i];

    for(int j = 0; j < tap.size(); j++) {
      if((i >> j) & 1) continue;
      for(int k = j + 1; k < tap.size(); k++) {
        if((i >> k) & 1) continue;
        for(int l = k + 1; l < tap.size(); l++) {
          if((i >> l) & 1) continue;
          int add = tap[j] + tap[k];
          int add2 = tap[l];
          if(add <= add2) {
            if((rec(i | (1 << j) | (1 << k) | (1 << l)))) {
              return dp[i] = true;
            }
          }
        }
      }
    }
    return dp[i] = false;
  });
  cout << rec(0) << endl;



  auto rec2 = MFP([&](auto rec2, int i) -> void {
    if(i == (1 << tap.size()) - 1) return;

    for(int j = 0; j < tap.size(); j++) {
      if((i >> j) & 1) continue;
      for(int k = j + 1; k < tap.size(); k++) {
        if((i >> k) & 1) continue;
        for(int l = k + 1; l < tap.size(); l++) {
          if((i >> l) & 1) continue;
          int add = tap[j] + tap[k];
          int add2 = tap[l];
          if(add <= add2) {
            if((rec(i | (1 << j) | (1 << k) | (1 << l)))) {
              cout << tap[j] << " " << tap[k] << " " << tap[l] << endl;

              rec2(i | (1 << j) | (1 << k) | (1 << l));
              return;
            }
          }
        }
      }
    }
    return;
  });
  rec2(0);


/*
int64 N, K;
cin >> N >> K;
if(N >= K * 2 - 1) {

} else {
  cout << "-1" << endl;

}

// N≧K*2-1のとき存在しそう
for(int K = 1; K <= 20; K++) {
  for(int N = 1; N <= 7; N++) {

    /*

    vector< int > tap;
    for(int i = 0; i < 3 * N; i++) {
      tap.emplace_back(K + i);
    }
    auto dp = make_v< int64 >(1 << tap.size());
    fill_v(dp, infll);
    dp[0] = 0;
    for(int i = 0; i < (1 << tap.size()); i++) {
      if(dp[i] == -1) continue;
      for(int j = 0; j < tap.size(); j++) {
        if((i >> j) & 1) continue;
        for(int k = j + 1; k < tap.size(); k++) {
          if((i >> k) & 1) continue;
          for(int l = k + 1; l < tap.size(); l++) {
            int add = tap[j] + tap[k];
            int add2 = tap[l];
            if(add <= add2) {
              if((~i >> j) & 1 && (~i >> k) & 1 && (~i >> l) & 1) {
                dp[i | (1 << j) | (1 << k) | (1 << l)] = dp[i];
              }
            }
          }
        }
      }
    }

if(N >= K * 2 - 1) {
cout << K << " " << N << " " <<
endl;


}
}
cout <<
endl;
}*/
}



Measured memory_bytes: 16384