// region standard
#include <bits/stdc++.h>
#define guard(x) if (!(x))
using namespace std;

#define _CAT(A, B) A ## B
#define CAT(A, B) _CAT(A, B)
#define _STR(...) ""
#define STR(...) _STR(__VA_ARGS__)
#define _FIRST(F, ...) F
#define FIRST(...) _FIRST(__VA_ARGS__, )
#define SKIP1(F, ...) __VA_ARGS__
#define SKIP2(F, ...) SKIP1(__VA_ARGS__, )
#define SKIP3(F, ...) SKIP2(__VA_ARGS__, )
#define SKIP4(F, ...) SKIP3(__VA_ARGS__, )
#define SKIP5(F, ...) SKIP4(__VA_ARGS__, )
#define SKIP6(F, ...) SKIP5(__VA_ARGS__, )
#define SKIP7(F, ...) SKIP6(__VA_ARGS__, )
#define SKIP8(F, ...) SKIP7(__VA_ARGS__, )
#define SKIP9(F, ...) SKIP8(__VA_ARGS__, )
#define SKIP10(F, ...) SKIP9(__VA_ARGS__, )
#define SKIP11(F, ...) SKIP10(__VA_ARGS__, )
#define SKIP12(F, ...) SKIP11(__VA_ARGS__, )
#define SKIP(N, ...) CAT(SKIP, N)(__VA_ARGS__, )
#define COUNT(...) FIRST(SKIP12(__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ))
#ifdef DEBUG
    #define MAGIC do { std::clog << boolalpha; } while(0)
    #define PRINT(msg) do { std::clog << "D:" << __LINE__ << "> " << msg << std::endl; } while(0)
#else
    #define MAGIC do { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); } while(0)
    #define PRINT(msg) do { } while(0)
#endif
#define _DBG1(x, ...) STR(x) << ": " << (x)
#define _DBG2(x, ...) STR(x) << ": " << (x) << " \t" << _DBG1(__VA_ARGS__)
#define _DBG3(x, ...) STR(x) << ": " << (x) << " \t" << _DBG2(__VA_ARGS__)
#define _DBG4(x, ...) STR(x) << ": " << (x) << " \t" << _DBG3(__VA_ARGS__)
#define _DBG5(x, ...) STR(x) << ": " << (x) << " \t" << _DBG4(__VA_ARGS__)
#define _DBG6(x, ...) STR(x) << ": " << (x) << " \t" << _DBG5(__VA_ARGS__)
#define _DBG7(x, ...) STR(x) << ": " << (x) << " \t" << _DBG6(__VA_ARGS__)
#define _DBG8(x, ...) STR(x) << ": " << (x) << " \t" << _DBG7(__VA_ARGS__)
#define _DBG9(x, ...) STR(x) << ": " << (x) << " \t" << _DBG8(__VA_ARGS__)
#define _DBG10(x, ...) STR(x) << ": " << (x) << " \t" << _DBG9(__VA_ARGS__)
#define _DBG11(x, ...) STR(x) << ": " << (x) << " \t" << _DBG10(__VA_ARGS__)
#define _DBG12(x, ...) STR(x) << ": " << (x) << " \t" << _DBG11(__VA_ARGS__)
#define _DBG(...) CAT(_DBG, COUNT(__VA_ARGS__))(__VA_ARGS__, )
#define DBG(...) PRINT(_DBG(__VA_ARGS__))
#define PDBG(msg, ...) PRINT(msg << _DBG(__VA_ARGS__))

#define ST first
#define ND second
#define EM emplace
#define EB emplace_back
#define IN insert
#define PB push_back
#define VI vector<int>
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define ALL(x) (x).begin(), (x).end()
#define PAL(p) p.first, p.second
#define FI(e, v) for (auto const & e : v)
#define RP(n) FR(CAT(i_, CAT(n, _i)), n)
#define FV(i, s, n) for (int i = s; i > (int)(n); --i)
#define FS(i, s, n) for (int i = s; i < (int)(n); ++i)
#define FR(i, n) FS(i, 0, n)
#define RV(i, s, n) for (int i = s; i >= (int)(n); --i)
#define RS(i, s, n) for (int i = s; i <= (int)(n); ++i)
#define RR(i, n) RS(i, 1, n)

template<typename T>
inline T mini(T & a, T const & b) {
    return a = min(a, b);
}
template<typename T>
inline T maxi(T & a, T const & b) {
    return a = max(a, b);
}

template<typename T, typename... Args>
ostream & operator << (ostream & os, vector<T, Args...> const & V) {
    FI(e, V) {
        os << e << " ";
    }
    return os;
}
// endregion


