You are given a integer $n$ ($n > 0$). Find any integer $s$ which satisfies these conditions, or report that there are no such numbers:

In the decimal representation of $s$:   $s > 0$,  $s$ consists of $n$ digits,  no digit in $s$ equals $0$,  $s$ is not divisible by any of it's digits. 


-----Input-----

The input consists of multiple test cases. The first line of the input contains a single integer $t$ ($1 \leq t \leq 400$), the number of test cases. The next $t$ lines each describe a test case.

Each test case contains one positive integer $n$ ($1 \leq n \leq 10^5$).

It is guaranteed that the sum of $n$ for all test cases does not exceed $10^5$.


-----Output-----

For each test case, print an integer $s$ which satisfies the conditions described above, or "-1" (without quotes), if no such number exists. If there are multiple possible solutions for $s$, print any solution.


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

Output
-1
57
239
6789



-----Note-----

In the first test case, there are no possible solutions for $s$ consisting of one digit, because any such solution is divisible by itself.

For the second test case, the possible solutions are: $23$, $27$, $29$, $34$, $37$, $38$, $43$, $46$, $47$, $49$, $53$, $54$, $56$, $57$, $58$, $59$, $67$, $68$, $69$, $73$, $74$, $76$, $78$, $79$, $83$, $86$, $87$, $89$, $94$, $97$, and $98$.

For the third test case, one possible solution is $239$ because $239$ is not divisible by $2$, $3$ or $9$ and has three digits (none of which equals zero).

Difficulty: EASY

Solutions:
t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


for _ in range(int(input())):
	N = int(input())
	if N == 1:
		print(-1)
		continue
	else:
		print('2' + '3' * (N - 1))


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		s = '2' + '3' * (n - 1)
		print(s)


import sys

def guess(n):
	if n == 1:
		return '-1'
	return '2' + '3' * (n - 1)
t = int(sys.stdin.readline())
for i in range(t):
	n = int(sys.stdin.readline())
	s = guess(n)
	print(s)


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	elif n == 2:
		print(23)
	else:
		print('23' + '3' * (n - 2))


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print(2, end='')
		for i in range(n - 1):
			print(3, end='')
		print()


t = int(input())
while t != 0:
	t -= 1
	a = int(input())
	if a == 1:
		print('-1')
	else:
		print('2' + '3' * (a - 1))


test_cases = int(input())
for test_case in range(test_cases):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		result = '2'
		for i in range(n - 1):
			result += '3'
		print(result)


import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
from functools import lru_cache
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

def input():
	return sys.stdin.readline()

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
for _ in range(int(input())):
	n = int(input())
	if n <= 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


for _ in range(int(input())):
	n = int(input())
	print(['-1', '2' + '3' * (n - 1)][n > 1])


for _ in range(int(input())):
	n = int(input())
	if n - 1:
		r = '2' + '3' * (n - 1)
	else:
		r = -1
	print(r)


import math
for w in range(int(input())):
	a = int(input())
	if a == 1:
		print(-1)
	else:
		b = '3' * (a - 1)
		print('2' + b)


import os
import sys
from io import BytesIO, IOBase
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')
n = int(input())
for i in range(n):
	t = int(input())
	if t == 1:
		print(-1)
	else:
		s = '2' * 1 + '3' * (t - 1)
		print(s)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
t = inp()
for i in range(t):
	n = inp()
	if n == 1:
		{print(-1)}
	else:
		print(2, end='')
		for j in range(n - 1):
			print(3, end='')
		print('')


for _ in range(int(input())):
	i = int(input())
	flag = 0
	if i == 1:
		print(-1)
	else:
		print('2' + '3' * (i - 1))


import sys
t = int(input())
for i in range(0, t):
	n = int(input())
	ans = []
	if n == 1:
		sys.stdout.write(str(-1) + '\n')
		continue
	chk = True
	for j in range(0, n):
		if chk:
			sys.stdout.write(str(2))
			chk = False
		else:
			sys.stdout.write(str(3))
	sys.stdout.write('\n')


for i in range(int(input())):
	x = int(input())
	if x == 1:
		print(-1)
	else:
		print('2', '3' * (x - 1), sep='')


t = int(input())
while t > 0:
	n = int(input())
	if n == 1:
		print(-1)
	else:
		l = '2'
		l += '3' * (n - 1)
		print(l)
	t -= 1


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = int(input())
for tt in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		s = '2'
		for i in range(n - 1):
			s += '3'
		print(s)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	input = raw_input
	range = xrange
	filter = itertools.ifilter
	map = itertools.imap
	zip = itertools.izip

def is_it_local():
	script_dir = str(os.getcwd()).split('/')
	username = 'dipta007'
	return username in script_dir

def READ(fileName):
	if is_it_local():
		sys.stdin = open(f'./{fileName}', 'r')
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')

def input1(type=int):
	return type(input())

def input2(type=int):
	[a, b] = list(map(type, input().split()))
	return (a, b)

def input3(type=int):
	[a, b, c] = list(map(type, input().split()))
	return (a, b, c)

def input_array(type=int):
	return list(map(type, input().split()))

def input_string():
	s = input()
	return list(s)
if is_it_local():

	def debug(*args):
		st = ''
		for arg in args:
			st += f'{arg} '
		print(st)
else:

	def debug(*args):
		pass

def main():
	t = input1()
	for ci in range(t):
		n = input1()
		if n == 1:
			print(-1)
			continue
		two = n // 3 * 3
		if two == n or two == n - 1:
			two -= 1
		else:
			two += 1
		st = '2'
		print(2, end='')
		for i in range(n - 1):
			print(3, end='')
		print()
	pass
main()


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	if n == 1:
		print('-1')
		continue
	s = '2'
	for i in range(1, n):
		s += '3'
	print(s)


