You are given an array a with n distinct integers. Construct an array b by permuting a such that for every non-empty subset of indices S = {x_1, x_2, ..., x_{k}} (1 ≤ x_{i} ≤ n, 0 < k < n) the sums of elements on that positions in a and b are different, i. e. $\sum_{i = 1}^{k} a_{x_{i}} \neq \sum_{i = 1}^{k} b_{x_{i}}$


-----Input-----

The first line contains one integer n (1 ≤ n ≤ 22) — the size of the array.

The second line contains n space-separated distinct integers a_1, a_2, ..., a_{n} (0 ≤ a_{i} ≤ 10^9) — the elements of the array.


-----Output-----

If there is no such array b, print -1.

Otherwise in the only line print n space-separated integers b_1, b_2, ..., b_{n}. Note that b must be a permutation of a.

If there are multiple answers, print any of them.


-----Examples-----
Input
2
1 2

Output
2 1 

Input
4
1000 100 10 1

Output
100 1 1000 10



-----Note-----

An array x is a permutation of y, if we can shuffle elements of y such that it will coincide with x.

Note that the empty subset and the subset containing all indices are not counted.

Source: codeforces | Difficulty: HARD
Tags: Greedy algorithms

Constructive algorithms


Solutions:
n = int(input())
j = [int(x) for x in input().split(' ')]
if n == 1:
	print(j[0])
else:
	k = [[j[i], i] for i in range(n)]
	k.sort()
	o = [0 for i in range(len(k))]
	for i in range(len(k)):
		o[k[i][1]] = str(k[(i + 1) % n][0])
	print(' '.join(o))


import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10 ** 8)
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class TreeNode:

	def __init__(self, k, v):
		self.key = k
		self.value = v
		self.left = None
		self.right = None
		self.parent = None
		self.height = 1
		self.num_left = 1
		self.num_total = 1

class AvlTree:

	def __init__(self):
		self._tree = None

	def add(self, k, v):
		if not self._tree:
			self._tree = TreeNode(k, v)
			return
		node = self._add(k, v)
		if node:
			self._rebalance(node)

	def _add(self, k, v):
		node = self._tree
		while node:
			if k < node.key:
				if node.left:
					node = node.left
				else:
					node.left = TreeNode(k, v)
					node.left.parent = node
					return node.left
			elif node.key < k:
				if node.right:
					node = node.right
				else:
					node.right = TreeNode(k, v)
					node.right.parent = node
					return node.right
			else:
				node.value = v
				return

	@staticmethod
	def get_height(x):
		return x.height if x else 0

	@staticmethod
	def get_num_total(x):
		return x.num_total if x else 0

	def _rebalance(self, node):
		n = node
		while n:
			lh = self.get_height(n.left)
			rh = self.get_height(n.right)
			n.height = max(lh, rh) + 1
			balance_factor = lh - rh
			n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
			n.num_left = 1 + self.get_num_total(n.left)
			if balance_factor > 1:
				if self.get_height(n.left.left) < self.get_height(n.left.right):
					self._rotate_left(n.left)
				self._rotate_right(n)
			elif balance_factor < -1:
				if self.get_height(n.right.right) < self.get_height(n.right.left):
					self._rotate_right(n.right)
				self._rotate_left(n)
			else:
				n = n.parent

	def _remove_one(self, node):
		replacement = node.left or node.right
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = replacement
			else:
				node.parent.right = replacement
			replacement.parent = node.parent
			node.parent = None
		else:
			self._tree = replacement
			replacement.parent = None
		node.left = None
		node.right = None
		node.parent = None
		self._rebalance(replacement)

	def _remove_leaf(self, node):
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = None
			else:
				node.parent.right = None
			self._rebalance(node.parent)
		else:
			self._tree = None
		node.parent = None
		node.left = None
		node.right = None

	def remove(self, k):
		node = self._get_node(k)
		if not node:
			return
		if AvlTree._is_leaf(node):
			self._remove_leaf(node)
			return
		if node.left and node.right:
			nxt = AvlTree._get_next(node)
			node.key = nxt.key
			node.value = nxt.value
			if self._is_leaf(nxt):
				self._remove_leaf(nxt)
			else:
				self._remove_one(nxt)
			self._rebalance(node)
		else:
			self._remove_one(node)

	def get(self, k):
		node = self._get_node(k)
		return node.value if node else -1

	def _get_node(self, k):
		if not self._tree:
			return None
		node = self._tree
		while node:
			if k < node.key:
				node = node.left
			elif node.key < k:
				node = node.right
			else:
				return node
		return None

	def get_at(self, pos):
		x = pos + 1
		node = self._tree
		while node:
			if x < node.num_left:
				node = node.left
			elif node.num_left < x:
				x -= node.num_left
				node = node.right
			else:
				return (node.key, node.value)
		raise IndexError('Out of ranges')

	@staticmethod
	def _is_left(node):
		return node.parent.left and node.parent.left == node

	@staticmethod
	def _is_leaf(node):
		return node.left is None and node.right is None

	def _rotate_right(self, node):
		if not node.parent:
			self._tree = node.left
			node.left.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.left
			node.left.parent = node.parent
		else:
			node.parent.right = node.left
			node.left.parent = node.parent
		bk = node.left.right
		node.left.right = node
		node.parent = node.left
		node.left = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	def _rotate_left(self, node):
		if not node.parent:
			self._tree = node.right
			node.right.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.right
			node.right.parent = node.parent
		else:
			node.parent.right = node.right
			node.right.parent = node.parent
		bk = node.right.left
		node.right.left = node
		node.parent = node.right
		node.right = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	@staticmethod
	def _get_next(node):
		if not node.right:
			return node.parent
		n = node.right
		while n.left:
			n = n.left
		return n

