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.util.*;
import java.lang.*;
public class CodeForce {
    
    
        public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            int[]a=new int[2*n];
            
            for(int i=0;i<2*n;i++){
                a[i]=sc.nextInt();
                
            }
            Arrays.sort(a);
            if(a[0]==a[2*n-1]){
                System.out.println("-1");
            }
            else {
                for(int i=0;i<2*n;i++)System.out.print(a[i]+" ");
            }
           
            //CodeForce.su(a,n);
            //
        
        
//        int count=0;
//        static void su(int[] a,int n){
//            
//            int smi=0,sml=0;
//            for(int i=0;i<n;i++){
//                smi+=a[i];
//                sml+=a[n+i];
//            }
//            CodeForce ce=new CodeForce();
//            if(smi!=sml)
//                for(int j=0;j<2*n;j++)System.out.print(a[j]+" ");
//            else{
//                ce.count++;
//                if(2*n>=ce.count){
//                
//                int temp=a[2*n-1];
//                for(int i=0;i<2*n-1;i++){
//                    a[2*n-1-i]=a[2*n-2-i];
//                }
//                a[0]=temp;
//                CodeForce.su(a,n);
//                }
//                else System.out.println("-1");
//                
//            }
//            
            
        }
}
    




            //sorting decreasing integer
//            for(int i=0;i<n;i++){
//                for(int j=i+1;j<n;j++){
//                    if(b[i]<b[j]){
//                        int temp=b[j];
//                        b[j]=b[i];
//                        b[i]=temp;
//                }
//            }
//            }
    