You're given an array a of length 2n. Is it possible to reorder it in such way so that the sum of the first n elements isn't equal to the sum of the last n elements?

Input

The first line contains an integer n (1 ≤ n ≤ 1000), where 2n is the number of elements in the array a.

The second line contains 2n space-separated integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^6) — the elements of the array a.

Output

If there's no solution, print "-1" (without quotes). Otherwise, print a single line containing 2n space-separated integers. They must form a reordering of a. You are allowed to not change the order.

Examples

Input


3
1 2 2 1 3 1


Output


2 1 3 1 1 2

Input


1
1 1


Output


-1

Note

In the first example, the first n elements have sum 2+1+3=6 while the last n elements have sum 1+1+2=4. The sums aren't equal.

In the second example, there's no solution.

import java.io.*;
import java.math.*;
import java.util.*;

public class Level   {
    public static DS.Scanner in =new DS.Scanner();
    public static void main(String[] args) {
           int n=in.nextInt();
     int[]ar=new int[n*2];
     for(int i=0;i<n*2;i++)
         ar[i]=in.nextInt();
     
     Arrays.sort(ar);
     long x1=0;
     long y1=0;
     for(int i=0;i<n;i++)
         x1+=ar[i];
     for(int i=n;i<2*n;i++)
         y1+=ar[i];
     if(x1==y1)
         System.out.println(-1);
     else{
         for(int i=0;i<(2*n)-1;i++)
             System.out.print(ar[i]+" ");
     System.out.println(ar[ar.length-1]);}
    }
     public static class Algo{
    public static void merge(int arr[], int l, int m, int r){ 
        int n1 = m - l + 1; 
        int n2 = r - m; 
  
        int L[] = new int [n1]; 
        int R[] = new int [n2]; 
  
        for (int i=0; i<n1; ++i) 
            L[i] = arr[l + i]; 
        for (int j=0; j<n2; ++j) 
            R[j] = arr[m + 1+ j]; 
  
  
        int i = 0, j = 0; 
  
        int k = l; 
        while (i < n1 && j < n2) 
        { 
            if (L[i] <= R[j]) 
            { 
                arr[k] = L[i]; 
                i++; 
            } 
            else
            { 
                arr[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
  
        while (i < n1) 
        { 
            arr[k] = L[i]; 
            i++; 
            k++; 
        } 
  
        while (j < n2) 
        { 
            arr[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
    public static void sort(int arr[], int l, int r){ 
        if (l < r) 
        { 
            int m = (l+r)/2; 
  
            sort(arr, l, m); 
            sort(arr , m+1, r); 
  
            merge(arr, l, m, r); 
        } 
    } 
    public static ArrayList<Integer> sieve(int n){
        long sqr=(long) Math.sqrt(n);
        boolean[] isPrime=new boolean[n+1];
        for(int i=0;i<=n;i++)
            isPrime[i]=true;
        for(int i=2;i<=sqr;i++){
            if(isPrime[i]){
                for(int p=i*i;p<=n;p+=i)
                    isPrime[p]=false;
            }
        }
        ArrayList<Integer> list=new ArrayList<Integer>();
        for(int i=0;i<=n;i++)
            if(isPrime[i])
                list.add(i);
        list.remove(0);
        list.remove(0);
        return list;
    }
    public static boolean isPrime(long n){
        boolean res=true;
        List l =sieve((int) Math.sqrt(n));
        for(int i=0;i<l.size();i++){
            int curPrime=(int) l.get(i);
            if(n%curPrime==0){
            res=false;
            break;
            }
        }
        return res;
    }
    public static ArrayList factorizatin(int n){
        if(isPrime(n)){
            System.out.println(-1);
            return null;
        }else{
        Iterator ptr =sieve((int) Math.sqrt(n)).iterator();
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(ptr.hasNext()){
        int cur=(int) ptr.next();
           // System.out.println(cur);
         while(n!=1){
            while(n%cur==0){
                list.add(cur);
                n/=cur;
            }
            if(ptr.hasNext())
            cur=(int) ptr.next();
             //System.out.println(cur);
        }
        }
        if(n>2)
            list.add(n);
        return list;
        }
    }
    public static long gcd(long a,long b){
        if(b==0)
            return a;
        else
            return gcd(b,a%b);
    }
    public static long lcm(long a,long b){
        long ab=a*b;
        long gcd=gcd(a,b);
        return ab/gcd;
    }
    public static int bs(int[]z,int k){
             int res=0;
             int l=0;
             int r=z.length-1;
             int mid=(l+r)/2;
             while(l<=r){
                 
                 if(z[mid]==k){
                     res=1;
                     break;
                 }
                 if(z[mid]>k)
                     r=mid-1;
                 else
                     l=mid+1;
                 mid=(l+r)/2;
             }
             return res;
         }
     public static void solve(){
        int n=Integer.parseInt(in.next());
        int target=Integer.parseInt(in.next());
        int[]z=new int[n];
        for(int i=0;i<n;i++)
            z[i]=Integer.parseInt(in.next());
        Arrays.sort(z);
        int ptr1=0;
        int ptr2=n-1;
        int wind=z[ptr1]+z[ptr2];
        if(wind==target)
            System.out.println(ptr1+"-"+ptr2);
        else{
            while(ptr1<ptr2 && wind!=target){
                if(wind>target){
                    wind-=z[ptr2--];
                    wind+=z[ptr2];
                }
                else{
                    wind-=z[ptr1++];
                    wind+=z[ptr1];
                }
            }
            if((ptr1!=0||ptr2!=n-1)&&ptr2!=ptr1)
                System.out.println(ptr1+"-"+ptr2);
            else
                System.out.println(-1);
        }
    }
     public static void sliding(){
        int n=Integer.parseInt(in.next());
        int k=Integer.parseInt(in.next());
        int[]z=new int[n];
        for(int i=0;i<n;i++)
            z[i]=Integer.parseInt(in.next());
        int wind=0;
        for(int i=0;i<k;i++)
            wind+=z[i];
        int max=wind;
        for(int i=k;i<n;i++){
            wind+=z[i];
            wind-=z[i-k];
            max=Math.max(max,wind);
        }
        System.out.println(max);
    }
     }
    private static class DS{
    private static class Stack 
    {
    private int Size;
    Node top;
    Stack(){
    
    Size=0;
    top=null;
    }
    public int size(){
    return this.Size;
    }
    public void push(Object item){
    Node node=new Node();
    node.data=item;
    node.next=top;
    top=node;
    Size++;
    }
    public void pop(){
    if(top!=null)
        top=top.next;
    Size--;
    }
    public boolean isEmpty(){
    return top==null;
    }
    public Object getTop(){
    if(top!=null)
        return top.data;
    else
        return null;
    }
    public void display(){
    if(top!=null){
        Node temp=top;
    while(temp!=null){
        System.out.print(temp.data+" ");
        temp=temp.next;
    }
        System.out.println();
    }
    }
  private class Node {
  Object data;
  Node next;
  }  
}
    private static class Scanner
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public Scanner()
        { 
            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; 
        }
        
        BigInteger nextBigInteger()
        {
            return new BigInteger(next());
        }
       
    } 
     }
}