#include <bits/stdc++.h>
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define st first
#define nd second
using namespace std;
typedef long long ll;
const ll inf = 1e18 + 7;
const int N = 1e2 + 5;
ll C[N][N], dp[N], cnt[N];

int cur[N], vis[N];

int balanced(int l, int r) {
  int tmp = 0;
  for (int i = l; i <= r; i++) {
    int mx = 0;
    for (int j = i; j <= r; j++) {
      mx = max(mx, cur[j]);
      tmp += mx == cur[i] || mx == cur[j];
    }
  }
  return tmp == dp[r - l + 1];
}

ll brute(int i, int n) {
  for (int j = i, k = 1; j < n; j++) {
    while (k <= n && vis[k])
      k++;
    cur[j] = k++;
  }
  int r = 0;
  do {
    r += balanced(0, n - 1);
  } while (next_permutation(cur + i, cur + n));
  for (int j = i; j < n; j++)
    cur[j] = 0;
  return r;
}

// len_of_prefix, len_of_tot, n, available numbers
ll count(int l, int r, int len, int n, ll k, vector<int> nums, vector<int> rhs) {
  // cout << l << " " << r << " " << len << " ("; for (int i: nums) cout << i << ", "; cout << ")" << endl;
  if (sz(nums) < len - (r - l))
    return 0;
  if (0 == r - l || len == r - l) {
    ll ret = 0;
    int j = sz(nums);
    if (r - l == len) {
      ret = balanced(l, r - 1);
    } else {
      if (C[sz(nums)][len] > k / cnt[len])
        ret = k;
      else
        ret = min(k, cnt[len] * C[sz(nums)][len]);
      j -= len;
    }
    for (int i = sz(rhs) - 1; i >= 0 && ret < k && ret > 0; i--) {
      if (rhs[i] <= 0) {
        rhs[i] = -rhs[i];
        if (C[j][rhs[i]] > k / ret)
          ret = k;
        else
          ret = min(k, ret * C[j][rhs[i]]);
        j -= rhs[i];
      } else
        j++;
    }
    return ret;
  }
  int mx = 0;
  for (int i = l; i < r; i++)
    mx = max(mx, cur[i]);
  ll ret = 0;
  while (sz(nums) >= len - (r - l) && nums.back() > mx) {
    int val = nums.back();
    nums.pop_back();
    rhs.push_back(0);
    for (int i = r; i < l + len && ret < k; i++) {
      if (dp[i - l] + dp[l + len - i - 1] + len == dp[len]) {
        rhs.back() = -(l + len - i - 1);
        ll tmp = count(l, r, i - l, n, k, nums, rhs);
        if (tmp > k / cnt[l + len - i - 1])
          tmp = k;
        else
          tmp *= cnt[l + len - i - 1];
        ret = min(k, ret + tmp);
      }
    }
    rhs.back() = val;
  }
  if (sz(nums) < len - (r - l))
    return ret;
  int i = l;
  while (i < r && cur[i] != mx)
    i++;
  assert(i < r);
  if (dp[i - l] + dp[l + len - i - 1] + len == dp[len] && balanced(l, i - 1))
    ret = min(k, ret + count(i + 1, r, l + len - i - 1, n, k, nums, rhs));
  return ret;
}

void dfs(int i, int n, ll& k, int mn) {
  if (k == 0)
    return;
  if (i > 0) {
    vector<int> nums;
    for (int j = 1; j <= n; j++)
      if (!vis[j])
        nums.push_back(j);
    ll kk = count(0, i, n, n, k, nums, {});
    if (k > kk) {
      k -= kk;
      return;
    }
    if (i == n && kk > 0)
      k--;
  }
  if (i == n)
    return;
  if (mn) {
    cur[i] = 0;
    while (cur[i] < n && k > 0) {
      cur[i]++;
      if (!vis[cur[i]]) {
        vis[cur[i]] = 1;
        dfs(i + 1, n, k, mn);
        vis[cur[i]] = 0;
      }
    }
  } else {
    cur[i] = n + 1;
    while (cur[i] > 1 && k > 0) {
      cur[i]--;
      if (!vis[cur[i]]) {
        vis[cur[i]] = 1;
        dfs(i + 1, n, k, mn);
        vis[cur[i]] = 0;
      }
    }
  }
}

