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.

Examples

Input

3
1 2 1


Output

1
1
2


Input

2
2 2


Output

-1


Input

9
1 1 1 2 2 1 2 3 2


Output

1
2
2
3
1
2
2
1
1
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        PrintWriter out = new PrintWriter(System.out);
        InputStreamScanner in = new InputStreamScanner(System.in);
        new Main().solve(in, out);
        out.flush();
    }

    private void solve(InputStreamScanner in, PrintWriter out) {
        int n = in.nextInt();
        int[] a = new int[n + 1];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }

        ArrayDeque<Act> q = new ArrayDeque<>();
        q.push(new Act(new int[0], a));
        List<Act> memo = new ArrayList<>();

        while (!q.isEmpty()) {
            Act x = q.pop();
            if (x.r[0] == 0) {
                for (int i = x.p.length - 1; i >= 0; i--) {
                    out.println(x.p[i]);
                }
                return;
            }

            for (int i = x.r.length - 1; i >= 0; i--) {
                if (x.r[i] == 0) {
                    continue;
                }
                if (x.r[i] == i + 1) {
                    int[] p = Arrays.copyOf(x.p, x.p.length + 1);
                    p[x.p.length] = i + 1;
                    int[] r = Arrays.copyOf(x.r, n + 1);
                    for (int j = i; j < n; j++) {
                        r[j] = r[j + 1];
                    }
                    Act na = new Act(p, r);
                    if (!memo.contains(na)) {
                        memo.add(na);
                        q.push(new Act(p, r));
                        break;
                    }
                }
            }
        }

        out.println(-1);
    }

    static class Act {
        int[] p;
        int[] r;

        Act (int[] p, int[] r) {
            this.p = p;
            this.r = r;
        }

        @Override
        public boolean equals(Object obj) {
            Act o = (Act)obj;
            return Arrays.equals(this.r, o.r);
        }
    }

    static class InputStreamScanner {

        private InputStream in;

        private byte[] buf = new byte[1024];
        private int len = 0;
        private int off = 0;

        InputStreamScanner(InputStream in)	{
            this.in = in;
        }

        String next() {
            StringBuilder sb = new StringBuilder();
            for (int b = skip(); !isSpace(b);){
                sb.appendCodePoint(b);
                b = read();
            }
            return sb.toString();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        char nextChar() {
            return (char)skip();
        }

        int skip() {
            for (int b; (b = read()) != -1;) {
                if (!isSpace(b)) {
                    return b;
                }
            }
            return -1;
        }

        private boolean isSpace(int c) {
            return c < 33 || c > 126;
        }

        private int read() {
            if (len == -1) {
                throw new InputMismatchException("End of Input");
            }
            if (off >= len){
                off = 0;
                try {
                    len = in.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException(e.getMessage());
                }
                if (len <= 0) {
                    return -1;
                }
            }
            return buf[off++];
        }
    }
}