Wrong LIS Algorithm

Jeonghyeon and Seojun learned an algorithm in their computer science class that finds the length of the longest increasing subsequence (LIS) of a sequence. Jeonghyeon found it too tedious to implement, so he wrote his own (incorrect) algorithm and started solving problems with it. Of course, the algorithm could not solve the problems, and he received "wrong answer" on several homework problems from an online judge.

Given a sequence $A$ of length $N$ where the $i$-th element is $A_i$, Jeonghyeon's algorithm builds a sequence $B$ as follows and returns it:

B = empty sequence
for i = 1 to n:
    if B is empty or the last element of B is less than A_i:
        append A_i to the end of B

The sequence $B$ returned by the algorithm is an increasing subsequence of $A$, but it is not always the longest one, so the algorithm is incorrect. Seojun noticed the mistake and wants to show Jeonghyeon a counterexample. Jeonghyeon refuses to accept the claim without one.

Seojun wants to find a sequence of length $N$ that contains each positive integer from $1$ to $N$ exactly once, where the longest increasing subsequence has length $M$ and the subsequence returned by Jeonghyeon's algorithm has length $K$. Help Seojun find such a sequence.

Three integers $N$, $M$, and $K$ are given, separated by spaces. $(2 \leq N \leq 300 000$; $1 \leq K < M \leq N)$

If a sequence that satisfies the conditions exists, print one such sequence. Print its $N$ elements in order, separated by spaces. If no such sequence exists, print -1.

The longest increasing subsequence of a sequence $A_i$ is the longest increasing sequence among all subsequences of $A_i$.

A subsequence is a sequence obtained by choosing one or more elements of the given sequence and listing them in their original order.

An increasing sequence is a sequence in which every element after the first is greater than the element immediately before it. In other words, if $C$ is a sequence of length $N$ and $C_{i-1} < C_i$ holds for all $2 \le i \le N$, then $C$ is increasing. By this definition, every sequence of length 1 is increasing.

Below are implementations of Jeonghyeon's algorithm in C++, Python 3, and Java.

C++

vector<int> b;
for(int x : a){
    if(b.empty() || b.back() < x){
        b.push_back(x);
    }
}

Python 3

b = []
for x in a:
    if not b or b[-1] < x:
        b.append(x)

Java

ArrayList<Integer> b = new ArrayList<Integer>();
for(int x : a){
    if(b.isEmpty() || b.get(b.size() - 1) < x){
        b.add(x);
    }
}