#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using ll = __int128_t;

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    int n, b;
    string tmp;
    cin >> n >> b >> tmp;

    ll K = 0;
    for (char& c : tmp) K = K * 10 + (c - '0');
    K--;
    vector<int> ans;
    vector<bool> used(n, false);
    for (int p = 0; p < n; p++) {
        for (int d = 0; d < n; d++) {
            if (used[d]) continue;
            int nb = b - abs(p - d);
            if (nb < 0) continue;
            used[d] = true;
            int cnt = 0, sum = 0;
            for (int i = 0; i <= p; i++) {
                if (used[i]) continue;
                cnt++;
                sum += abs(p + 1 - i);
            }
            if (sum > nb) continue;
            nb -= sum;
            vector dp(n + 1, vector<ll>(nb + 1, 0)), ndp(n + 1, vector<ll>(nb + 1, 0));
            dp[cnt][0] = 1;
            debug(nb);
            for (int k = p + 1, add = 0; k < n; k++, add++) {
                for (int i = 0; i <= n; i++) {
                    for (int j = 0; j <= nb; j++) {
                        ll& val = dp[i][j];
                        if (val == 0) continue;
                        int x = not used[k];
                        int rest = add - (cnt - i);
                        if (i > 0 and rest > 0 and not used[k]) {  // use a and b
                            int ni = i - 1, nj = j + ni + (rest - 1);
                            if (nj <= nb) ndp[ni][nj] += val * i * rest;
                        }
                        if (not used[k]) {  // link a and b
                            int ni = i, nj = j + ni + rest;
                            if (nj <= nb) ndp[ni][nj] += val;
                        }
                        if (i > 0) {  // use a
                            int ni = i - 1 + x, nj = j + ni + rest;
                            if (nj <= nb) ndp[ni][nj] += val * i;
                        }
                        if (not used[k]) {  // use b
                            int ni = i, nj = j + ni + rest;
                            if (nj <= nb) ndp[ni][nj] += val * rest;
                        }
                        {
                            int ni = i + x, nj = j + ni + rest + 1;
                            if (nj <= nb) ndp[ni][nj] += val;
                        }
                        val = 0;
                    }
                }
                cnt += (not used[k]);
                swap(dp, ndp);
            }
            ll val = dp[0][nb];
            debug(p, d, (long long)val);
            if (K < val) {
                ans.emplace_back(d);
                break;
            } else {
                K -= val;
                used[d] = false;
            }
        }
        b -= abs(p - ans.back());
        debug(used);
    }

    for (int i = 0; i < n; i++) cout << ans[i] + 1 << (i + 1 == n ? "\n" : " ");
    return 0;
}