#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#pragma GCC target "abm,bmi,bmi2"

using namespace std;

constexpr int N = 1e6;

using u32 = uint32_t;
using u64 = uint64_t;
using u128 = __uint128_t;

u64 splitmix(u64 x) {
  x += 0x9e3779b97f4a7c15;
  (x ^= x >> 30) *= 0xbf58476d1ce4e5b9;
  (x ^= x >> 27) *= 0x94d049bb133111eb;
  return x ^ (x >> 31);
}

template <typename V>
struct umap {
  vector<u64> keys;
  vector<V> vals;
  vector<u32> nx;
  vector<u32> head;
  int cap{};

  int geti(u64 k) {
    reserve();
    k = splitmix(k);
    for (int i = head[k & cap]; ~i; i = nx[i]) if (keys[i] == k) return i;
    nx.push_back(head[k & cap]);
    head[k & cap] = keys.size();
    keys.push_back(k);
    vals.push_back({});
    return vals.size() - 1;
  }

  void reserve() {
    if (keys.size() * 2 < cap) return;
    cap = max(cap * 2 + 1, 6);
    head.assign(cap + 1, -1);
    nx.clear();
    for (int i = 0; i < keys.size(); ++i) {
      nx.push_back(head[keys[i] & cap]);
      head[keys[i] & cap] = i;
    }
  }
};

int n, b;

umap<u64> mem_[30][30][256];

u64 cnt_(int l, int c, int b, u32 m) {
  if (m >> l & 1) ++c, m -= 1 << l;
  if (l == n || b < 0) return !b;
  int loc = mem_[l][c][b].geti(m);
  if (mem_[l][c][b].vals[loc]) return ~mem_[l][c][b].vals[loc];
  int mx = (2 * n - 1 - c - 2 * l) * c / 2, mn = (n - 1 + l) * (n - l) / 2 - c * l;
  for (int t = m; t; t &= t - 1) mn -= __builtin_ctz(t);
  for (int i = n - c, t = m; --i > l; ) {
    if (int d = __builtin_ctz(t); d < i) mx += i - d, t &= t - 1;
    else break;
  }
  if (b < mn || b > mx) return mem_[l][c][b].vals[loc] = -1, 0;
  u64 ans{};
  if (c) ans += cnt_(l + 1, c - 1, b - c + 1, m) * c;
  for (u32 t = m; t; t &= t - 1) ans += cnt_(l + 1, c, b - c, m - (t & -t));
  mem_[l][c][b].vals[loc] = ~ans;
  return ans;
}

umap<u128> mem[30][30][256];

u128 cnt(int l, int c, int b, u32 m) {
  if (n - l < 21) return cnt_(l, c, b, m);
  if (m >> l & 1) ++c, m -= 1 << l;
  if (l == n || b < 0) return !b;
  int loc = mem[l][c][b].geti(m);
  if (mem[l][c][b].vals[loc]) return ~mem[l][c][b].vals[loc];
  int mx = (2 * n - 1 - c - 2 * l) * c / 2, mn = (n - 1 + l) * (n - l) / 2 - c * l;
  for (int t = m; t; t &= t - 1) mn -= __builtin_ctz(t);
  for (int i = n - c, t = m; --i > l; ) {
    if (int d = __builtin_ctz(t); d < i) mx += i - d, t &= t - 1;
    else break;
  }
  if (b < mn || b > mx) return mem[l][c][b].vals[loc] = -1, 0;
  u128 ans{};
  if (c) ans += cnt(l + 1, c - 1, b - c + 1, m) * c;
  for (u32 t = m; t; t &= t - 1) ans += cnt(l + 1, c, b - c, m - (t & -t));
  mem[l][c][b].vals[loc] = ~ans;
  return ans;
}

u128 cnt(int l, int b, u32 m) {
  int c = 0;
  for (int i = 0; i < l; ++i) if (m & 1 << i) {
    ++c;
    b -= l - i;
    m ^= 1 << i;
  }
  auto ans = cnt(l, c, b, m);
  return ans;
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> b; b /= 2;
  u128 k{};
  for (char c; cin >> c && isdigit(c); ) k = k * 10 + c - '0';
  u32 ans[30], l = 0, m = (1 << n) - 1;
  while (l < n) {
    for (int i = 0; i < n; ++i) if (m & 1 << i) if (auto t = cnt(l + 1, b - max((int)l - i, {}), m - (1 << i)); t >= k) {
      b -= max((int)l - i, {});
      ans[l++] = i + 1;
      m -= 1 << i;
      break;
    } else k -= t;
    if (l % 2 == 0)
    for (auto& mem: mem)
    for (auto& mem: mem)
    for (auto& mem: mem) mem.cap = 0, mem.head = {}, mem.nx = {}, mem.vals = {}, mem.keys = {}, mem.head.shrink_to_fit(), mem.nx.shrink_to_fit(), mem.vals.shrink_to_fit(), mem.keys.shrink_to_fit();
  }
  for (int i = 0; i < n; ++i) cout << ans[i] << ' ';
}