Given an array a of length n, find another array, b, of length n such that:

  * for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i. 



The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.

If such array doesn't exist, determine this.

Input

The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.

The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.

Output

If there's no such array, print a single line containing -1.

Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)

If there are multiple answers, print any.

Examples

Input


3
1 2 3


Output


0 1 2 

Input


4
0 0 0 2


Output


1 3 4 0 

Input


3
1 1 3


Output


0 2 1 

Note

In the second test case, other answers like [1,1,1,0], for example, are valid.
	import java.io.*;
	import java.util.*;
	import java.math.*;
	
	 
	 public class Main	{
	   static class Pair implements Comparable<Pair>{
	   int a;
	   int b;
	   public Pair(int x,int y){a=x;b=y;}
	   public Pair(){}
	   public int compareTo(Pair p){
		 return a - p.a;
	   }
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + a;
		result = prime * result + b;
	//	out.println("hashcode = "+result);
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		Pair cur = (Pair)obj;
		if((a==cur.a && b==cur.b) || (a==cur.b && b==cur.a))return true;
		return false;
	}
	 }
	   static class cell implements Comparable<cell>{
		   int a,b;
		   long dis;
		   public cell(int x,int y,long z) {a=x;b=y;dis=z;}
		   public int compareTo(cell c) {
			   return Long.compare(dis,c.dis);
		   }
	   }
	static class TrieNode{
		TrieNode left;
		TrieNode right;
		int op;
		int data;
		public TrieNode() {}
	}
	  public static int gcd(int a,int b)
	  {
	    if(a<b)
	
	      return gcd(b,a);
	    if(b==0)
	      return a;
	    return gcd(b,a%b);
	    
	  }
	  static long lcm(int a,int b) {
		  return  a*b / gcd(a,b);
	  }
	  //static long ans = 0;
	  static long mod = 998244353;//(long)(1e9+7);//
	   
	    public static void main(String[] args) throws Exception {
	       new Thread(null, null, "Anshum Gupta", 99999999) {
	            public void run() {
	                try {
	                    solve();
	                } catch(Exception e) {
	                    e.printStackTrace();
	                    System.exit(1);
	                }
	            }
	        }.start();
	    }
	
	static long pow(long x,long y){
	    if(y == 0)return 1;
	    if(y==1)return x;
	    long a = pow(x,y/2);
	    a = (a*a)%mod;
	    if(y%2==0){
	        return a;
	    }
	    return (a*x)%mod;
	}
	
	static long mxx;
	static int mxN = (int)(1e7);
	static long[]fact,inv_fact;
	static long my_inv(long a) {
		return pow(a,mod-2);
	}
	static long bin(int a,int b) {
		if(a < b || a<0 || b<0)return 0;
	    return ((fact[a]*inv_fact[a-b])%mod * inv_fact[b])%mod;
	}
	//static ArrayList<ArrayList<Integer>>adj;
	//static boolean[]vis;
	static void make_facts() {
	  fact=new long[mxN];
	  inv_fact = new long[mxN];
	  fact[0]=inv_fact[0]=1L;
	  for(int i=1;i<mxN;i++) {
		   fact[i] = (i*fact[i-1])%mod;
		   inv_fact[i] = my_inv(fact[i]);
	  }
	}
	//static int[]bfs(int a){
	//	Queue<Integer> q = new  LinkedList<Integer>();
	//	
	//	vis = new boolean[n+1];
	//	int[]dis = new int[n+1];
	//	q.add(a);
	//	dis[a] = 0;
	//	vis[a] = true;
	//	while(!q.isEmpty()) {
	//		int cur = q.poll();
	//	//	vis[cur] = true;
	//	//	if(cur == b)break;
	//		for(int x : adj.get(cur)) {
	//			if(vis[x])continue;
	//			q.add(x);
	//			dis[x] = dis[cur]+1;
	//			vis[x] = true;
	//		}
	//	}
	//	return dis;
	//}
	
	 public static void solve() throws Exception {
	   // solve the problem here
	   MyScanner s = new MyScanner();
	        out = new PrintWriter(new BufferedOutputStream(System.out), true);
	        int tc = 1;//s.nextInt();
	        mxx = (long)(1e18+5);
	//        make_facts();  
	       
	        while(tc-->0){
	        	int n = s.nextInt();
	        	int[]a = new int[n];
	        	int[]b = new int[n];
	          		HashMap<Integer,Integer> freq = new HashMap<Integer, Integer>();
	        	for(int i=0;i<n;++i) {
	        		a[i] = s.nextInt();
	                if(freq.containsKey(a[i]))
	                	freq.put(a[i], freq.get(a[i])+1);
	                else freq.put(a[i],1);
	        	}
	        	Arrays.fill(b, -1);
	        	
	        	int[]ex = new int[n+1000];
	        	for(int i=1;i<n;i++) {
	        		if(a[i]!=a[i-1]) {
	        			b[i] = a[i-1];
	        			ex[b[i]]=1;
	        		}
	        	}
	        	int st = 0;
	        	ex[a[n-1]]=1;
	        	for(int i=0;i<n;i++)
	        	{
	        		while(ex[st] > 0) {
	        			st++;
	        		}
	        		if(b[i] == -1) {
	        			b[i] = st;
	        			ex[st] = 1;
	        		}
	        		out.print(b[i]+" ");
	        	}
	        	out.println();
	      
	        }
	        	
	           
	        out.flush();
	}
	 
	     
	 
	 
	 
	    //-----------PrintWriter for faster output---------------------------------
	    public static PrintWriter out;
	 
	    //-----------MyScanner class for faster input----------
	    public static class MyScanner {
	        BufferedReader br;
	        StringTokenizer st;
	 
	        public MyScanner() {
	            br = new BufferedReader(new InputStreamReader(System.in));
	        }
	 
	        String next() {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                } catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	        long nextLong() { return Long.parseLong(next()); }
	        double nextDouble() { return Double.parseDouble(next()); }
	         
	        String nextLine(){
	            String str = "";
	            try {
	                str = br.readLine();
	            } catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
	    }
	    //--------------------------------------------------------
	}
