Problem:
Score : 400 points

Problem Statement

Snuke has an empty sequence a.

He will perform N operations on this sequence.

In the i-th operation, he chooses an integer j satisfying 1 \leq j \leq i, and insert j at position j in a (the beginning is position 1).

You are given a sequence b of length N. Determine if it is possible that a is equal to b after N operations. If it is, show one possible sequence of operations that achieves it.

Constraints

All values in input are integers.

1 \leq N \leq 100

1 \leq b_i \leq N

Input

Input is given from Standard Input in the following format:

N
b_1 \dots b_N

Output

If there is no sequence of N operations after which a would be equal to b, print -1.
If there is, print N lines. In the i-th line, the integer chosen in the i-th operation should be printed. If there are multiple solutions, any of them is accepted.

Sample Input 1

3
1 2 1

Sample Output 1

1
1
2

In this sequence of operations, the sequence a changes as follows:

After the first operation: (1)

After the second operation: (1,1)

After the third operation: (1,2,1)

Sample Input 2

2
2 2

Sample Output 2

-1

2 cannot be inserted at the beginning of the sequence, so this is impossible.

Sample Input 3

9
1 1 1 2 2 1 2 3 2

Sample Output 3

1
2
2
3
1
2
2
1
1

Solution in Python (3.8.2) (judge verdict: Wrong Answer)

import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    n = I()
    b = LI()
    ans_lst = []

    while len(b)!=0:
        lst = collections.deque([])
        mx = 1
        phase = False
        while len(b)!=0:
            nxt = b.pop()
            mx = max(mx, nxt)
            if mx==1:
                lst.appendleft(nxt)
            else:
                phase |= nxt == 1
                if phase and nxt != 1:
                    b.append(nxt)
                    break
                else:
                    lst.appendleft(nxt)

        ctn = True
        up = True
        now_mx = 0
        now_mn = mx
        lenth = 0
        for x in lst:
            if up:
                if x>=now_mx:
                    if x==mx:
                        up = False
                    else:
                        lenth += 1
                else:
                    ctn = False
                    break
            else:
                if x<=now_mn:
                    now_mn = min(now_mn, x)
                else:
                    ctn = False
                    break
        
        if not ctn or lenth+1<mx or lst[0] != 1:
            print(-1)
            exit(0)
        
        gr = [[k,len(list(g))] for k, g in itertools.groupby(lst)]
        com = len(lst)
        phase = False
        down = False
        now_len = 0
        i = 0

        while com!= 0:
            nxt = lst[-1]
            if not phase:
                if now_len+1 < nxt:
                    if not down:
                        if gr[i][0] == mx:
                            down = True
                            i -= 1
                        else:
                            ans_lst.append(gr[i][0])
                            now_len += 1
                            com -= 1
                            gr[i][1] -= 1
                            i += 1
                    else:
                        if gr[i][1] == 0:
                            i -= 1
                        else:
                            ans_lst.append(gr[i][0])
                            now_len += 1
                            com -= 1
                            gr[i][1] -= 1
                else:
                    ans_lst.append(nxt)
                    com -= 1
                    lst.pop()
                    phase |= nxt == mx
            else:
                if nxt == mx:
                    ans_lst.append(nxt)
                    com -= 1
                    lst.pop()
                else:
                    if not down:
                        if gr[i][0] == mx:
                            down = True
                            i -= 1
                        else:
                            ans_lst.append(gr[i][0])
                            com -= 1
                            gr[i][1] -= 1
                            i += 1
                    else:
                        if gr[i][1] == 0:
                            i -= 1
                        else:
                            ans_lst.append(gr[i][0])
                            com -= 1
                            gr[i][1] -= 1

    print(*ans_lst, sep="\n")

main()