ll constexpr MAX_V = (ll)(3e18) + 100;
ll constexpr INF = MAX_V + 1000;
int constexpr INT_INF = 1e9 + 1000;
ll constexpr MAX_N = 250000 + 10;

struct Input {
    int n = 0;
    ll k = 0;

    friend istream & operator >> (istream & is, Input & self) {
        auto & n = self.n;
        auto & k = self.k;

        return is >> n >> k;
    }
};

struct Output {
    bool b;
    vector<int> V;

    Output() : b(false), V() { }
    Output(vector<int> && _V) : b(true), V(move(_V)) { }

    friend ostream & operator << (ostream & os, Output const & self) {
        auto const & b = self.b;
        auto const & V = self.V;

        os << (b ? "TAK\n" : "NIE\n");
        FI(e, V) {
            os << e << " ";
        }
        return os;
    }
};

constexpr ll calc_all(ll n) {
    return (n*(n-1)) >> 1;
}

constexpr ll ka0(ll) {
    return 1;
}
constexpr ll ka1(ll n) {
    return n-1;
}
constexpr ll ka2(ll n) {
    return (n+1)*(n-2)/2;
}
//constexpr ll ka3(ll n) {
//    return (n+1)*(n+2)*(n-3)/6 + 1;
//}
//constexpr ll ka4(ll n) {
//    return (n+1)*(n+2)*(n+3)*(n-4)/24;
//}

struct Preprocess {
    vector<vector<ll>> table;

    Preprocess() {
        RS(n, 0, 250000) {
            vector<ll> V {0};
            ll v = 0;
            for (ll k = 0; k <= calc_all(n); ++k) {
                v += inversions(n, k);
                if (v > MAX_V) break;
                V.EB(v);
            }
            table.EB(move(V));
        }
    }

    map<pair<int, int>, ll> dp {{{1, 0}, 1}, {{1, 1}, 0}, {{1, 2}, 0}, {{1, 3}, 0}, {{1, 4}, 0},  {{2, 0}, 1}, {{2, 1}, 1}, {{2, 2}, 0}, {{2, 3}, 0}, {{2, 4}, 0},  {{3, 0}, 1}, {{3, 1}, 2}, {{3, 2}, 2}, {{3, 3}, 1}, {{3, 4}, 0},  {{4, 0}, 1}, {{4, 1}, 3}, {{4, 2}, 5}, {{4, 3}, 6}, {{4, 4}, 5}};
    ll calc_inversions(int n, int k) {
        switch (k) {
            case 0: return ka0(n);
            case 1: return ka1(n);
            case 2: return ka2(n);
//            case 3: return ka3(n);
//            case 4: return ka4(n);
        }
        if (n == 1) { return 0; }
        if (k >= n) {
            return inversions(n, k-1) + inversions(n-1, k) - inversions(n-1,k-n);
        }
        ll val = 0;
        for (int j = 0; j < n && k >= j; j++) {
            val += inversions(n-1, k-j);
            if (val > MAX_V) { return INF; }
        }
        return val;
    }
    ll inversions(int n, int k) {
        auto it = dp.find({n, k});
        if (it == dp.end()) {
            auto v = calc_inversions(n, k);
            dp.IN({{n, k}, v});
            return v;
        } else {
            return it->ND;
        }
    }
};


#define left(v) ((v)<<1)
#define right(v) (((v)<<1)+1)
#define parent(v) ((v)>>1)
struct Tree {
    static int constexpr BASE = 262144;
    int node[(BASE << 1) + 10] {};
    int to_push[(BASE << 1) + 10] {};


    Tree() {
        FR(i, BASE) {
            node[BASE+i] = i;
        }
        FV(i, BASE-1, 0) {
            update(i);
        }
    }


    void update(int v) {
        node[v] = max(node[left(v)], node[right(v)]);
    }

    void push(int v) {
        node[left(v)] += to_push[v];
        to_push[left(v)] += to_push[v];
        node[right(v)] += to_push[v];
        to_push[right(v)] += to_push[v];
        to_push[v] = 0;
    }


    void dec(int a, int b) {
        _add(a, b, -1);
    }

    void _add(int a, int b, int c, int p = 0, int k = BASE, int v = 1) {
        if (a <= p && k <= b) {
            node[v] += c;
            to_push[v] += c;
            return;
        }
        if (k <= a || b <= p) { return; }

        push(v);

        int s = (p+k)/2;

        _add(a, b, c, p, s, left(v));
        _add(a, b, c, s, k, right(v));

        update(v);
    }


    void set(int a, int c) {
        return _set(a, a+1, c);
    }

