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.
                ////////////////////////////////////////////////////
                //                                                //
                //  For her who keeps the fire kindling in me...  //
                //                                                //
                ////////////////////////////////////////////////////


    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileOutputStream;
    import java.io.IOException; 
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.util.Scanner;
    import java.util.ArrayList;
    import java.util.Collections; 
    import java.util.StringTokenizer;
    import java.lang.Math;
    import java.awt.Point;
    import java.awt.geom.*;
    
    public class Main{
    
        /*static Integer angleWithSlopeOne(Point2D fpt, Point2D spt){
            final Integer epsi = .000001;
            if(Math.abs(fpt.getX() - spt.getX())<=epsi)
                return (Math.PI/4);
            Integer m = (spt.getY()-fpt.getY())/(spt.getX()-fpt.getX());
            return Math.abs((Math.PI/2)-(Math.atan(Math.abs(m))));
        }*/
    
        /*static Integer disFromSlopeOne(Point2D fpt, Point2D spt){
            //Integer angl = angleWithSlopeOne(fpt, spt);
            Integer a, b, r, c1, c2;
            Point2D midpt = new Point2D.Integer((fpt.getX()+spt.getX())/2, (fpt.getY()+spt.getY())/2);
            //r = midpt.distance(spt);
            c1 = midpt.getY() - midpt.getX();
            c2 = midpt.getY() + midpt.getX();
            a = Math.abs(spt.getY() - spt.getX() - c1);
            b = Math.abs(spt.getY() + spt.getX() - c2);
            return Math.min(a, b);
        }*/
    
        public static void main(String args[]){
            try{
                FastReader s = new FastReader();
                BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
                //final Integer epsi = .000001;
                int n, i, j, k, t;
                long sum1, sum2;
                n = s.nextInt();
                ArrayList<Integer> arr = new ArrayList<Integer>(2*n);
                for(i=0; i<2*n; i++)
                    arr.add(s.nextInt());
                Collections.sort(arr);
                sum1=0l;
                sum2=0l;
                for(i=0; i<n; i++)
                    sum1+=arr.get(i);
                for(i=n; i<2*n; i++)
                    sum2+=arr.get(i);
                if(sum1!=sum2){
                    for(i=0; i<2*n; i++)
                    w.write(arr.get(i)+" ");
                    w.write("\n");
                }else
                w.write("-1\n");


                w.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    
    
    //========================================### FAST IO ###=========================================//
    class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
    
        public FastReader() 
        { 
            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; 
        } 
    }
        //====================================================================================================//