All techniques in the ninja world consist of hand seals. At the moment Naruto is learning a new technique, which consists of $n\cdot m$ different seals, denoted by distinct numbers. All of them were written in an $n\times m$ table.

The table is lost now. Naruto managed to remember elements of each row from left to right, and elements of each column from top to bottom, but he doesn't remember the order of rows and columns. Please restore the table consistent with this data so that Naruto will be able to learn the new technique.


-----Input-----

The first line of the input contains the only integer $t$ ($1\leq t\leq 100\,000$) denoting the number of test cases. Their descriptions follow.

The first line of each test case description consists of two space-separated integers $n$ and $m$ ($1 \leq n, m \leq 500$) standing for the number of rows and columns in the table, respectively. All hand seals are encoded by the positive integers from $1$ to $n\cdot m$.

The following $n$ lines contain $m$ space separated integers each, denoting elements of an arbitrary row in the table left to right.

The following $m$ lines contain $n$ space separated integers each, denoting elements of an arbitrary column in the table top to bottom.

Sum of $nm$ over all test cases does not exceed $250\,000$. It is guaranteed that each row occurs in the input exactly once, as well as each column. It is also guaranteed that each number from $1$ to $nm$ occurs exactly once in all rows, as well as in all columns. Finally, it is guaranteed that a table consistent with the input exists.


-----Output-----

For each test case, output $n$ lines with $m$ space-separated integers each, denoting the restored table. One can show that the answer is always unique.


-----Example-----
Input
2
2 3
6 5 4
1 2 3
1 6
2 5
3 4
3 1
2
3
1
3 1 2

Output
1 2 3 
6 5 4 
3 
1 
2 



-----Note-----

Consider the first test case. The matrix is $2 \times 3$. You are given the rows and columns in arbitrary order.

One of the rows is $[6, 5, 4]$. One of the rows is $[1, 2, 3]$.

One of the columns is $[1, 6]$. One of the columns is $[2, 5]$. One of the columns is $[3, 4]$.

You are to reconstruct the matrix. The answer is given in the output.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import math\nfrom collections import deque\nfrom sys import stdin, stdout, setrecursionlimit\nfrom string import ascii_letters\nletters = ascii_letters[:26]\nfrom collections import defaultdict\n#from functools import reduce\ninput = stdin.readline\n#print = stdout.write\n\nfor _ in range(int(input())):\n    n, m = list(map(int, input().split()))\n    horizontal = [list(map(int, input().split())) for i in range(n)]\n    vertical = [list(map(int, input().split())) for i in range(m)]\n    vals = vertical[0]\n    first = vals[0]\n    pos = 0\n    \n    for i in horizontal:\n        for g in range(m):\n            if i[g] == first:\n                pos = g\n    \n    path = {}\n    order = {}\n    for ind, i in enumerate(vals):\n        path[i] = ind\n    for ind, i in enumerate(horizontal):\n        order[path[i[pos]]] = ind\n\n    for i in range(len(order)):\n        print(*horizontal[order[i]])\n\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14066