t = int(input())
for i in range(t):
	n = int(input())
	num = str(2)
	if n == 1:
		print(-1)
	else:
		for j in range(n - 1):
			num += str(3)
	if num != '2':
		print(num)


from sys import stdin, stdout
n = int(stdin.readline())
for _ in range(n):
	n = int(stdin.readline())
	if n == 1:
		stdout.write('-1\n')
	else:
		stdout.write('2')
		while n > 1:
			stdout.write('3')
			n -= 1
		stdout.write('\n')


for _ in range(int(input())):
	n = int(input())
	b = [0] * n
	if n == 1:
		print(-1)
	else:
		b[0] = 2
		for i in range(1, n):
			b[i] = 3
		c = str(b[0])
		for i in range(1, len(b)):
			c += str(b[i])
		print(c)


def solve(n):
	if n == 1:
		return -1
	else:
		return '2' + '3' * (n - 1)
t = int(input())
results = list()
for _ in range(0, t):
	n = int(input())
	results.append(solve(n))
for result in results:
	print(result)


tc = int(input())
import math
for _ in range(tc):
	x = int(input())
	if x == 1:
		print(-1)
	else:
		ans = '2'
		for i in range(x - 1):
			ans += '3'
		print(ans)


k = int(input())
for m in range(k):
	a = int(input())
	if a == 1:
		print(-1)
		continue
	print(2, end='')
	for i in range(a - 1):
		print(3, end='')
	print()


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		nums = ['2']
		for i in range(n - 1):
			nums.append('3')
		print(''.join(nums))


from os import remove
from sys import stdin

def readint():
	return int(stdin.readline())

def readarray(typ):
	return list(map(typ, stdin.readline().split()))

def readmatrix(n):
	M = []
	for _ in range(n):
		row = readarray(int)
		assert len(row) == n
		M.append(row)
	return M

def solve():
	n = readint()
	s = '2'
	if n == 1:
		print(-1)
	else:
		for i in range(1, n):
			s = s + '3'
		print(s)
T = readint()
for _ in range(T):
	solve()


from sys import stdin
r = stdin.readline

def main():
	cases = int(r())
	for case in range(cases):
		n = int(r())
		print(-1 if n == 1 else '2' + '3' * (n - 1))
main()


import sys
input = sys.stdin.readline
t = int(input())
for testcase in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		res = ['2'] + ['3'] * (n - 1)
		print(''.join(res))


testCases = int(input())
for x in range(testCases):
	n = int(input())
	if n == 1:
		print('-1')
	else:
		startNumber = '2' + (n - 1) * '3'
		print(startNumber)


testCases = int(input())
for i1 in range(testCases):
	length = int(input())
	if length == 1:
		print('-1')
	else:
		result = '2' + '3' * (length - 1)
		print(result)


import math

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())
for _ in range(ii()):
	n = ii()
	if n == 1:
		print(-1)
		continue
	for i in range(n):
		if i == 0:
			print('2', end='')
		else:
			print('3', end='')
	print()


for _ in range(int(input())):
	l = int(input())
	if l == 1:
		print(-1)
	else:
		ans = '2'
		while len(ans) != l:
			ans += '3'
		print(ans)


import io
import os
from collections import Counter, defaultdict, deque

def solve(N):
	if N == 1:
		return -1
	return '2' + '3' * (N - 1)
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N,) = [int(x) for x in input().split()]
	ans = solve(N)
	print(ans)


T = int(input())
for Z in range(T):
	n = int(input())
	a = ['2']
	if n == 1:
		print(-1)
	else:
		for i in range(n - 1):
			a.append('3')
		c = ''.join(a)
		print(c)


t = int(input())
for i in range(t):
	x = int(input())
	if x == 1:
		print('-1')
	else:
		print('2', end='')
		for j in range(x - 1):
			print('3', end='')
		print('')


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print('-1')
		continue
	s = '2'
	for j in range(n - 1):
		s += '3'
	print(s)


def solve(n):
	res = []
	if n == 1:
		res.append(-1)
		return res[0]
	elif n > 1:
		res.append('2')
		for i in range(n - 1):
			res.append('3')
		return ''.join(res)
t = int(input())
for _ in range(t):
	n = int(input())
	print(solve(n))


from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))

def solve():
	n = get_int()
	if n == 1:
		return -1
	else:
		return '2' + '3' * (n - 1)

def main():
	print(solve())
TestCases = True
if TestCases:
	for i in range(get_int()):
		main()
else:
	main()


for t in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	print('2' + '3' * (n - 1))


def solve():
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))
for i in range(int(input())):
	solve()


t = int(input())
while t != 0:
	n = int(input())
	if n == 1:
		print(-1)
	elif n > 1:
		print('2', end='')
		print('3' * (n - 1))
	t -= 1


t = int(input(''))
n = 0
for i in range(t):
	num = ''
	n = int(input(''))
	if n == 1:
		print('-1')
	else:
		L = [2, 3, 4, 5, 6, 7, 8, 9]
		num = '2'
		num += '3' * (n - 1)
		print(num)


t = int(input())
for i in range(0, t):
	n = int(input())
	if n == 1:
		print(-1)
	elif n >= 2:
		ans = '2'
		for j in range(1, n):
			ans = ans + '3'
		print(ans)


import math
p = lambda x: print(x, end='', sep='')
t = int(input())
for i in range(t):
	x = int(input())
	if x == 1:
		print('-1')
	else:
		p(2)
		for j in range(1, x):
			p(3)
		print()


import math
from bisect import bisect_left, bisect_right
from sys import stdin, stdout, setrecursionlimit
from collections import Counter
input = lambda : stdin.readline().strip()
print = stdout.write
t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print('-1\n')
	else:
		ls = ['2']
		for i in range(n - 1):
			ls.append('3')
		print(''.join(ls) + '\n')


