#if !defined(__clang__) && defined(__GNUC__) && !defined(LOCAL)
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#if !defined(LOCAL)
#include <algorithm>
#include <array>
#include <atcoder/maxflow>
#include <atcoder/string>
#include <bit>
#include <chrono>
#include <compare>
#include <concepts>
#include <execution>
#include <fstream>
#include <iostream>
#include <limits>
#include <map>
#include <numbers>
#include <numeric>
#include <print>
#include <random>
#include <ranges>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#elif 1
#include <pch.h>
#else
import std;
#endif
namespace inner {
// clang-format off
#define c_ constexpr
#define t_ template
std::vector<bool> isprime_seq(size_t size){std::vector<bool> ret(size+size%2+2);ret[0]=ret[1]=0;ret[2]=1;for(size_t i=3;i<ret.size();i+=2)ret[i]=1;for(size_t i=3;i<ret.size();i+=2){if(ret[i])for(size_t j=i*2;j<ret.size();j+=i)ret[j]=0;}return ret;}
t_<class T = int64_t> struct ratio {
  T n;T d;
  c_ ratio(T n_,T d_):n(n_/std::gcd(n_,d_)),d(d_/std::gcd(n_,d_)){}c_ ratio(T n_):n(n_),d(1){}
  #define o_(o,...) c_ ratio& operato##o(const ratio& r){*this={__VA_ARGS__};return *this;}
  o_(r+=,n*r.d+d*r.n,r.d*d);o_(r-=,n*r.d-d*r.n,r.d*d);o_(r*=,n*r.n,r.d*d);o_(r/=,n*r.d,r.d*n);
  #undef o_
  #define o_(o) c_ ratio operato##o(const ratio& y)const{ratio r=*this;o##=y;return r;}
  o_(r+);o_(r-);o_(r*);o_(r/);
  #undef o_
};
namespace ｺﾝｾﾌﾟ{
t_<class F,class R,class... T>concept func=std::is_invocable_r_v<R,F,T...>;
};
t_<class T,auto e_>
c_ T segtree_id();
t_<class T,ｺﾝｾﾌﾟ::func<T,T,T>auto op,auto e_>
struct segtree{std::vector<T>v;size_t sz;static inline T e=segtree_id<T,e_>();
#define SEGTREE_BODY \
c_ segtree(){}\
c_ segtree(size_t sz_):v(std::bit_ceil(sz_)*2,e),sz(std::bit_ceil(sz_)){}\
c_ segtree(std::initializer_list<T>v){init(v);}\
t_<std::ranges::range R>c_ segtree(const R& v_){init(v_);}\
t_<std::ranges::range R>c_ void init(const R& v_){using namespace std::ranges;sz=std::bit_ceil(size(v_));v.resize(std::bit_ceil(sz*2));copy(v_,v.begin()+sz);fill(v|views::drop(size(v_)),e);auto sz_=sz/2;while(sz_!=0){for(size_t i=sz_;i<sz_*2;i++){v[i]=op(v[2*i+1],v[2*i]);}sz_/=2;}}\
c_ T prod(size_t l,size_t r)const{l+=sz;r+=sz;T l_=e,r_=e;while(l<r){if(l%2)l_=op(l_,v[l++]);if(r%2)r_=op(v[--r],r_);l/=2;r/=2;}return op(l_,r_);}\
c_ const T& get(size_t i){return v[i+sz];}\
c_ const T& operator[](size_t i){return get(i);}\
c_ void set(size_t i,T v){i+=sz;v[i]=v;while(i/=2){v[i]=op(v[i*2],v[i*2|1]);}}\
c_ size_t size(){return sz;}
SEGTREE_BODY};
t_<class T,ｺﾝｾﾌﾟ::func<T,T,T>auto op,auto e_>requires requires{segtree_id<T,e_()>();}
struct segtree<T,op,e_>{std::vector<T>v;size_t sz;c_ static T e=segtree_id<T,e_>();SEGTREE_BODY};
t_<class T,auto op,std::convertible_to<T>auto e_>
c_ T segtree_id(){return e_;}
t_<class T,auto op,ｺﾝｾﾌﾟ::func<T>auto e_>
c_ T segtree_id(){return e_();}
#undef SEGTREE_BODY
int main();
#undef c_
// clang-format on
}  // namespace inner
int main() {
  using namespace std;
  using namespace std::chrono;
  ios::sync_with_stdio(false);
  cout.precision(10);
#ifdef LOCAL
  ifstream in("case.txt");
  int n;
  in >> n;
  if (n > 0) {
    cin.rdbuf(in.rdbuf());
    for (int i = 0; i < n; i++) {
      cout << "\n----test case " << i << "----" << endl;
      auto t0 = high_resolution_clock::now();
      inner::main();
      auto t1 = high_resolution_clock::now();
      cout << format("\n\n{},{}", i, t1 - t0) << endl;
    }
  } else if (n < 0) {
  } else {
    inner::main();
  }
  return 0;
#else
  inner::main();
  return 0;
#endif
}
using namespace inner;
using std::cin, std::cout;
#define main inner::main
#include <iostream>
#include <map>
#include <set>
#include <vector>

int main() {
  int64_t N, S;
  std::cin >> N >> S;
  std::vector<int64_t> P(N);
  for (auto& p : P) std::cin >> p;
  int l = N / 2, r = N - l;
  std::multimap<int64_t, int> m1, m2;
  std::set<int64_t> ans;
  for (int i = 0; i < (1 << l); i++) {
    int64_t sum = 0;
    for (int b = 0; b < l; b++)
      if (i & (1 << b)) sum += P[l - 1 - b];
    m1.emplace(sum, i);
  }
  for (int i = 0; i < (1 << r); i++) {
    int64_t sum = 0;
    for (int b = 0; b < r; b++)
      if (i & (1 << b)) sum += P[l + r - 1 - b];
    m2.emplace(sum, i);
  }
  for (auto&& [k, v] : m1) {
    auto [i1, i2] = m2.equal_range(S - k);
    for (; i1 != i2; i1++) {
      ans.insert(v << r | i1->second);
    }
  }
  for (auto a : ans | std::views::reverse) {
    for (int b = 0; b < N; b++)
      if (a & (1 << (N - 1 - b))) std::cout << b + 1 << ' ';
    std::cout << "\n";
  }
  return 0;
}