class SegmentTree1:

	def __init__(self, data, default=2 ** 51, func=lambda a, b: a & b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] < key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] >= k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater
n = int(input())
l = list(map(int, input().split()))
e = l + []
e.sort()
d = defaultdict(int)
for i in range(1, n):
	d[e[i - 1]] = e[i]
d[e[-1]] = e[0]
for i in range(n):
	print(d[l[i]], end=' ')


inf = lambda : map(int, input().split())
(n,) = inf()
a = list(inf())
p = sorted([i for i in range(n)], key=lambda x: a[x])
b = [0] * n
for i in range(n):
	b[p[i]] = a[p[(i + 1) % n]]
for i in range(n):
	print(b[i], end=' ')
print()


n = int(input())
lst = [int(i) for i in input().split()]
for elem in lst:
	print(sorted(lst)[sorted(lst).index(elem) - 1])


n = int(input())
a = list(map(int, input().split()))
b = a.copy()
a.sort()
c = []
for i in range(n):
	c.append(a[(a.index(b[i]) + 1) % n])
print(*c)


n = int(input())
a = list(map(int, input().split()))
sorted_a = sorted(a)
shifted_sorted_a = [sorted_a[-1]] + sorted_a[:-1]
for i in range(len(a)):
	pos_in_sorted = sorted_a.index(a[i])
	print(shifted_sorted_a[pos_in_sorted], end=' ')


n = int(input())
data = list(map(int, input().split()))
sorted_data = sorted(data)
ans = {}
for i in range(0, n):
	ans[sorted_data[i]] = sorted_data[(i + 1) % n]
for v in data:
	print(ans[v], end=' ')


n = int(input())
l = [int(i) for i in input().split(' ')]
nums = sorted(l)
for i in l:
	print(nums[(nums.index(i) + 1) % n], end=' ')


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
ans = []
for x in a:
	ans.append(b[b.index(x) - 1])
print(*ans)


n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
for i in range(n):
	print(b[(b.index(a[i]) + 1) % n], end=' ')


n = int(input())
A = input().split()
A = [int(i) for i in A]
if n != len(set(A)):
	print(-1)
else:
	B = A[:]
	B.sort()
	C = [n + 100] * n
	for i in range(0, n):
		C[i] = A.index(B[i])
	D = [n + 100] * n
	for i in range(0, n):
		D[C[i]] = A[C[(i + 1) % n]]
	for x in D:
		print(x, end=' ')
	print()


from collections import defaultdict, deque
import sys
import bisect
input = sys.stdin.readline
n = int(input())
a = [int(i) for i in input().split() if i != '\n']
ind = defaultdict(int)
for i in range(n):
	ind[a[i]] = i
a.sort()
ans = [0] * n
for i in range(n):
	index = ind[a[(i + 1) % n]]
	ans[index] = a[i]
print(*ans)


input()
(t, s) = zip(*sorted(((int(q), i) for (i, q) in enumerate(input().split()))))
for (i, q) in sorted(((i, q) for (q, i) in zip(t[1:] + t[:1], s))):
	print(q)


def solve():
	n = int(input())
	a = list(map(int, input().split()))
	b = sorted(a) + [min(a)]
	for i in range(n):
		a[i] = str(b[b.index(a[i]) + 1])
	print(' '.join(a))
	return
solve()


n = int(input())
A = [int(a) for a in input().split(' ')]
R = sorted(A)
for i in range(n):
	if A[i] == R[-1]:
		A[i] = R[0]
	else:
		A[i] = R[R.index(A[i]) + 1]
print(' '.join([str(a) for a in A]))


(n, a) = (int(input()), [int(i) for i in input().split()])
(b, m) = (a[:], dict())
b.sort()
for i in range(len(b) - 1):
	m[b[i]] = b[i + 1]
m[b[-1]] = b[0]
for i in range(len(a)):
	a[i] = m[a[i]]
if len(set(b)) == n:
	print(*a)
else:
	print(-1)


import sys

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def N():
	return int(inp())

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def take():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def testcase(t):
	for p in range(t):
		solve()

def solve():
	n = N()
	ar = lis()
	t = sorted(ar)
	ans = []
	for i in ar:
		ind = t.index(i)
		ind = (ind + 1) % n
		ans.append(t[ind])
	print(*ans)
solve()


n = int(input())
a = [int(i) for i in input().split()]
b = sorted(a)
s = {}
for i in range(-1, n - 1):
	s[b[i + 1]] = b[i]