def num(n):
	resultado = ''
	x = 0
	for i in range(n):
		x = input()
		if x is '1':
			resultado = '-1'
			print(resultado)
		elif x in nums:
			resultado = nums[x]
			print(resultado)
		else:
			resultado = '2' + '3' * (int(x) - 1)
			print(resultado)
			nums[x] = resultado
nums = {}
num(int(input()))


T = int(input())
for i in range(T):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		s = '2'
		s = s + '3' * (n - 1)
		print(s)


T = int(input())
while T > 0:
	T = T - 1
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


t = int(input())
for case_num in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		a = [2 if i == 0 else 3 for i in range(n)]
		print(''.join(map(str, a)))


tt = input()
t = int(tt)
while t > 0:
	t = t - 1
	nu = input()
	n = int(nu)
	s = ''
	if n == 1:
		s += '-1'
	else:
		n = n - 1
		s += '2'
		while n > 0:
			n = n - 1
			s += '3'
	print(s)


n = int(input())
t = []
for i in range(n):
	t.append(int(input()))
for i in range(len(t)):
	if t[i] == 1:
		print(-1)
	else:
		x = '23'
		for j in range(2, t[i]):
			x = x + '3'
		print(x)


import sys
import math
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		for i in range(n):
			if i == 0:
				print(2, end='')
			else:
				print(3, end='')
		print()


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	n = iinput()
	if n == 1:
		print('-1')
	else:
		print('2' + '3' * (n - 1))


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	if n == 1:
		print(-1)
	else:
		x = n - 1
		print(2, end='')
		while x > 1:
			print(3, end='')
			x -= 1
		print(3)


t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	if n == 1:
		print(-1)
		continue
	s = '2' + '3' * (n - 1)
	print(s)


T = int(input())
for kase in range(T):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


for x in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		p = '2' + '3' * (n - 1)
		print(p)


for _ in '0' * int(input()):
	n = int(input())
	if n == 1:
		print('-1')
	else:
		print(str(2) * 1 + str(3) * (n - 1))


from sys import stdin, stdout
t = int(stdin.readline())
for test in range(t):
	n = int(stdin.readline())
	if n == 1:
		stdout.write('-1\n')
	else:
		p = [2, 3]
		m = [3] * (n - 2)
		p = p + m
		print(*p, sep='')


c = int(input())
for _ in range(c):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	result = '2'
	for _ in range(n - 1):
		result += '3'
	print(result)


def solve():
	n = int(input())
	if n == 1:
		print('-1', end='')
	else:
		li = [2]
		li1 = [3]
		new_list = li
		if len(new_list) != n:
			new_list = new_list + li1 * (n - 1)
		for ele in new_list:
			print(ele, end='')
	print()
test = int(input())
for _ in range(test):
	solve()


t = int(input())
s = []
for jngn in range(0, t):
	n = int(input())
	q = ''
	if n == 1:
		s.append(-1)
	else:
		q += '2'
		q += (n - 1) * '3'
		s.append(q)
for i in s:
	print(i)


T = int(input())
while T > 0:
	N = int(input())
	if N == 1:
		print('-1')
	else:
		print('2' + str(str(3) * (N - 1)))
	T = T - 1


t = int(input())
for _ in range(t):
	n = int(input())
	if n != 1:
		for x in range(n - 1):
			if x == 0:
				print(2, end='')
			print(3, end='')
		print('')
	else:
		print(-1)


from sys import stdin, stdout
from collections import defaultdict, Counter
from functools import lru_cache
from math import gcd, floor, ceil

def ilist():
	return [int(x) for x in stdin.readline().strip().split(' ')]

def iint():
	return int(stdin.readline().strip())

def istr():
	return stdin.readline().strip()
t = iint()
for _x in range(t):
	n = iint()
	if n == 1:
		print(-1)
	else:
		print('2' + (n - 1) * '3')


import math

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
t = inp()
while t:
	n = inp()
	res = '2'
	if n == 1:
		print(-1)
	else:
		for i in range(n - 1):
			res += '3'
		print(res)
	t -= 1


t = int(input())
ans = []
for _ in range(t):
	l = int(input())
	if l == 1:
		print(-1)
	else:
		print(2, end='')
		for i in range(3, l + 2):
			print(3, end='')
		print()


import math
func = len

def solve():
	n = int(input())
	if n == 1:
		return -1
	res = '2'
	for i in range(n - 1):
		res += '3'
	return res
for i in range(int(input())):
	print(solve())


def main_function():
	t = int(input())
	for i in range(t):
		n = int(input())
		if n == 1:
			print('-1')
			continue
		print('2' + '3' * (n - 1))
main_function()


def make(n):
	S = '3' * n
	Ans = '2' + S
	return Ans
T = int(input())
for _ in range(T):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print(make(n - 1))


import math
t = int(input())
for i in range(t):
	u = int(input())
	if u == 1:
		print('-1', end='')
	else:
		print('2', end='')
		for i in range(u - 1):
			print('3', end='')
	print('')


import math
a = int(input())
for i in range(0, a):
	n = int(input())
	arr = ['2']
	if n == 1:
		print(-1)
	else:
		for i in range(n - 1):
			arr.append('3')
		print(''.join(arr))


def f(n):
	if n == 1:
		return '-1'
	ans = '23'
	for i in range(n - 2):
		ans += '3'
	return ans

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		print(f(n))
main()


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print(2, end='')
		for j in range(n):
			print((n - 1) * str(3))
			break


for _ in range(int(input())):
	No = int(input())
	if No <= 1:
		print('-1')
		continue
	s = '2' + '3' * (No - 1)
	print(s)


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	l = ['3'] * (n - 1)
	l.insert(0, '2')
	print(''.join(l))


