import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;

void calc(int[] ps, int s) {

    int[][int] count(int[] xs) {
        int[][int] d;
        for (int i = 1; i < (1 << xs.length); i++) {
            int sum = 0;
            for (int j = 0; j < xs.length; j++) {
                if (i & (1 << j))
                    sum += xs[j];
            }

            d[sum] ~= i;
        }
        return d;
    }

    auto lps = ps[0 .. ps.length / 2];
    auto rps = ps[ps.length / 2 .. $];

    auto lmap = count(lps);
    auto rmap = count(rps);

    void print(int l, int r, ref int[][] ans) {
        int[] buf;
        for (int i = 0; i < lps.length; i++) {
            if (l & (1 << i))
                buf ~= i + 1;
        }
        for (int i = 0; i < rps.length; i++) {
            if (r & (1 << i))
                buf ~= cast(int)lps.length + i + 1;
        }
        ans ~= buf;
    }

    int[][] ans;
    if (s in lmap) {
        foreach (d; lmap[s]) print(d, 0, ans);
    }
    if (s in rmap) {
        foreach (d; rmap[s]) print(0, d, ans);
    }

    foreach (k, v; lmap) {
        if (k < s && (s - k) in rmap) {
            foreach (a; lmap[k]) {
                foreach (b; rmap[s - k]) {
                    print(a, b, ans);
                }
            }
        }
    }

    ans.sort();
    foreach (a; ans) {
        writeln(a.map!(e => e.to!string).join(" "));
    }
}

void main() {
    auto ns = readints;
    int n = ns[0], s = ns[1];

    int[] ps;
    for (int i = 0; i < n; i++) {
        ps ~= readint;
    }

    calc(ps, s);
}