Recently personal training sessions have finished in the Berland State University Olympiad Programmer Training Centre. By the results of these training sessions teams are composed for the oncoming team contest season. Each team consists of three people. All the students of the Centre possess numbers from 1 to 3n, and all the teams possess numbers from 1 to n. The splitting of students into teams is performed in the following manner: while there are people who are not part of a team, a person with the best total score is chosen among them (the captain of a new team), this person chooses for himself two teammates from those who is left according to his list of priorities. The list of every person's priorities is represented as a permutation from the rest of 3n - 1 students who attend the centre, besides himself.

You are given the results of personal training sessions which are a permutation of numbers from 1 to 3n, where the i-th number is the number of student who has won the i-th place. No two students share a place. You are also given the arrangement of the already formed teams in the order in which they has been created. Your task is to determine the list of priorities for the student number k. If there are several priority lists, choose the lexicographically minimal one.

Input

The first line contains an integer n (1 ≤ n ≤ 105) which is the number of resulting teams. The second line contains 3n space-separated integers from 1 to 3n which are the results of personal training sessions. It is guaranteed that every student appears in the results exactly once.

Then follow n lines each containing three integers from 1 to 3n — each line describes the members of a given team. The members of one team can be listed in any order, but the teams themselves are listed in the order in which they were created. It is guaranteed that the arrangement is correct, that is that every student is a member of exactly one team and those teams could really be created from the given results using the method described above.

The last line contains number k (1 ≤ k ≤ 3n) which is the number of a student for who the list of priorities should be found.

Output

Print 3n - 1 numbers — the lexicographically smallest list of priorities for the student number k. 

The lexicographical comparison is performed by the standard < operator in modern programming languages. The list a is lexicographically less that the list b if exists such an i (1 ≤ i ≤ 3n), that ai < bi, and for any j (1 ≤ j < i) aj = bj. Note, that the list 1 9 10 is lexicographically less than the list 1 10 9. That is, the comparison of lists is different from the comparison of lines.

Examples

Input

3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
4


Output

2 3 5 6 9 1 7 8 

Input

3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
8


Output

1 2 3 4 5 6 7 9 

Input

2
4 1 3 2 5 6
4 6 5
1 2 3
4


Output

5 6 1 2 3

Source: codeforces | Difficulty: HARD
Tags: Greedy algorithms

Implementation

Constructive algorithms


Solutions:
import sys
I = lambda : int(input())
RL = readline = lambda : sys.stdin.readline().strip('\n')
RM = readmap = lambda x=int: map(x, readline().split(' '))

def f(l, x):
	if x == l[0]:
		return (l[1], l[2])
	if x == l[1]:
		return (l[0], l[2])
	if x == l[2]:
		return (l[0], l[1])
	return -1

def delrank(x):
	global pre, nxt
	(prex, nxtx) = (pre[x], nxt[x])
	nxt[prex] = nxtx
	pre[nxtx] = prex
n = I()
N = 3 * n
rank = [*RM()] + [N + 1]
tris = [tuple(RM()) for i in range(n)]
k = I()
(pre, nxt) = (list(range(N + 2)), list(range(N + 2)))
temp0 = 0
for i in range(N + 1):
	temp1 = rank[i]
	(pre[temp1], nxt[temp0]) = (temp0, temp1)
	temp0 = temp1
for (ind, tri) in enumerate(tris):
	leader = nxt[0]
	(x, y) = f(tri, leader)
	if k in tri:
		if leader != k:
			l = [i for i in range(1, N + 1) if i != k]
		else:
			l1 = [i for tri in tris[:ind] for i in tri]
			l2 = [x, y]
			l3 = [i for tri in tris[ind + 1:] for i in tri]
			l0 = sorted(l1 + l2)
			ind = l0.index(max(x, y))
			l = l0[:ind + 1] + sorted(l0[ind + 1:] + l3)
		print(' '.join([str(i) for i in l]))
		sys.exit(0)
	for i in tri:
		delrank(i)
quit()

def rec(u, v):
	if v:
		rec(pre[u][v], u)
		print(v, end=' ')
