#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr Int INF = 1001001001001001001LL;
Int mul(Int a, Int b) {
  return (b && a > INF / b) ? INF : (a * b);
}


int L(int n) {
  assert(n >= 1);
  if (n == 1) return 0;
  const int e = 31 - __builtin_clz(n);
  return (n < 3 << (e - 1)) ? ((1 << (e - 1)) - 1) : (n - (1 << e));
}
int R(int n) {
  assert(n >= 1);
  return n - 1 - L(n);
}
int C(int n) {
  assert(n >= 1);
  if (n == 1) return 0;
  const int e = 31 - __builtin_clz(n);
  return (n < 3 << (e - 1)) ? (1 << (e - 1)) : (n - (1 << e));
}


namespace brute {
constexpr int LIM_N = 100;
Int bn[LIM_N][LIM_N];
int cost[LIM_N], ls[LIM_N], rs[LIM_N];
Int way[LIM_N];
int cutMns[LIM_N], cutMxs[LIM_N];
vector<int> mns[LIM_N], mxs[LIM_N];
void run() {
  for (int n = 0; n < LIM_N; ++n) {
    bn[n][0] = bn[n][n] = 1;
    for (int k = 1; k < n; ++k) {
      bn[n][k] = min(bn[n - 1][k - 1] + bn[n - 1][k], INF);
    }
  }
  cost[0] = 0;
  way[0] = 1;
  for (int n = 1; n < LIM_N; ++n) {
    cost[n] = n * (n + 1) / 2 + 1;
    for (int i = 0; i < n; ++i) {
      chmin(cost[n], n + cost[i] + cost[n - 1 - i]);
    }
    ls[n] = n;
    rs[n] = -1;
    for (int i = 0; i < n; ++i) {
      if (cost[n] == n + cost[i] + cost[n - 1 - i]) {
        chmin(ls[n], i);
        chmax(rs[n], i);
      }
    }
    for (int i = ls[n]; i <= rs[n]; ++i) {
      assert(cost[n] == n + cost[i] + cost[n - 1 - i]);
    }
    mns[n] = {n};
    for (int i = ls[n]; i <= rs[n]; ++i) {
      chmin(way[n] += mul(bn[n - 1][i], mul(way[i], way[n - 1 - i])), INF);
      {
        vector<int> tmp;
        for (const int a : mns[i]) tmp.push_back(a);
        tmp.push_back(n - 1);
        for (const int a : mns[n - 1 - i]) tmp.push_back(i + a);
        if (chmin(mns[n], tmp)) cutMns[n] = i;
      }
      {
        vector<int> tmp;
        for (const int a : mns[i]) tmp.push_back(n - 1 - i + a);
        tmp.push_back(n - 1);
        for (const int a : mns[n - 1 - i]) tmp.push_back(a);
        if (chmax(mxs[n], tmp)) cutMxs[n] = i;
      }
    }
    const bool greedMn = (way[n - 1 - cutMns[n]] >= INF);
    const bool greedMx = (way[n - 1 - cutMxs[n]] >= INF);
cerr<<n<<": "<<cost[n]<<" ["<<ls[n]<<", "<<rs[n]<<"] "<<way[n]<<" "<<cutMns[n]<<" "<<cutMxs[n]<<" "<<greedMn<<" "<<greedMx<<endl;
// if(n<=35)cerr<<mns[n]<<endl<<mxs[n]<<endl;
    assert(ls[n] == L(n));
    assert(rs[n] == R(n));
    assert(cutMns[n] == C(n));
    assert(cutMxs[n] == L(n));
  }
}
}  // brute


