#include <bits/stdc++.h>

using i128 = __int128_t;

template <typename Tp>
void read(Tp &res) {
    char ch;
    ch = std::cin.get();
    while (!isdigit(ch)) {
        ch = std::cin.get();
    }
    res = 0;
    while (isdigit(ch)) {
        res = res * 10 + int(ch - 48);
        ch = std::cin.get();
    }
}

constexpr int N = 30;
i128 dp[2][N * N + 1][N][N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, b;
    i128 k;

    read(n), read(b), read(k);

    std::vector<uint8_t> upper(n), lower(n);
    std::vector<int> ans;

    auto check = [&]() -> i128 {
        memset(dp[1], 0, sizeof(dp[1]));
        dp[1][0][0][0] = 1;

        for (int i = 0; i < n; ++i) {
            memset(dp[i & 1], 0, sizeof(dp[i & 1]));
            for (int j = 0; j <= i * i; ++j) {
                for (int a = 0; a <= i; ++a) {
                    for (int b = 0; b <= i; ++b) {
                        if (dp[i & 1 ^ 1][j][a][b] == 0) {
                            continue;
                        }
                        i128 val = dp[i & 1 ^ 1][j][a][b];
                        
                        if (!upper[i] && !lower[i]) {
                            // null
                            dp[i & 1][j + a + b][a][b] += val;

                            // a -= 1 a += 1
                            dp[i & 1][j + a + b][a][b] += a * val;

                            // b -= 1 b += 1
                            dp[i & 1][j + a + b][a][b] += b * val;

                            // a -= 1 b -= 1
                            if (a && b) {
                                dp[i & 1][j + a + b][a - 1][b - 1] += a * b * val;
                            }

                            // a += 1 b += 1
                            dp[i & 1][j + a + b][a + 1][b + 1] += val;
                        } else if (!lower[i]) {
                            dp[i & 1][j + a + b][a + 1][b] += val;
                            if (b) {
                                dp[i & 1][j + a + b][a][b - 1] += b * val;
                            }
                        } else if (!upper[i]) {
                            dp[i & 1][j + a + b][a][b + 1] += val;
                            if (a) {
                                dp[i & 1][j + a + b][a - 1][b] += a * val;
                            }
                        } else {
                            dp[i & 1][j + a + b][a][b] += val;
                        }
                    }
                }
            }
        }

        return dp[(n - 1) & 1][b][0][0];
    };

    for (int i = 0; i < n; ++i) {
        upper[i] = true;
        for (int j = 0; j < n; ++j) {
            if (!lower[j]) {
                int tmp_b = b;
                b -= abs(i - j);
                if (b < 0) {
                    continue;
                }

                lower[j] = true;
                i128 num = check();
                
                
                // for (int p = 0; p < n; ++p) {
                //     std::cout << (int)upper[p];
                // }
                // std::cout << '\n';
                // for (int p = 0; p < n; ++p) {
                //     std::cout << (int)lower[p];
                // }
                // std::cout << '\n';
                // std::cout << "k, num = " << (int)k << ", " << (int)num << '\n';
                if (k <= num) {
                    ans.push_back(j + 1);
                    break;
                }
                b = tmp_b;
                k -= num;
                lower[j] = false;
            }
        }
    }

    for (int i : ans) {
        std::cout << i << ' ';
    }
}