    void _set(int a, int b, int c, int p = 0, int k = BASE, int v = 1) {
        if (a <= p && k <= b) {
            node[v] = c;
            return;
        }
        if (k <= a || b <= p) { return; }

        push(v);

        int s = (p+k)/2;

        _set(a, b, c, p, s, left(v));
        _set(a, b, c, s, k, right(v));

        update(v);
    }


    int get(int a) {
        return _get(a, a+1);
    }

    int _get(int a, int b, int p = 0, int k = BASE, int v = 1) {
        if (a <= p && k <= b) {
            return node[v];
        }
        if (k <= a || b <= p) { return -INT_INF; }

        push(v);

        int s = (p+k)/2;

        return max(
            _get(a, b, p, s, left(v))
          , _get(a, b, s, k, right(v))
        );
    }


    int find(int c) {
        return _find(c);
    }

    int _find(int c, int v = 1) {
        if (v >= BASE) {
            if (node[v] == c) { return v - BASE; }
            else              { return -1; }
        }

        push(v);

        if (node[left(v)] < 0 && node[right(v)] < 0) { return -1; }
        if (node[left(v)] < 0) { return _find(c, right(v)); }
        if (node[right(v)] < 0) { return _find(c, left(v)); }

        if (node[left(v)] >= c) { return _find(c, left(v)); }
        else                    { return _find(c, right(v)); }
    }
};

vector<vector<ll>> TABLE;
bool success = true;
Tree tree;
VI res;

struct It : iterator<random_access_iterator_tag, ll, int> {
    int n, base_k, cur_k;

    It(int _n, int _base_k, int _cur_k) : n(_n), base_k(_base_k), cur_k(_cur_k) { }

    It & operator += (int a) {
        cur_k -= a;
        return *this;
    }
    It & operator ++ () {
        --cur_k;
        return *this;
    }
    int operator - (It const & o) {
        return o.cur_k - cur_k;
    }
    ll operator * () {
        return TABLE[n][base_k] - TABLE[n][cur_k];
    }
};

void inversion(int n, int k, ll p) {
    DBG(n, k, p);

    if (p >= TABLE[n][k+1] - TABLE[n][k]) { success = false; return; }
    if (k > calc_all(n)) { success = false; return; }
    if (n == 0) { return; }

    auto l = min(k+1, (int)(TABLE[n-1].size()-1));
    It it_b(n-1, l, l);
    It it_e(n-1, l, 0);

    auto it = upper_bound(it_b, it_e, p);
    if (it.cur_k >= l) { success = false; return; }

    auto c = it.cur_k;

    auto e = k - c;
    res.EB(e);

    DBG(l, c, e);
    PRINT("");

    inversion(n-1, c, p - TABLE[n-1][l] + TABLE[n-1][c+1]);
}

#define debug_tree() do { tree.get(0); tree.get(1); tree.get(2); tree.get(3); tree.get(4); tree.get(5); tree.get(6); tree.get(7); PRINT("tree"); DBG(tree.node[1]); DBG(tree.node[2], tree.node[3]); DBG(tree.node[4], tree.node[5], tree.node[6], tree.node[7]); DBG(tree.node[8], tree.node[9], tree.node[10], tree.node[11], tree.node[12], tree.node[13], tree.node[14], tree.node[15]); } while(0)
#define debug_tree_to_push() do { tree.get(0); tree.get(1); tree.get(2); tree.get(3); tree.get(4); tree.get(5); tree.get(6); tree.get(7); PRINT("to_push"); DBG(tree.to_push[1]); DBG(tree.to_push[2], tree.to_push[3]); DBG(tree.to_push[4], tree.to_push[5], tree.to_push[6], tree.to_push[7]); DBG(tree.to_push[8], tree.to_push[9], tree.to_push[10], tree.to_push[11], tree.to_push[12], tree.to_push[13], tree.to_push[14], tree.to_push[15]); } while(0)

Output algo(Input && input, Preprocess && preprocess) {
    auto const & n = input.n;
    auto const & p = input.k - 1;
    TABLE = move(preprocess.table);
    if ((n*(n-1)) & 0b11) { return {}; }

    inversion(n, (n*(n-1))>>2, p);

    if (!success) { return {}; }

    VI V;
    FI(e, res) {
        PRINT("");
        auto f = tree.find(e);
        DBG(e, f);

        V.EB(f + 1);

        tree.set(f, -1);
        tree.dec(f+1, n+2);
    }

    return {move(V)};
}

#if __INCLUDE_LEVEL__ == 0
int main() {
    MAGIC;
    Input input;
    cin >> input;
    cout << algo(move(input), {});
}
#endif