namespace fast {
constexpr int LIM_N = 40;

Int bn[LIM_N][LIM_N];
Int all[LIM_N];
Int dp[LIM_N][LIM_N][LIM_N];
Int dpSum[LIM_N][LIM_N][LIM_N];
int seqs[LIM_N][LIM_N];

vector<int> solve(int O, int N, Int K) {
  if (N == 0) {
    return {};
  } else if (N >= LIM_N || K == 0) {
    const int cut = O ? L(N) : C(N);
    const auto resL = solve(O, cut, 0);
    const auto resR = solve(O, N - 1 - cut, K);
    vector<int> ret;
    for (const int a : resL) ret.push_back(O ? (N - 1 - cut + a) : a);
    ret.push_back(N - 1);
    for (const int a : resR) ret.push_back(O ? a : (cut + a));
    return ret;
  } else {
// cerr<<COLOR("33")<<"[solve] O = "<<O<<", N = "<<N<<", K = "<<K<<COLOR()<<endl;
    for (int n = 0; n <= N; ++n) {
      bn[n][0] = bn[n][n] = 1;
      for (int k = 1; k < n; ++k) {
        bn[n][k] = min(bn[n - 1][k - 1] + bn[n - 1][k], INF);
      }
    }
    fill(all, all + (N + 1), 0);
    all[0] = 1;
    for (int n = 1; n <= N; ++n) {
      const int cutL = L(n);
      const int cutR = R(n);
      for (int i = cutL; i <= cutR; ++i) {
        chmin(all[n] += mul(bn[n - 1][i], mul(all[i], all[n - 1 - i])), INF);
      }
    }
    if (K >= all[N]) {
      return {-2};
    }
    
    memset(dp, 0, sizeof(dp));
    memset(dpSum, 0, sizeof(dpSum));
    vector<int> ret(N, -1);
    // used[i] := set ret[0, i)
    vector<Int> used(N + 1, 0);
    // seqs[l][l, i]: ret[l, i] when ret[0, l) are removed
    memset(seqs, ~0, sizeof(seqs));
    for (int i = 0; i < N; ++i) {
      for (int a = O ? (N - 1) : 0; 0 <= a && a < N; O ? --a : ++a) if (!(used[i] & 1LL << a)) {
        ret[i] = a;
        used[i + 1] = used[i] | 1LL << a;
        for (int l = i; l >= 0; --l) {
          seqs[l][i] = a - __builtin_popcountll(used[l] & ((1LL << a) - 1));
        }
        // dp[l][r][h]: value range [0, h) when ret[0, l) are ignored, max = h-1
        for (int l = i; l >= 0; --l) for (int r = i + 1; r <= N; ++r) {
          const int cutL = l + L(r - l);
          const int cutR = l + R(r - l);
          const int m = max_element(seqs[l] + l, seqs[l] + r) - seqs[l];
          fill(dp[l][r], dp[l][r] + (N + 1), 0);
          fill(dpSum[l][r], dpSum[l][r] + (N + 1), 0);
          for (int h = max(seqs[l][m] + 1, r - l); h <= N; ++h) {
            dp[l][r][h] = 0;
            if (seqs[l][m] == h - 1) {
              // max is already put
              if (cutL <= m && m <= cutR) {
                Int way = 1;
                if (l < m) {
                  way = mul(way, dp[l][m][*max_element(seqs[l] + l, seqs[l] + m) + 1]);
                }
                if (m == i) {
                  way = mul(way, mul(bn[h - 1 - (m - l)][r - (m + 1)], all[r - (m + 1)]));
                } else if (m + 1 < r) {
                  way = mul(way, dpSum[m + 1][r][h - 1 - (m - l)]);
                }
                chmin(dp[l][r][h] += way, INF);
              }
            } else {
              // choose max position
              for (int c = cutL; c <= cutR; ++c) if (!~seqs[l][c]) {
                Int way = 1;
                if (l < c) {
                  way = mul(way, dpSum[l][c][h - 1]);
                }
                way = mul(way, mul(bn[h - 1 - (c - l)][r - (c + 1)], all[r - (c + 1)]));
                chmin(dp[l][r][h] += way, INF);
              }
            }
// cerr<<"  dp["<<l<<"]["<<r<<"]["<<h<<"] = "<<dp[l][r][h]<<endl;
            dpSum[l][r][h] = min(dpSum[l][r][h - 1] + dp[l][r][h], INF);
          }
        }
// cerr<<"prefix "<<ret<<": "<<dp[0][N][N]<<endl;
// for(int l=0;l<=i;++l){cerr<<"  seqs["<<l<<"] = ";pv(seqs[l],seqs[l]+N);}
        if (K >= dp[0][N][N]) {
          K -= dp[0][N][N];
        } else {
          goto found;
        }
      }
      assert(false);
     found:{}
    }
    return ret;
  }
}
}  // fast


int main() {
  // brute::run();
  
  int N;
  Int K[2];
  for (; ~scanf("%d%lld%lld", &N, &K[0], &K[1]); ) {
    for (int O = 0; O < 2; ++O) {
      --K[O];
      const auto ans = fast::solve(O, N, K[O]);
      for (int i = 0; i < (int)ans.size(); ++i) {
        if (i) printf(" ");
        printf("%d", ans[i] + 1);
      }
      puts("");
    }
  }
  return 0;
}