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.io.*;

public class EhabThanos
{
    public static void main(String... args)
    {
        int n = getInt();
        int[] arr = new int[2 * n];
        for (int i = 0; i < 2 * n; ++i) {
            arr[i] = getInt();
        }
//        long suml = 0;
//        long sumr = 0;
//        for (int i = 0; i < n; ++i) {
//            suml = suml + arr[i];
//        }
//        for (int i = n; i < 2 * n; ++i) {
//            sumr = sumr + arr[i];
//        }
//        boolean ans = suml != sumr;
//        int ansi = 0;
//        if (!ans) {
//            for (int i = 0; i < n; ++i) {
//                suml -= arr[i];
//                sumr += arr[i];
//                suml += arr[i + n];
//                sumr -= arr[i + n];
//                if (suml != sumr) {
//                    ans = true;
//                    ansi = i + 1;
//                    break;
//                }
//            }
//        }
//        if (ans) {
//            for (int i = 0; i < 2*n; ++i) {
//                int ind = (i + ansi) % (2 * n);
//                print(arr[ind] + " ");
//            }
//        }
//        else {
//            print("-1");
//        }
//        flush();
        Arrays.sort(arr);
        long suml = 0;
        long sumr = 0;
        for (int i = 0 ; i < n ; ++i) suml += arr[i];
        for (int i = n ; i < 2*n; ++i) sumr += arr[i];
        if (suml == sumr) print("-1");
        else for (int i = 0 ; i < 2*n; ++i) print(arr[i] + " ");
        flush();
    }

    // ===== Printing code ===== 
    static StringBuilder buf = new StringBuilder();
    static int bufSize = 5000;

    static void print(String s)
    {
        print(s, false);
    }

    static void print(String s, boolean newLine)
    {
        buf.append(s);
        if (newLine) {
            buf.append("\n");
        }
        if (buf.length() >= bufSize) {
            System.out.print(buf);
            buf.delete(0, buf.length());
        }
    }

    static void flush()
    {
        System.out.print(buf);
        buf.delete(0, buf.length());
    }

    // ===== INPUT TAKING CODE ==== 
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;

    static void checkSt()
    {
        if (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                System.out.println("Error parsing input");
            }
        }
    }

    static int getInt()
    {
        checkSt();
        return Integer.valueOf(st.nextToken());
    }

    static int getLong()
    {
        checkSt();
        return Integer.valueOf(st.nextToken());
    }

    static long getNewLineLong()
    {
        try {
            return Long.valueOf(br.readLine());
        } catch (IOException e) {
            System.out.println("Error parsing input");
            return 0;
        }
    }

    static int getNewLineInt()
    {
        try {
            return Integer.valueOf(br.readLine());
        } catch (IOException e) {
            System.out.println("Error parsing input");
            return 0;
        }
    }

    static char getChar()
    {
        checkSt();
        return st.nextToken().charAt(0);
    }

    static String getStr()
    {
        checkSt();
        return st.nextToken();
    }

}