for i in range(int(input())):
	k = int(input())
	print('2' + '3' * (k - 1) if k != 1 else '-1')


def solve(n):
	if n == 1:
		return -1
	return '2' + '3' * (n - 1)
t = int(input())
for i in range(t):
	n = int(input())
	y = solve(n)
	print(y)


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		res = [3] * (n - 1)
		res.insert(0, 2)
		print(*res, sep='')


s = int(input())
for i in range(0, s):
	k = int(input())
	n = '3'
	if k == 1:
		print(-1)
	else:
		n = n * (k - 1)
		print('2' + n)


for _ in range(int(input())):
	n = int(input())
	ans = '2'
	if n == 1:
		print(-1)
	else:
		n = n - 1
		while n:
			ans += '3'
			n -= 1
		print(ans)


import sys
import math
from collections import deque

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]
t = read_int()
for i in range(t):
	n = read_int()
	if n == 1:
		print(-1)
	else:
		str = '2'
		str = str + '3' * (n - 1)
		print(str)


for _ in range(int(input())):
	n = int(input())
	x = '2'
	if n == 1:
		print(-1)
	else:
		for i in range(n - 1):
			x = x + '3'
		print(str(x))


t = int(input())
ls = []
for i in range(t):
	n = int(input())
	ls.append(n)
for i in range(len(ls)):
	if ls[i] == 1:
		print(-1)
	else:
		print('2', end='')
		for j in range(ls[i] - 1):
			print('3', end='')
		print('')


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		p = ['3'] * (n - 1)
		q = ''.join(p)
		s = '2'
		s += q
		print(s)


from sys import stdin
import math
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
	n = int(inp())
	if n == 1:
		print(-1)
	else:
		print(2, end='')
		for i in range(n - 1):
			print(3, end='')
		print('')


from sys import exit

def i():
	return input()

def ii():
	return int(input())

def iis():
	return map(int, input().split())

def liis():
	return list(map(int, input().split()))

def print_array(a):
	print(' '.join(map(str, a)))
t = ii()
for _ in range(t):
	n = ii()
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


a = int(input())
for i in range(a):
	b = int(input())
	if b == 1:
		print(-1)
	else:
		s = ''
		s += '2' + '3' * (b - 1)
		print(s)


def main():
	t = int(input())
	while t != 0:
		n = int(input())
		if n == 1:
			print(-1)
		else:
			print(2, end='')
			for i in range(n - 1):
				print(3, end='')
			print()
		t -= 1
main()


r = int(input())
for i in range(r):
	n = int(input())
	if n == 1:
		res = -1
	else:
		res = '2' + (n - 1) * '3'
	print(res)


A = []
T = int(input())
for i in range(T):
	A.append(int(input()))
for n in A:
	if n == 1:
		print(-1)
	else:
		print(2, end='')
		for j in range(n - 2):
			print(3, end='')
		print(3)


def sol(n):
	if n == 1:
		return -1
	else:
		return '2' + '3' * (n - 1)
g = int(input())
results = list()
for i in range(0, g):
	m = int(input())
	results.append(sol(m))
for result in results:
	print(result)


t = int(input())
out = []
for rep in range(t):
	n = int(input())
	if n == 1:
		out.append('-1')
	else:
		out.append('2' + '3' * (n - 1))
print('\n'.join(out))


import math
case = int(input())
for i in range(case):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


from sys import stdin, stdout
import sys, os

def func(s):
	if s == 1:
		return -1
	return ''.join(['2' if x == 0 else '3' for x in range(s)])
test_range = int(input())
for i in range(test_range):
	s = int(input())
	print(func(s))


import os
import io
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce
from collections import deque
import threading

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())
mod = int(1000000000.0) + 7

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
for _ in range(iinput()):
	n = iinput()
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


t = int(input())
for _ in range(t):
	n = int(input())
	res = 0
	if n == 1:
		print('-1')
	else:
		res = '2' + '3' * (n - 1)
		print(res)


t = int(input())
while t:
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))
	t -= 1


for i in range(int(input())):
	n = int(input())
	b = [2]
	if n == 1:
		print('-1')
	else:
		for i in range(n - 1):
			b.append(3)
		b = ''.join((str(i) for i in b))
		print(b)


for i in range(int(input())):
	s = int(input())
	if s == 1:
		print('-1')
	else:
		print('2', end='')
		print('3' * (s - 1))


import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2 ** 62 - 1

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

def read_int_n():
	return list(map(int, input().split()))

def read_float():
	return float(input())

def read_float_n():
	return list(map(float, input().split()))

def read_str():
	return input().strip()

def read_str_n():
	return list(map(str, input().split()))

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

@mt
def slv(N):
	if N == 1:
		return -1
	s = ['2']
	for _ in range(N - 1):
		s.append('3')
	return ''.join(s)

def main():
	T = read_int()
	for _ in range(T):
		N = read_int()
		print(slv(N))
main()


def main():
	import sys
	input = sys.stdin.readline
	for _ in range(int(input())):
		N = int(input())
		if N == 1:
			print(-1)
		else:
			ans = ['3'] * N
			ans[0] = '2'
			print(''.join(ans))
main()


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	T = Scanner.int()
	for _ in range(T):
		N = Scanner.int()
		if N == 1:
			print(-1)
			continue
		print('2' + '3' * (N - 1))
main()


import sys
import os
from io import IOBase, BytesIO
import math
mod = 10 ** 9 + 7
pie = 3.1415926536

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def ain():
	return list(map(int, sin().split()))

def sin():
	return input().strip()

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def read2DIntArray(row, col):
	arr = []
	for i in range(0, row):
		temp = list(map(int, sin().split()))
		arr.append(temp)
	return arr

