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.
//package com.karancp;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.InputStream;


 public class karan {
    public static void main(String args[])
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader z = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        task solver =new task();
        solver.solve(z,out);
        out.close();
    }

    static class task {

        static long gcd(long a, long b) {
            if (b == 0) return a;
            else return gcd(b, a % b);
        }

        static long lcm(long a, long b) {
            long pp = a * b;
            long bb = gcd(a, b);
            long res = pp / bb;
            return res;
        }

        static int max(int a, int b) {
            return Math.max(a, b);
        }

        static int min(int a, int b) {
            return Math.min(a, b);
        }




        public static void solve(InputReader z, PrintWriter out) {

           int n=z.nextInt();
           int ar[]=new int[2*n];
           int i;
           long sum=0;
           for(i=0;i<2*n;i++)
           {
               ar[i]=z.nextInt();
               sum+=ar[i];
           }
           Arrays.sort(ar);
           long s2=0;
           for(i=0;i<n;i++)
           {
               s2+=ar[i];
           }
           sum=sum-s2;
           if(s2==sum)out.println("-1");
           else
           {
               for(i=0;i<2*n;i++)
               {
                   out.print(ar[i]+" ");
               }
           }
        }
    }
        static class InputReader {
            public BufferedReader reader;
            public StringTokenizer tokenizer;

            public InputReader(InputStream stream) {
                reader = new BufferedReader(new InputStreamReader(stream), 32768);
                tokenizer = null;
            }

            public String next() {
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    try {
                        tokenizer = new StringTokenizer(reader.readLine());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                return tokenizer.nextToken();
            }

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

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

        }


    }