void prep() {
  for (int i = 0; i < N; C[i++][0] = 1)
    for (int j = 1; j <= i; j++)
      C[i][j] = min(inf, C[i - 1][j] + C[i - 1][j - 1]);
  dp[0] = 0, cnt[0] = 1;
  for (int i = 1; i < N; i++) {
    dp[i] = inf;
    for (int j = 0; j < i; j++)
      dp[i] = min(dp[j] + dp[i - j - 1], dp[i]);
    dp[i] += i;
    for (int j = 0; j < i; j++) {
      if (dp[j] + dp[i - j - 1] + i == dp[i]) {
        ll v = cnt[j];
        if (v > inf / cnt[i - j - 1])
          v = inf;
        else
          v = min(inf, v * cnt[i - j - 1]);
        if (v > inf / C[i - 1][j])
          v = inf;
        else
          v = min(inf, v * C[i - 1][j]);
        cnt[i] = min(inf, cnt[i] + v);
      }
    }
  }
}

void solve(int n, ll x, int mn) {
  int h = 1;
  while ((1 << h) - 1 < n)
    h++;
  h--;
  vector<int> a(1 << h), pos(1 << h);
  if (mn == 1) {
    for (int i = h - 1, l = 1; i >= 0; i--, l *= 2) {
      for (int j = i + 1; j <= i + l; j++) {
        if (j != i + 1)
          a[j + l - 1] = a[j];
        a[j] ^= l;
      }
    }
  } else {
    for (int i = 0; i < (1 << h); i++)
      a[i] = (1 << h) - 1 - i;
  }
  for (int i = 0; i < (1 << h); i++)
    pos[a[i]] = i;
  int leaves = n - (1 << h) + 1, val = 1, idx = 0;
  vector<int> arr(n), s(n);
  function<int(int)> build = [&](int k) {
    if (k - 1 >= (1 << h) - 1) {
      if (pos[k - (1 << h)] < leaves) {
        arr[idx] = val++;
        return s[idx++] = 1;
      }
      return 0;
    }
    int ret = build(2 * k + !mn);
    int tmp = idx++;
    ret += build(2 * k + mn);
    arr[tmp] = val++;
    return s[tmp] = ++ret;
  };
  build(1);
  if (mn == 0) {
    reverse(arr.begin(), arr.end());
    reverse(s.begin(), s.end());
  }
  int ok = 0;
  for (int i = n - 1; i >= 0; i--) {
    if (s[i] > 22) {
      assert(s[i] <= 39);
      dfs(0, s[i], x, mn);
      int j = i;
      while (j >= 0 && arr[j] <= arr[i])
        j--;
      j++;
      vector<int> tmp;
      for (int k = j; k < n; k++)
        tmp.push_back(arr[k]);
      sort(all(tmp));
      for (int k = j; k < n; k++)
        arr[k] = tmp[cur[k - j] - 1];
      ok = 1;
      break;
    }
  }
  if (ok == 0) {
    dfs(0, n, x, mn);
    for (int i = 0; i < n; i++)
      arr[i] = cur[i];
  }
  if (x > 0) {
    cout << "-1\n";
  } else {
    for (int i = 0; i < n; i++)
     cout << arr[i] << " \n"[i + 1 == n];
  }
}

int main() {
  ios_base::sync_with_stdio(false); cin.tie(0);
  int n; ll x, y; cin >> n >> x >> y;
  prep();
  solve(n, x, 1);
  for (int i = 0; i < N; i++)
    cur[i] = vis[i] = 0;
  solve(n, y, 0);
}


/*
build a cartesian tree. permutation is balanced iff this tree is almost complete.
Observe that #balanced_permutations > 10^18 for n > 22 -> build greedily the lex-min/max
and brute force the last subtree with > 22 nodes (size <= 39). Use dp to optimize.
*/