print(' '.join([str(s[i]) for i in a]))


import sys
input()
a = list(map(int, input().split()))
b = sorted(a)
for i in a:
	sys.stdout.write(str(b[b.index(i) - 1]))
	sys.stdout.write(' ')
sys.stdout.write('\n')


n = int(input())
a = list(map(int, input().split()))
arr = sorted(a, reverse=True)
ans = [None for x in range(n)]
for i in range(n - 1):
	pos = a.index(arr[i])
	ans[pos] = arr[i + 1]
for i in range(n):
	if ans[i] == None:
		ans[i] = arr[0]
print(*ans)


import os, sys
from io import BytesIO, IOBase

def main():
	n = int(input())
	a = list(map(int, input().split()))
	x = sorted(a, reverse=1)
	ans = [0] * n
	for i in range(n):
		b = a.index(x[i])
		ans[b] = x[(i + 1) % n]
	print(*ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
a = list(map(int, input().split()))
ans = list()
for i in range(n):
	ans.append(0)
position = dict()
for i in range(n):
	position[a[i]] = i
a = sorted(a)
ans[position[a[n - 1]]] = a[0]
for i in range(n - 1):
	ans[position[a[i]]] = a[i + 1]
for i in range(n):
	print(ans[i], end=' ')


n = int(input())
A = list(map(int, input().split()))
C = []
for (i, a) in enumerate(A):
	C.append((a, i))
C.sort()
B = [-1] * n
for i in range(n - 1):
	B[C[i + 1][1]] = C[i][0]
B[C[0][1]] = C[-1][0]
print(*B)


n = int(input())
A = list(map(int, input().split()))
B = sorted(A)
for i in A:
	print(B[B.index(i) - 1], end=' ')


input()
t = list(map(int, input().split()))
s = sorted(t)
for q in t:
	print(s[s.index(q) - 1])


import sys, math
readline = sys.stdin.readline
n = int(readline())
inf = pow(10, 10)
tmp = list(map(int, readline().split()))
tmp2 = [inf] * n
mai = 0
for i in range(n):
	for j in range(n):
		if tmp[i] < tmp[j]:
			tmp2[i] = min(tmp2[i], tmp[j])
for i in range(n):
	if tmp[i] == max(tmp):
		mai = i
		break
tmp2[mai] = min(tmp)
for x in tmp2:
	print(x, end=' ')


input()
a = list(map(int, input().split()))
for i in a:
	print(sorted(a)[sorted(a).index(i) - 1])


n = int(input())
a = list(map(int, input().split()))

def solve(n, a):
	if n == 1:
		return [str(a[0])]
	arr = [[x, i] for (i, x) in enumerate(a)]
	arr = sorted(arr, key=lambda x: x[0])
	ans = [-1] * n
	for ([x, i], [y, j]) in zip(arr[1:], arr[:-1]):
		ans[j] = str(x)
	ans[arr[-1][1]] = str(arr[0][0])
	return ans
ans = solve(n, a)
print(' '.join(ans))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
A = [int(x) for x in input().split()]
wc = collections.Counter(A)
if any((v > 1 for v in wc.values())):
	print(-1)
	exit(0)
C = list(sorted(A))
NC = {C[i]: C[i + 1] for i in range(N - 1)}
NC[C[-1]] = C[0]
ans = []
for v in A:
	ans.append(NC[v])
print(' '.join(map(str, ans)))


n = int(input())
l = [int(i) for i in input().split(' ')]
index = []
nums = sorted(l)
for i in l:
	index.append(nums.index(i))
indexbis = [int(i - 1) for i in index]
for i in range(n):
	if indexbis[i] == min(indexbis):
		indexbis[i] = n - 1
		break
for i in indexbis:
	print(l[index.index(i)], end=' ')


import math
n = int(input())
a = list(map(int, input().split()))
pos = {}
ans = []
for i in range(n):
	pos[a[i]] = i
	ans.append(0)
a.sort()
ans[pos[a[n - 1]]] = a[0]
for i in range(n - 1):
	ans[pos[a[i]]] = a[i + 1]
for i in ans:
	print(i, end=' ')


n = int(input())
a = list(map(int, input().split()))
ans = sorted(a) + [min(a)]
print(' '.join([str(ans[ans.index(a[i]) + 1]) for i in range(n)]))


n = int(input())
A = list(map(int, input().split()))
S = sorted(A)
P = {S[i]: S[(i + 1) % n] for i in range(n)}
B = [P[a] for a in A]
print(' '.join(map(str, B)))


n = int(input())
a = [int(i) for i in input().split()]
if n == 1:
	print(a[0])
else:
	a_with_index = [[a[i], i] for i in range(n)]
	a_with_index.sort()
	ans = [0 for i in range(n)]
	for i in range(n):
		ans[a_with_index[i][1]] = str(a_with_index[(i + 1) % n][0])
	print(' '.join(ans))


n = int(input())
L = list(map(int, input().split()))
S = sorted(L)
for i in L:
	print(S[(S.index(i) + 1) % n], end=' ')