Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length $k$ have the same sum. A subarray of an array is any sequence of consecutive elements.

Phoenix currently has an array $a$ of length $n$. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between $1$ and $n$ inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.


-----Input-----

The input consists of multiple test cases. The first line contains an integer $t$ ($1 \le t \le 50$) — the number of test cases.

The first line of each test case contains two integers $n$ and $k$ ($1 \le k \le n \le 100$).

The second line of each test case contains $n$ space-separated integers ($1 \le a_i \le n$) — the array that Phoenix currently has. This array may or may not be already beautiful.


-----Output-----

For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.

The first line should contain the length of the beautiful array $m$ ($n \le m \le 10^4$). You don't need to minimize $m$.

The second line should contain $m$ space-separated integers ($1 \le b_i \le n$) — a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array $a$. You may print integers that weren't originally in array $a$.

If there are multiple solutions, print any. It's guaranteed that if we can make array $a$ beautiful, we can always make it with resulting length no more than $10^4$.


-----Example-----
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2

Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2


-----Note-----

In the first test case, we can make array $a$ beautiful by inserting the integer $1$ at index $3$ (in between the two existing $2$s). Now, all subarrays of length $k=2$ have the same sum $3$. There exists many other possible solutions, for example:   $2, 1, 2, 1, 2, 1$  $1, 2, 1, 2, 1, 2$ 

In the second test case, the array is already beautiful: all subarrays of length $k=3$ have the same sum $5$.

In the third test case, it can be shown that we cannot insert numbers to make array $a$ beautiful.

In the fourth test case, the array $b$ shown is beautiful and all subarrays of length $k=4$ have the same sum $10$. There exist other solutions also.

Starter code:

Solutions:
t = int(input())

for _ in range(t):
    n, k = [int(x) for x in input().split()]
    a = [int(x) for x in input().split()]
    if len(set(a)) > k:
        print(-1)
        continue
    l = list(set(a))
    l.extend([1]*(k - len(l)))

    print(n*k)
    for _ in range(n):
        print(*l, end=" ")
    print()


for i in range(int(input())):
	n, k=(int(j) for j in input().split())
	a=[int(j) for j in input().split()]
	mm=set(a)
	if(len(mm)>k):
		print("-1", end=" ")
	else:
		if(len(mm)<k):
			for j in range(1, 101):
				if(j not in mm):
					mm.add(j)
				if(len(mm)==k):
					break
		print(n*len(mm))
		for j in range(n):
			print(" ".join(str(x) for x in mm), end=" ")
	print()

import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: list(map(int, stdin.readline().split()))
nl = lambda: list(map(int, stdin.readline().split()))

def solve():
    n, k = nm()
    a = nl()
    if k < len(set(a)):
        print(-1)
        return
    f = list(set(a))
    f += [1]*(k-len(f))
    f *= n
    print(len(f))
    print(*f)
    return


t = ni()
for _ in range(t):
    solve()


for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    arr = list(map(int, input().split()))
    if len(set(arr)) > k:
        print(-1)
    else:
        result = []
        temp = list(set(arr))
        for i in range(1, n + 1):
            if len(temp) == k:
                break
            if i not in temp:
                temp.append(i)
                
        for i in range(len(arr)):
            result.extend(temp)
        print(len(result))
        print(*result)
        


import collections

t=int(input())
for _ in range(t):
    n,k=map(int,input().split())
    arr=list(map(int,input().split()))
    if len(collections.Counter(arr))>k:
        print(-1)
    else:
        cand=list(collections.Counter(arr).keys())
        cnt=len(cand)
        for i in range(1,n+1):
            if cnt>=k:
                break
            else:
                if i not in cand:
                    cand.append(i)
                    cnt+=1
        print(cnt*n)
        print(*(cand*n))

from collections import Counter

def read_int():
    return int(input())


def read_ints():
    return map(int, input().split(' '))


t = read_int()
for case_num in range(t):
    n, k = read_ints()
    a = list(read_ints())
    cnt = Counter(a)
    distinct = len(cnt)
    if distinct > k:
        print(-1)
    else:
        print(n * k)
        s = set(cnt)
        for i in range(1, n + 1):
            if len(s) < k and not i in s:
                s.add(i)
        ans = list(s) * n
        print(' '.join(map(str, ans)))

import sys
readline = sys.stdin.readline

T = int(readline())
Ans = []
for qu in range(T):
    N, K = map(int, readline().split())
    A = list(map(int, readline().split()))
    SA = set(A)
    if len(SA) <= K:
        res = list(SA)
        for i in range(1, N+1):
            if len(res) == K:
                break
            if i not in SA:
                res.append(i)
        Ans.append(str(N*K))
        Ans.append(' '.join(map(str, res*N)))
    else:
        Ans.append('-1')
print('\n'.join(map(str, Ans)))

import sys

input = sys.stdin.readline

for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    if len(set(a)) > k:
        print(-1)
        continue
    a = list(set(a))
    a += [1] * (k - len(a))
    print(k * n)
    print(*(a * n))


def Solve(nCase):
    n, k = [int(x) for x in input().split()]
    a = [int(x) for x in input().split()]
    l = list(set(a))
    p = len(l)
    if p > k:
        print(-1)
        return
    for i in range(k - p):
        l.append(a[0])
    ans = n * l
    print(len(ans))
    print(' '.join(str(x) for x in ans)) 


T = int(input())
for i in range(1, T + 1):
    Solve(i)


def beauty(n, k, array):
    s = set(array)
    
    if len(s) > k:
        print(-1)
        return
    
    L = list(s)
    L.extend([array[0]] * (k - len(s)))
    L *= n
    
    print(len(L))
    print(*L)
    
t = int(input())
for i in range(t):
    n, k = list(map(int, input().split()))
    array = list(map(int, input().split()))
    beauty(n, k, array)


q = int(input())
for _ in range(q):
	n,k = map(int,input().split())
	l = list(map(int,input().split()))
	#szukamy tak zeby okres byl k-1
	if k==1:
		if max(l) == min(l):
			print(len(l))
			print(*l)
		else:
			print(-1)
	else:
		cyk = set()
		for i in l:
			cyk.add(i)
		if len(cyk) > k:
			dasie = 0
		else:
			dasie = 1
		if dasie == 0:
			print(-1)
		else:
			a = list(cyk)
			while len(a) != k:
				a.append(l[0])
			odp = n*a
			print(len(odp))
			print(*odp)