#pragma GCC optimize("unroll-loops")

#include<bits/stdc++.h>

using namespace std;
using ll = long long;

using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pii>;

using i128 = __int128_t;

const ll INF = 4e18;

ll mul(ll x, ll y) {
    i128 res = (i128) x * y;
    if(res > INF) {
        return INF;
    }
    return res;
}

ll add(ll x, ll y) {
    if(x + y > INF) {
        return INF;
    }
    return x + y;
}

int n;
ll k;


const int N = 55;
// const int N = 10;
ll ncr[N][N];
ll dp[N];

void precomp() {
    ncr[0][0] = 1;
    for(int i = 0; i < N-1; i++) {
        for(int j = 0; j <= i; j++) {
            ncr[i+1][j] = add(ncr[i+1][j], ncr[i][j]);
            ncr[i+1][j+1] = add(ncr[i+1][j+1], ncr[i][j]);
        }
    }

    // cerr << ncr[10][5] << endl;

    dp[0] = dp[1] = 1;
    for(int j = 2; j < N; j++) {
        for(int i = 0; i < j; i++) {
            // cerr << ncr[j-1][i] << ' ' << dp[i] << ' ' << dp[N-i-1] << endl;
            dp[j] = add(dp[j], mul(ncr[j-1][i], mul(dp[i], dp[j-i-1])));
        }
        dp[j] /= 2;
    }

    // for(int i = 0; i < 10; i++) {
    //     cerr << dp[i] << ' ';
    // }
    // cerr << endl;
}

ll check_prefix(vi pref) {

    // cerr << "check_prefix" << endl;
    // for(int i : pref) {
    //     cerr << i << ' ';
    // }
    // cerr << endl;

    int m = pref.size();
    vi rev(n, -1);

    for(int i = 0; i < m; i++) {
        rev[pref[i]] = i;
    }

    // ll dir_mult = ((m > 1) ? 1 : 2);

    ll ans = 1;

    int rem = n - m;

    bool odd_dir = true;
    bool even_dir = true;

    for(int i = 1; i < n; i++) {
        if(rev[i] != -1 && rev[i-1] != -1) {
            if((rev[i] > rev[i-1]) ^ (i % 2)) {
                odd_dir = false;
            } else {
                even_dir = false;
            }
        }
    }
    if(!odd_dir && !even_dir) {
        return 0;
    }

    bool ok = true;
    int num_gaps = 0;
    int gap_size = 0;
    bool at_start = true;

    auto process_gap = [&](bool ignore_dir) {
        if(gap_size > 0) {
            // cerr << rem << ' ' << gap_size << ' ' << ncr[rem][gap_size] << ' ' << dp[gap_size] << endl;
            ans = mul(ans, mul(ncr[rem][gap_size], dp[gap_size]));
            rem -= gap_size;
            num_gaps++;
            gap_size = 0;
            if(!ignore_dir && gap_size % 2 == 1) {
                ok = false;
            }
        }
    };

    for(int i = 0; i < n; i++) {
        if(rev[i] != -1) {
            if(i > 0 && rev[i-1] == -1) {
                if(0 ^ (i % 2)) {
                    odd_dir = false;
                } else {
                    even_dir = false;
                }
            }
            process_gap(at_start);
            at_start = false;
        } else {
            if(i > 0 && rev[i-1] != -1) {
                if(1 ^ (i % 2)) {
                    odd_dir = false;
                } else {
                    even_dir = false;
                }
            }
            gap_size++;
        }
    }
    process_gap(true);

    if(!odd_dir && !even_dir) {
        return 0;
    }

    if(m == 0) {
        ans = mul(ans, 2);
    }

    return ans;
}

void solve() {
    cin.tie(0);
    ios::sync_with_stdio(0);

    cin >> n >> k;

    // cerr << check_prefix(vector<int>({})) << endl;
    // cerr << check_prefix(vector<int>({0})) << endl;
    // cerr << check_prefix(vector<int>({1})) << endl;
    // cerr << check_prefix(vector<int>({3})) << endl;

    // exit(0);

    ll tot = check_prefix(vector<int>({}));
    if(k > tot) {
        cout << -1 << endl;
        return;
    }
    vector<bool> rem(n, true);
    vi pref;
    ll run = 0;
    while(pref.size() < n) {
        for(int i = 0; i < n; i++) {
            if(rem[i]) {
                pref.push_back(i);
                ll num = check_prefix(pref);
                // cerr << num << endl;
                if(num == 0 || add(run, num) < k) {
                    run = add(run, num);
                    pref.pop_back();
                } else {
                    rem[i] = false;
                    break;
                }
            }
        }
    }
    for(int i = 0; i < n; i++) {
        cout << pref[i]+1 << ' ';
    }
    cout << endl;
}

int main() {
    precomp();
    solve();
    return 0;
}