def read2DCharArray(row, col):
	arr = []
	for i in range(0, row):
		temp = str(sin())
		arr.append(temp)
	return arr

def smallestNumber(n):
	lst = list(str(n))
	lst.sort()
	tmp = ''
	for (i, n) in enumerate(lst):
		if n != '0':
			tmp = lst.pop(i)
			break
	return str(tmp) + ''.join(lst)

def main():
	t = int(sin())
	lst = []
	for i in range(t):
		lst.append(int(sin()))
	for d in lst:
		if d == 1:
			print('-1', end='')
		else:
			print('2', end='')
			d -= 1
			while d > 0:
				print('3', end='')
				d -= 1
		print('')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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))

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


from math import sqrt
t = int(input())
while t:
	t = t - 1
	n = int(input())
	if n == 1:
		print(-1)
		continue
	for i in range(n):
		if i == 0:
			print(2, end='')
		else:
			print(3, end='')
	print()


import collections

def solve(n):
	if n == 1:
		return -1
	ans = [2]
	for i in range(1, n):
		ans.append(3)
	return ''.join(map(str, ans))
t = int(input().strip())
for i in range(t):
	n = int(input().strip())
	print(solve(n))


t = int(input())
for i in range(t):
	a = int(input())
	if a == 1:
		print(-1)
	elif a == 2:
		print(23)
	else:
		s = '2' + '3' * (a - 1)
		print(s)


t = int(input())
for T in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print(2, sep='', end='')
		for i in range(n - 1):
			print(3, sep='', end='')
		print('')


def solve():
	n = int(input())
	if n == 1:
		print(-1)
		return
	else:
		print('2' + '3' * (n - 1))
t = int(input())
for x in range(t):
	solve()


def checker(x):
	if x == 1:
		return -1
	return '2' + '3' * (x - 1)
for _ in range(int(input())):
	print(checker(int(input())))


for _ in range(int(input())):
	t = int(input())
	if t == 1:
		print(-1)
	else:
		print('2', '3' * (t - 1), sep='')


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	if n == 1:
		print(-1)
		continue
	l = [3 for _ in range(n)]
	s = sum(l)
	if s % 3 != 0:
		pass
	else:
		for i in range(2, 10):
			if (s + i - 3) % 3 != 0:
				l[0] = i
				break
	print(''.join((str(x) for x in l)))


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
for i in range(ip()):
	n = ip()
	if n == 1:
		print(-1)
	else:
		x = ['2'] + ['3'] * (n - 1)
		print(''.join(x))


def R():
	return map(int, input().split())

def I():
	return int(input())

def S():
	return str(input())

def L():
	return list(R())
from collections import Counter
import math
import sys
from itertools import permutations
import bisect
for _ in range(I()):
	n = I()
	if n == 1:
		print('-1')
	else:
		print('2' + '3' * (n - 1))


test_cases = int(input().strip())

def testCase():
	n = int(input().strip())
	print('2' + (n - 1) * '3' if n > 1 else '-1')
for t in range(test_cases):
	testCase()


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	s = '2'
	for i in range(n - 1):
		s += '3'
	print(s)


T = int(input())
for i in range(T):
	N = int(input())
	if N == 1:
		print(-1)
		continue
	result = '2'
	for i in range(N - 1):
		result += '3'
	print(result)


def ProcessInputs():
	N = int(input())
	if N == 1:
		print(-1)
	else:
		print('2' + '3' * (N - 1))
T = int(input())
for _ in range(T):
	ProcessInputs()


t = int(input())
for test in range(t):
	n = int(input())
	if n == 1:
		print('-1')
		continue
	print('2', end='')
	for i in range(n - 1):
		print('3', end='')
	print()


t = input()
t = int(t)
for i in range(t):
	n = input()
	n = int(n)
	if n is 1:
		print('-1', end='')
	else:
		for j in range(n):
			if j is 0:
				print('2', end='')
			else:
				print('3', end='')
	print()


num_inp = lambda : int(input())
arr_inp = lambda : list(map(int, input().split()))
for _ in range(int(input())):
	n = int(input())
	print('2' + (n - 1) * '3' if n != 1 else '-1')
sp_inp = lambda : map(int, input().split())
str_inp = lambda : input()


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	res = '2' + ''.join(['3' for i in range(n - 1)])
	print(res)


def solve(n):
	if n == 1:
		print(-1)
		return
	print(2, end='')
	print('3' * (n - 1))
t = int(input())
for _ in range(t):
	n = int(input())
	solve(n)


a = int(input())
r = 0
c = list()
while r < a:
	b = int(input())
	if b == 1:
		c.append('-1')
	elif b == 2:
		c.append('23')
	else:
		s = 0
		t = '23'
		while s < b - 2:
			t = t + '3'
			s = s + 1
		c.append(t)
	r = r + 1
r = 0
while r < a:
	print(c[r])
	r = r + 1


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	else:
		s = ['3'] * n
		s[0] = '2'
		print(''.join(s))


n = int(input())
for _ in range(n):
	x = int(input())
	if x == 1:
		print(-1)
		continue
	print(2, end='')
	for _ in range(x - 1):
		print(3, end='')
	print()


for _ in range(int(input())):
	n = int(input())
	l = []
	if n == 1:
		print('-1')
	else:
		for i in range(n):
			if i == 0:
				l.append('2')
			else:
				l.append('3')
		str1 = ''
		print(str1.join(l))


from random import randint
for i in range(int(input())):
	n = int(input())
	print('2' + '3' * (n - 1) if n != 1 else -1)


for x in range(int(input())):
	a = int(input())
	if a == 1:
		print(-1)
	else:
		print(str(2) + str(3) * (a - 1))