from collections import deque
(n, m, k) = RM()
adj = [[] for i in range(n + 1)]
dist = [[int(1000000000.0)] * (n + 1) for i in range(n + 1)]
pre = [[0] * (n + 1) for i in range(n + 1)]
bad = set()
for _ in range(m):
	(x, y) = RM()
	adj[x].append(y)
	adj[y].append(x)
for _ in range(k):
	bad.add(tuple(RM()))
dist[0][1] = 0
q = deque([(0, 1)])
while q:
	(u, v) = q.popleft()
	d = dist[u][v] + 1
	for w in adj[v]:
		if d < dist[v][w] and (not (u, v, w) in bad):
			dist[v][w] = d
			pre[v][w] = u
			q.append((v, w))
			if w == n:
				print(d)
				rec(v, w)
				print()
				sys.exit(0)
print(-1)


from sys import stdin, stdout
n = int(stdin.readline())
points = list(map(int, stdin.readline().split()))
teams = []
chance = []
for i in range(n):
	teams.append(tuple(map(int, stdin.readline().split())))
k = int(stdin.readline())
for i in range(n):
	(f, s, t) = teams[i]
	if not k in teams[i]:
		chance += [f, s, t]
	else:
		(a, b) = [f, s, t][:[f, s, t].index(k)] + [f, s, t][[f, s, t].index(k) + 1:]
		if points.index(a) < points.index(k) or points.index(b) < points.index(k):
			chance = []
			for i in range(1, 3 * n + 1):
				if i != k:
					chance.append(i)
		else:
			chance += [a, b]
		break
chance.sort()
s = set(chance)
for i in range(1, 3 * n + 1):
	if not i in s and i != k:
		chance.append(i)
chance = chance[:chance.index(max(a, b)) + 1] + sorted(chance[chance.index(max(a, b)) + 1:])
stdout.write(' '.join(list(map(str, chance))))


n = int(input())
pos = list(map(int, input().split()))
gr = []
for _ in range(n):
	gr.append(list(map(int, input().split())))
k = int(input())
cidx = -1
for (idx, cg) in enumerate(gr):
	for elm in cg:
		if elm == k:
			cidx = idx
			break
per = [0] * len(pos)
for (idx, elm) in enumerate(pos):
	per[elm - 1] = idx
max_per = min([per[gr[cidx][i] - 1] for i in range(3)])
if max_per == per[k - 1]:
	fi = []
	for idx in range(cidx):
		for elm in gr[idx]:
			fi.append(elm)
	tm = []
	for elm in gr[cidx]:
		if elm != k:
			fi.append(elm)
			tm.append(elm)
	max_tm = max(tm)
	fi.sort()
	cut_point = fi.index(max_tm)
	se = fi[cut_point + 1:]
	fi = fi[:cut_point + 1]
	for idx in range(cidx + 1, n):
		for elm in gr[idx]:
			se.append(elm)
	se.sort()
	ans = fi + se
else:
	ans = []
	for elm in pos:
		if elm != k:
			ans.append(elm)
	ans.sort()
print(*ans)


import sys
from array import array

def input():
	return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
a = list(map(int, input().split()))
order = [0] * (3 * n + 1)
for (i, x) in enumerate(a):
	order[x] = i
used = [0] * (3 * n + 1)
items = [tuple(map(int, input().split())) for _ in range(n)]
k = int(input())

def end1(x, y, z):
	free = []
	(pre, suf) = ([], [])
	for i in range(1, 3 * n + 1):
		if i == k:
			continue
		if i == x or i == y or i == z:
			pre.append(i)
		elif not used[i]:
			suf.append(i)
		else:
			free.append(i)
	ans = []
	(fi, fn) = (0, len(free))
	for x in pre + suf:
		while fi < fn and free[fi] < x:
			ans.append(free[fi])
			fi += 1
		ans.append(x)
	ans += free[fi:]
	print(*ans)
	exit()

def end2():
	print(*list(range(1, k)) + list(range(k + 1, 3 * n + 1)))
	exit()
for (x, y, z) in items:
	used[x] = used[y] = used[z] = 1
	if k in (x, y, z):
		if order[k] == min(map(lambda x: order[x], (x, y, z))):
			end1(x, y, z)
		else:
			end2()