#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define REP(i,n) for(int i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010

#define SUBMIT

ll N, A, B;

void Disp(const vector<ll>& ans) {
    REP(i, ans.size()) { printf("%lld%c", ans[i], (i == ans.size()-1) ? '\n' : ' '); }
}

// 最長増加部分列の長さを返す O(n log n)
ll lis(const vector<ll>& v) {
    ll ret = 0;
    // 増加部分列の長さが i のとき、一番右に来る数字の最小値(dp 内の値は単調増加になる)
    vector<ll> dp(v.size(), LLINF);
    for(int i = 0; i < v.size(); ++i) {
        auto it = upper_bound(dp.begin(), dp.end(), v[i]);
        *it = v[i];
        ret = max(ret, static_cast<ll>(it - dp.begin()));
    }
    // LLINF でない最大のインデックス + 1 が LIS になる
    return ret + 1;
}

// 最長減少部分列の長さを返す O(n log n)
ll lds(const vector<ll>& v) {
    vector<ll> minus_v;
    for(auto& val : v) { minus_v.push_back(-val); }
    return lis(minus_v);
}

// 全パターン試す
vector<ll> blute_force() {
    // 数列の作成
    vector<ll> v;
    REP(i, N) { v.push_back(i + 1); }
    do {
        if(A == lis(v) && B == lds(v)) { return v; }
    } while(next_permutation(v.begin(), v.end()));
    vector<ll> ret = {-1};
    return ret;
}

vector<ll> solve() {
    // 数列の作成
    vector<ll> v, rev_v(N+1);
    REP(i, N) {
        v.push_back(i + 1);
        rev_v[v[i]] = N - i;
    }

    bool isReverse = (B > A);
    if(isReverse) { swap(B, A); }

    // 数列を B 個ごとのグループにする
    ll group_num = N / B;   // グループ数
    if(N % B != 0) { group_num++; }
    vector< vector<ll> > group(group_num, vector<ll>());
    // ひとつめのグループ
    int tmp_val = 1;
    REP(i, N % B) {
        group[0].push_back(tmp_val);
        tmp_val++;
    }
    // それ以降のグループ
    for(int ind = (group[0].size() > 0) ? 1 : 0; ind < group_num; ++ind) {
        REP(j, B) {
            group[ind].push_back(tmp_val);
            tmp_val++;
        }
    }
    assert(tmp_val - 1 == N);

    // LIS が A になるまでグループを解体
    ll a = group_num;
    ll demise = -1;     // 解体するグループの最大インデックス
    ll d_cnt = 0;       // 解体した要素の総和
    while(a < A && demise != group_num-1) {
        demise++;
        // グループ demise を解体
        d_cnt += group[demise].size();
        a = d_cnt + (group_num - demise - 1);
    }

    //DBG("demise: %lld a: %lld\n", demise, a);

    if(demise == group_num-1) {
        // 全てのグループを解体してしまった
        vector<ll> minus = {-1};
        return minus;
    }

    if(a > A) {
        if(demise < 0) {
            vector<ll> minus = {-1};
            return minus;
        }
        assert(a - A < group[demise].size());

        // このグループ内で作成したい昇順の要素数
        ll want = A - (a - group[demise].size());
        // 昇順のまま残す連続した要素数
        ll remain = want - 1;
        vector<ll> tmp;
        for(int i = remain; i < group[demise].size(); ++i) { tmp.push_back(group[demise][i]); }
        reverse(tmp.begin(), tmp.end());
        for(int i = remain; i < group[demise].size(); ++i) { group[demise][i] = tmp[i - remain]; }
    }

    // 答えの作成
    vector<ll> ret;
    REP(i, group_num) {
        if(i > demise) {
            reverse(group[i].begin(), group[i].end());
        }
        REP(j, group[i].size()) {
            ret.push_back(group[i][j]);
        }
    }

    if(isReverse) {
        REP(i, ret.size()) {
            ret[i] = rev_v[ret[i]];
        }
        swap(A, B);
    }
    return ret;
}

signed main()
{
#ifdef SUBMIT
    cin >> N >> A >> B;
    vector<ll> ans = solve();
    //vector<ll> ans = blute_force();
    Disp(ans);
#else
#  if 1
    for(int n = 1; n <= 9; ++n) {
        N = n;
        for(int a = 1; a <= n; ++a) {
            for(int b = 1; b <= n; ++b) {
                A = a; B = b;
                printf("N: %lld A: %lld B:%lld\n", N, A, B);
                vector<ll> cand = solve();
                vector<ll> ans = blute_force();
                // check
                if(cand[0] == -1) {
                    if(cand[0] != ans[0]) {
                        //printf("N: %lld A: %lld B:%lld ans: ", N, A, B);
                        printf("  ans: ");
                        Disp(ans);
                        return 0;
                    }
                }
                else {
                    if(lis(cand) != A || lds(cand) != B) {
                        printf("  N: %lld A: %lld B:%lld\n", N, A, B);
                        printf("  lis: %lld lds: %lld cand: ", lis(cand), lds(cand));
                        Disp(cand);
                        return 0;
                    }
                }
            }
        }
    }
#  else
    for(int n = 1; n <= 8; ++n) {
        N = n;
        printf("N: %lld\n", N);
        for(int a = 1; a <= n; ++a) {
            for(int b = 1; b <= n; ++b) {
                A = a; B = b;
                vector<ll> ans = blute_force();
                printf("  A: %lld B:%lld ans: ", A, B);
                Disp(ans);
            }
        }
    }
#  endif
#endif
    return 0;
}


Measured memory_bytes: 28908