a = int(input())
for j in range(a):
	n = int(input())
	b = str()
	if n == 1:
		print(-1)
		continue
	else:
		for i in range(1, n + 1):
			if i == n:
				print(3)
				break
			if i == 1:
				print(2, end='')
			else:
				print(3, end='')


t = int(input())
for i in range(t):
	n = int(input())
	if n == 1:
		print('-1')
		continue
	p = 2 * (n - 1) + 3
	if p % 2 == 0 and p % 3 == 0:
		a = ''
		for i in range(n - 1):
			a = a + '2'
		a = a + '3'
		print(a)
	else:
		a = ''
		a = a + '2'
		for i in range(n - 1):
			a = a + '3'
		print(a)


import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda : int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda : list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda : float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda : list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda : stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda : stdin.readline().split()
t = ni()

def sol():
	n = ni()
	if n == 1:
		print(-1)
		return
	print(2, end='')
	for _ in range(n - 1):
		print(3, end='')
	print()

def main():
	for _ in range(t):
		sol()
main()


test = int(input())
for ij in range(test):
	s = '2'
	n = int(input())
	if n == 1:
		s = '-1'
	else:
		i = 1
		while i < n:
			s += '3'
			i += 1
	print(s)


queries = int(input())
for _ in range(queries):
	number = int(input())
	if number == 1:
		print('-1')
	else:
		toadd = '3' * (number - 1)
		print('2' + toadd)


from sys import stdin
try:
	for _ in range(int(stdin.readline())):
		n = int(stdin.readline())
		if n == 1:
			print(-1)
		else:
			s = str(2)
			s += str(3) * (n - 1)
			print(s)
except:
	pass


from sys import stdin
n = int(stdin.readline())
for _ in range(n):
	s = int(stdin.readline())
	if s == 1:
		print(-1)
	else:
		print(2, end='')
		for j in range(s - 1):
			print(3, end='')
		print('')


import sys

def rr():
	return sys.stdin.readline().rstrip()

def rri():
	return int(rr())

def rrl():
	return list(map(int, rr().split()))

def rrt():
	return tuple(map(int, rr().split()))

def rrle():
	return (line.rstrip() for line in sys.stdin.readlines())

def rrtl():
	return [tuple(map(int, l.split())) for l in rrle()]
from collections import defaultdict

def mus(d=lambda : 0):
	return defaultdict(lambda : defaultdict(d))

def dd0(d=lambda : 0):
	return defaultdict(d)

def ms(x, y, d=0):
	return [[0] * y for i in range(x)]

def ar(x, d=0):
	return [d] * x

def ppm(m, n=0, x=0, y=0):
	print('\n'.join(('\t'.join((str(m[j][i]) for j in range(y or n))) for i in range(x or n))))

def ppa(a, n):
	print('\t'.join(map(str, a[0:n])))

def ppl(a=0, x=[1]):
	x[0] = a or x[0] + 1
	print('-' + '- -' * 14 + '-# ' + str(x[0] - 2) + ' #-' + '- -' * 14 + '-')

def fltn(a):
	(i for sub in a for i in sub)

def yn(x):
	return 'YES' if x else 'NO'
from itertools import accumulate
from itertools import groupby
from itertools import permutations

def grp(x, key=None):
	return ((i, sum((1 for _ in g))) for (i, g) in groupby(x, key=key))
import math

def rnar():
	return (*rrl(), rrl())

def rn():
	return (*rrl(),)

def dpp(a, b=''):
	print('#| {} |#:^ {} ^:'.format(a, b))
MOD17 = 10 ** 9 + 7

def read():
	return (rri(),)

def solve(n):
	if n == 1:
		ans = -1
	else:
		ans = '2' + '3' * (n - 1)
	return ans
test_count = rri()
for _ in range(test_count):
	input_data = read()
	result = solve(*input_data)
	print(result)


from sys import stdin

def solve(n):
	return '2' + '3' * (n - 1) if n > 1 else '-1'
input()
for line in stdin:
	print(solve(int(line)))


t = int(input())
while t != 0:
	t = t - 1
	n = int(input())
	ans = ''
	sum = 0
	if n == 1:
		print(-1)
	else:
		sum = '2'
		for j in range(0, n - 1):
			sum += '3'
		print(sum)


def process(n):
	if n < 2:
		return '-1'
	res = '2'
	res += '3' * (n - 1)
	return res
limit = int(input())
for i in range(limit):
	n = int(input())
	res = process(n)
	print(res)


import sys
IN = sys.stdin.readline
for i in range(int(IN())):
	a = int(IN())
	print('-1' if a == 1 else '2' + '3' * (a - 1))


import math
n = int(input())
Result = []
for i in range(0, n):
	List = []
	digits = int(input())
	if digits == 1:
		Result.append(-1)
	else:
		for j in range(0, digits):
			if j == 0:
				List.append('2')
			else:
				List.append('3')
		x = ''.join(List)
		Result.append(x)
for i in Result:
	print(i)


def func():
	n = int(input())
	if n == 1:
		print(-1)
		return
	print('2' + '3' * (n - 1))
	return
t = int(input())
for _ in range(t):
	func()


testCase = int(input())
for i in range(testCase):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print(2, end='')
		for j in range(1, n):
			print(3, end='')
		print()


def kras(n):
	q = int(n - 1)
	s = '2'
	q = q - 1
	while q >= 0:
		s += '3'
		q = q - 1
	if n != 1:
		return s
	return -1
n = int(input())
for i in range(n):
	t = int(input())
	print(kras(t))


t = int(input())
for _ in range(t):
	a = int(input())
	if a == 1:
		print('-1')
	else:
		print('2', end='')
		for i in range(a - 1):
			print('3', end='')
		print()


t = int(input())
for case in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		p = ['2']
		q = ['3'] * (n - 1)
		print(''.join(p + q))


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	s = '2' + '3' * (n - 1)
	print(s)


