#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 <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; }


vector<string> PRE[16];
void experiment() {
  for (int n = 1; n < 16; ++n) {
    int mn = n * n + 1;
    vector<string> ss;
    for (int p = 0; p < 1 << n; ++p) {
      string s(n, '?');
      for (int i = 0; i < n; ++i) s[n - 1 - i] = "01"[p >> i & 1];
      auto isPalin = [&](int i, int j) -> bool {
        --j;
        for (; i < j; ++i, --j) {
          if (s[i] != s[j]) return false;
        }
        return true;
      };
      int cnt = 0;
      for (int i = 0; i < n; ++i) for (int j = i + 1; j <= n; ++j) {
        if (isPalin(i, j)) {
          ++cnt;
        }
      }
      if (chmin(mn, cnt)) ss.clear();
      if (mn == cnt) ss.push_back(s);
    }
    // cerr << n << ": " << mn << " " << ss.size() << endl;
    for (const auto &s : ss) {
      PRE[n].push_back(s);
      // cout << s << endl;
    }
  }
}
/*
15: 28 12
001011001011001
001101001101001
010011010011010
010110010110010
011001011001011
011010011010011
100101100101100
100110100110100
101001101001101
101100101100101
110010110010110
110100110100110
*/

vector<Int> solve(int N, Int M, Int K) {
  if (M == 1) {
    if (K > 1) {
      return {};
    }
    return vector<Int>(N, 0);
  } else if (M == 2) {
    const int len = min(N, 6);
    if (K > (int)PRE[len].size()) {
      return {};
    }
    vector<Int> ans(N, -1);
    for (int i = 0; i < N; ++i) {
      ans[i] = PRE[len][K - 1][i % 6] - '0';
    }
    return ans;
  } else {
    vector<Int> prod(N + 1);
    prod[N] = 1;
    for (int i = N; --i >= 0; ) {
      const __int128 b = ((i == 0) ? M : (i == 1) ? (M - 1) : (M - 2));
      prod[i] = min<__int128>(b * prod[i + 1], K + 1);
    }
    if (K > prod[0]) {
      return {};
    }
    vector<Int> ans(N, -1);
    Int k = K;
    for (int i = 0; i < N; ++i) {
      const Int q = (k - 1) / prod[i + 1];
      k -= prod[i + 1] * q;
      ans[i] = q;
      if (i == 0) {
        //
      } else if (i == 1) {
        if (ans[i - 1] <= ans[i]) ++ans[i];
      } else {
        const Int a = min(ans[i - 2], ans[i - 1]);
        const Int b = max(ans[i - 2], ans[i - 1]);
        if (a <= ans[i]) ++ans[i];
        if (b <= ans[i]) ++ans[i];
      }
    }
    return ans;
  }
}

int main() {
  // needed
  experiment();
  
  int N;
  Int M, K;
  for (; ~scanf("%d%lld%lld", &N, &M, &K); ) {
    const auto ans = solve(N, M, K);
    if (!ans.empty()) {
      for (int i = 0; i < N; ++i) {
        if (i) printf(" ");
        printf("%lld", ans[i] + 1);
      }
      puts("");
    } else {
      puts("-1");
    }
  }
  return 0;
}