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.
#include <bits/stdc++.h>
using namespace std;
namespace BAsis {
inline int Read() {
  char Ch = getchar();
  while (Ch < 48 || Ch > 57) Ch = getchar();
  int x = Ch - 48;
  Ch = getchar();
  while (Ch >= 48 && Ch <= 57) x = (x * 10) + (Ch - 48), Ch = getchar();
  return x;
}
inline long long LRead() {
  char Ch = getchar();
  while (Ch < 48 || Ch > 57) Ch = getchar();
  long long x = Ch - 48;
  Ch = getchar();
  while (Ch >= 48 && Ch <= 57) x = (x * 10) + (Ch - 48), Ch = getchar();
  return x;
}
inline int Min(const int &x, const int &y) { return x < y ? x : y; }
inline int Max(const int &x, const int &y) { return x > y ? x : y; }
inline void Swap(int &x, int &y) {
  register int p = x;
  x = y;
  y = p;
}
}  // namespace BAsis
using namespace BAsis;
int a[2005], n;
void Work() {
  sort(a + 1, a + 2 * n + 1);
  for (int i = (1), iLimit = (2 * n); i <= iLimit; ++i) printf("%d ", a[i]);
  puts("");
}
signed main() {
  n = Read();
  for (int i = (1), iLimit = (2 * n); i <= iLimit; ++i) a[i] = Read();
  for (int i = (2), iLimit = (2 * n); i <= iLimit; ++i)
    if (a[i] != a[i - 1]) return Work(), 0;
  puts("-1");
  return 0;
}