import heapq as hp
import collections
import bisect
import math
import re

def unpack(func=int):
	return map(func, input().split())

def l_unpack(func=int):
	return list(map(func, input().split()))

def s_unpack(func=int):
	return sorted(map(func, input().split()))

def ml_unpack(n):
	return [int(input()) for i in range(n)]

def range_n():
	return range(int(input()))

def counter(a):
	d = {}
	for x in a:
		if x in d:
			d[x] += 1
		else:
			d[x] = 1
	return d

def getint():
	return int(input())

def have_1_or_0(n):
	while n:
		t = n % 10
		if t == 0 or t == 1:
			return True
		n //= 10
	return False

def main():
	for _ in range_n():
		n = getint()
		if n == 1:
			print(-1)
		else:
			n -= 1
			print('2' + '3' * n)
main()


from sys import stdin, stdout
t = int(stdin.readline())
while t > 0:
	n = int(stdin.readline())
	if n == 1:
		print('-1')
	else:
		print('2' + '3' * (n - 1))
	t = t - 1


import sys
import random
from math import log2, log, ceil
input = sys.stdin.readline

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a > 0:
		return gcd(b % a, a)
	return b

def primefs(n):
	if n == 1:
		return 1
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	while x != link[x]:
		x = link[x]
	return x

def union(x, y, size, link):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]
spf_sieve()

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().split()))
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


from math import ceil, sqrt, floor
import sys
n = int(input())
for i in range(n):
	a = int(input())
	if a == 1:
		print(-1)
	else:
		print('2' + '3' * (a - 1))


from collections import Counter
from collections import defaultdict
import math
t = int(input())
for _ in range(0, t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		a = str(2) + '3' * (n - 1)
		s = ''.join(a)
		print(s)


import math

def sol():
	t = int(input())
	for _ in range(t):
		n = int(input())
		s = '2'
		if n == 1:
			print(-1)
			continue
		else:
			for i in range(n - 1):
				s += '3'
		print(s)
sol()


def process():
	n = int(input())
	if n == 1:
		print('-1')
		return
	if n == 2:
		print('23')
		return
	else:
		c = '2'
		print(c, end='')
		for i in range(1, n):
			print('3', end='')
		print()
tests = int(input())
for i in range(0, tests):
	process()


x = int(input())
for i in range(x):
	y = int(input())
	if y == 1:
		print('-1')
	else:
		print('2', end='')
		for z in range(y - 1):
			print('3', end='')
		print()


n = int(input())
for n in range(n):
	x = int(input())
	if x < 2:
		print(-1)
		continue
	arr = '2'
	x -= 1
	for i in range(x):
		arr += '3'
	print(arr)


val_a = input()
t = int(val_a)
for i in range(0, t, 1):
	val_b = input()
	n = int(val_b)
	if n != 1:
		v = '3' * (n - 1)
		s = '2' + v
		print(s)
	else:
		print('-1')


from sys import stdin
input = stdin.readline

def main():
	test = int(input())
	for _ in range(test):
		n = int(input())
		if n == 1:
			print(-1)
		else:
			s = '2' + (n - 1) * '3'
			print(s)
main()


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	a = []
	a.append('2')
	for i in range(n - 1):
		a.append('3')
	print(''.join(a))


t = int(input())
while t > 0:
	result = ''
	n = int(input())
	if n == 1:
		print(-1)
	else:
		result += '2'
		for i in range(n - 1):
			result += '3'
		print(result)
	t -= 1


def linput(a):
	return [int(i) for i in a.split()]
q = int(input())
for ughblnk in range(q):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


def getUglyNumber(v):
	if v == 1:
		print(-1)
	else:
		print(2, end='')
		j = 1
		while j < v - 1:
			print(3, end='')
			j = j + 1
		print(3)
t = int(input())
for i in range(t):
	v = int(input())
	getUglyNumber(v)


def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a * b / gcd(a, b)
test = int(input())
while test > 0:
	x = int(input())
	test = test - 1
	if x == 1:
		print('-1')
	else:
		ans = '2'
		while x > 1:
			ans = ans + '3'
			x = x - 1
		print(ans)


from sys import stdin, stderr

def rl():
	return [int(w) for w in stdin.readline().split()]
(t,) = rl()
for _ in range(t):
	(n,) = rl()
	if n > 1:
		print('2' + '3' * (n - 1))
	else:
		print('-1')


import math

def inp_n():
	return int(input())

def inp_list():
	return list(map(int, input().split()))

def inp_mul_num():
	return map(int, input().split())

def is_odd(n):
	if n & 1:
		return True
	return False

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
for _ in range(inp_n()):
	n = inp_n()
	f = 0
	v = ''
	if n > 1:
		v = '2' + '3' * (n - 1)
		print(v)
	else:
		print(-1)


from sys import stdin, stdout
import math
import random

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		ans = ''
		if n == 1:
			print(-1)
			continue
		ans += '2'
		for j in range(n - 1):
			ans += '3'
		print(ans)
main()


def main():
	t = int(input())
	while t:
		n = int(input())
		if n == 1:
			print(-1)
		else:
			s = '2'
			s += (n - 1) * '3'
			print(s)
		t -= 1
main()


def main():
	n = int(input())
	if n == 1:
		return -1
	else:
		return '2' + (n - 1) * '3'
for _ in range(int(input())):
	print(main())


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		st = '2'
		st += '3' * (n - 1)
		print(st)


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
from bisect import bisect_left as lower_bound, bisect_right as upper_bound

def so():
	return int(input())

def st():
	return input()

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

def msj():
	return map(str, input().strip().split(' '))

def le():
	return list(map(int, input().split()))

def lebe():
	return list(map(int, input()))

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()

def joro(L):
	return ''.join(map(str, L))

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def npr(n, r):
	return factorial(n) // factorial(n - r) if n >= r else 0

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = -1
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = mid
			break
	return ans

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	li = []
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, len(prime)):
		if prime[p]:
			li.append(p)
	return li

def primefactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n //= 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n //= i
	if n > 2:
		factors.append(n)
	return factors

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def tr(n):
	return n * (n + 1) // 2

def ma(m):
	import math as my
	y = my.floor(my.log(m, 2))
	if y % 2 != 0:
		return y
	return y - 1

def iu():
	import sys
	import math as my
	m = so()
	if m != 1:
		print('2' + '3' * (m - 1))
	else:
		print(-1)

def main():
	for i in range(so()):
		iu()
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


for _ in range(int(input())):
	i = int(input())
	if i == 1:
		print('-1')
		continue
	w = ''
	for j in range(i):
		if j == 0:
			w = '2'
		else:
			w += '3'
	print(w)


a = input()
i = int(a)
x = 0
lst = []
c = 1
while x < i:
	x += 1
	b = input()
	n = int(b)
	if n == 1:
		print(-1)
	if n != 1:
		print(str(2) + int(n - 1) * str(3))


def solve(n):
	if n == 1:
		return -1
	return '2' + '3' * (n - 1)
cases = int(input())
for case in range(cases):
	print(solve(int(input())))


def solve(n):
	if n == 1:
		print('-1')
		return
	else:
		print('2', end='')
		for i in range(n - 1):
			print('3', end='')
		print('')
		return
t = int(input())
while t:
	n = int(input())
	solve(n)
	t -= 1


tc = int(input().strip())
for t in range(tc):
	n = int(input().strip())
	if n == 1:
		print(-1)
	else:
		print('2', end='')
		for i in range(1, n):
			print('3', end='')
		print()


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
		continue
	a = [3] * n
	a[0] = 2
	for i in range(n):
		print(a[i], end='')
	print()


import functools

def cmp(str1, str2):
	if str1 < str2:
		return 1
	elif str1 > str2:
		return -1
	else:
		return 0
import math
t = int(input())
while t:
	t -= 1
	x = int(input())
	if x == 1:
		print(-1)
		continue
	else:
		print(2, end='')
		for i in range(x - 1):
			print(3, end='')
		print()


t = int(input())
a = []
while t:
	n = int(input())
	if n == 1:
		a.append('-1')
	else:
		s = ['2']
		s.extend('3' * (n - 1))
		a.append(''.join(s))
	t -= 1
print('\n'.join(a))


t = int(input())
for j in range(t):
	a = int(input())
	if a == 1:
		print(-1)
	else:
		print('2' + '3' * (a - 1))


t = int(input())
for _ in range(t):
	digits = int(input())
	if digits == 1:
		print(-1)
		continue
	else:
		print('2' + '3' * (digits - 1))


def main():
	t = int(input())
	all_input = []
	for i in range(t):
		n = int(input())
		if n == 1:
			print(-1)
		else:
			string_ans = '2'
			for j in range(1, n):
				string_ans += '3'
			print(string_ans)
main()


t = int(input())
while t > 0:
	n = int(input(''))
	if n <= 1:
		print(-1)
	else:
		k = n - 1
		s1 = '2' * 1
		s2 = '3' * k
		s = s1 + s2
		print(s)
	t = t - 1


import sys
from math import *
from collections import defaultdict
from queue import deque
from heapq import heappush, heappop
lines = [line.strip() for line in sys.stdin.readlines()]
t = int(lines[0])
for tt in range(1, 1 + t):
	n = int(lines[tt])
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


from collections import defaultdict
import math
from functools import reduce
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


testcases = int(input())
while testcases > 0:
	testcases = testcases - 1
	n = int(input())
	if n == 1:
		print('-1')
		continue
	else:
		string = '2' + '3' * (n - 1)
		print(string)


import sys
cases = int(sys.stdin.readline())
for j in range(cases):
	solution = '-1'
	n = int(sys.stdin.readline())
	if n != 1:
		solution = '2'
		for i in range(n - 1):
			solution += '3'
	print(solution)


import sys
read = sys.stdin.buffer.readline
for _ in range(int(read())):
	n = int(read())
	print([-1, '2' + '3' * (n - 1)][n != 1])


def answer(n):
	if n == 1:
		return -1
	return '2' + '3' * (n - 1)
testCount = int(input())
for _ in range(testCount):
	n = int(input())
	print(answer(n))


for _ in range(int(input())):
	digits = int(input())
	if digits == 1:
		print(-1)
	else:
		print('23' + '3' * (digits - 2))


i = int(input())
for j in range(0, i):
	a = int(input())
	if a > 1:
		print(str(2) + str(3) * (a - 1))
	else:
		print(-1)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x) + '\n')
for i in range(get_int()):
	n = get_int()
	if n == 1:
		print(-1)
	else:
		print('2' + '3' * (n - 1))


for i in range(int(input())):
	n = int(input())
	if n == 1:
		print(-1)
	elif n >= 2:
		print('2' + '3' * (n - 1))


t = int(input())
for sai in range(t):
	n = int(input())
	if n == 1:
		print(-1)
	else:
		s = '2'
		for z in range(n - 1):
			s = s + '3'
		print(s)


t = int(input())
for i in range(t):
	n = int(input())
	a = '2'
	if n == 1:
		print(-1)
		continue
	else:
		for j in range(1, n):
			a += '3'
	print(a)


k = int(input())
while k:
	k -= 1
	n = int(input())
	if n == 1:
		ugly = str(-1)
	else:
		for i in range(n):
			if i == 0:
				ugly = str(2)
			else:
				ugly += str(3)
	print(ugly)