A hypergraph is a generalization of a graph, where an edge can connect any number of vertices. A k-uniform hypergraph is a hypergraph such that all its hyperedges have size k. For more information, see Wikipedia.

Let's call a particular hypergraph a hypertree if it is connected (that is, you can move from any vertex to any other vertex using only its hyperedges) and removing any of its hyperedges makes the hypergraph disconnected (note that this definition of hypertrees differs from the standard one).

Given just one integer N, find the number of 3-uniform hypertrees on N vertices. Two 3-uniform hypertrees are considered different if a hyperedge (u, v, w) exists such that it is present in exactly one of these hypertrees (note that the order of vertices in the hyperedge doesn't matter, and neither does the order of hyperedges in the hypertree).

-----Input-----
The first line of the input contains an integer T -- the number of test cases (at most 15). Then T lines follow, each contains an integer N (3 ≤ N ≤ 17).

Important! Please include all code used in solving this problem in your solution.

-----Output-----
For each test case output one line containing the requested number. It's guaranteed that this number won't exceed 263-1.

-----Examples-----
Input:
4
3
4
5
8

Output:
1
6
25
93268

Explanation:
There is just one 3-uniform hypertree on 3 vertices: {(1,2,3)}. There are six of them on 4 vertices: {(1,2,3), (1,2,4)}, {(1,2,3), (1,3,4)}, {(1,2,3), (2,3,4)}, {(1,2,4), (1,3,4)}, {(1,2,4), (2,3,4)}, {(1,3,4), (2,3,4)}. Two of the 25 possible hypertrees on 5 vertices are {(1,2,3), (3,4,5)} and {(1,2,3), (1,2,4), (1,2,5)}.

Difficulty: HARD

Solutions:
output = '\n{(6, 9): 10559808000, (0, 7): 0, (1, 6): 0, (0, 10): 0, (3, 7): 2142, (2, 5): 1, (1, 11): 0, (5, 8): 48094200, (6, 7): 6350400, (5, 5): 1440, (6, 10): 247973140800, (0, 17): 0, (0, 4): 0, (1, 1): 0, (4, 10): 57808440, (2, 6): 1, (5, 11): 84587745000, (4, 5): 2160, (0, 1): 0, (3, 12): 531366, (1, 12): 0, (2, 11): 1, (7, 8): 482630400, (0, 14): 0, (3, 11): 177078, (1, 15): 0, (8, 9): 45113241600, (4, 12): 2148847272, (2, 12): 1, (1, 16): 0, (1, 5): 0, (0, 11): 0, (3, 6): 690, (2, 2): 1, (1, 10): 0, (6, 11): 4928158065600, (0, 5): 0, (1, 0): 1, (0, 8): 0, (4, 11): 354158640, (3, 5): 210, (2, 7): 1, (5, 10): 7639380000, (4, 6): 25560, (5, 7): 2835000, (0, 2): 0, (1, 3): 0, (4, 8): 1433544, (2, 8): 1, (0, 15): 0, (3, 10): 58986, (1, 14): 0, (4, 13): 12970756656, (2, 13): 1, (1, 4): 0, (0, 12): 0, (3, 9): 19626, (2, 3): 1, (1, 9): 0, (2, 14): 1, (6, 8): 336268800, (0, 6): 0, (1, 7): 0, (0, 9): 0, (3, 4): 54, (2, 4): 1, (5, 9): 644550480, (4, 7): 206640, (6, 6): 43200, (5, 6): 104400, (7, 7): 1814400, (0, 16): 0, (0, 3): 0, (3, 14): 4782882, (1, 2): 0, (4, 9): 9265200, (3, 3): 6, (2, 9): 1, (5, 12): 900380296200, (4, 4): 72, (7, 10): 2379856852800, (0, 0): 1, (3, 13): 1594242, (1, 13): 0, (2, 10): 1, (7, 9): 44808422400, (0, 13): 0, (3, 8): 6510, (1, 8): 0, (8, 8): 101606400, (2, 15): 1}\n'
sve = eval(''.join(output.split('\n')))

def fact(n):
	assert n >= 0
	ret = 1
	for i in range(n):
		ret *= i + 1
	return ret

def comb(a, b):
	return fact(a + b) / fact(a) / fact(b)
	pass
memo_ff = {}

def powpoly(x, t):
	ret = [1] + [0] * (len(x) - 1)
	n = len(x)
	for _ in range(t):
		ret2 = [0 for _ in range(n)]
		for i in range(n):
			for j in range(n):
				if i + j < n:
					ret2[i + j] += ret[i] * x[j]
		ret = ret2
	return ret

def ing(x):
	n = len(x)
	assert x[0] == 0
	ret = [0 for _ in range(n)]
	for t in range(0, n):
		ret2 = powpoly(x, t)
		for i in range(n):
			ret[i] += fr * ret2[i] / fact(t)
	return ret

def ff(Y):
	if Y in memo_ff:
		return memo_ff[Y]
	t = Y[0]
	if t == 0:
		n = Y[1]
		ret = 0
		for (v, e) in sve:
			if v + e > n or v == 0:
				continue
			val = sve[v, e]
			for l1 in range(n - v + 1):
				l2 = n - v - l1
				p1 = ff((2, l1, e))
				p2 = ff((3, l2, v))
				a = fr * val * fact(n - 1) / fact(v - 1) / fact(l1) / fact(l2) * p1 * p2 / fact(e)
				ret += a
	elif t == 1:
		n = Y[1]
		ret = 0
		for (v, e) in sve:
			val = sve[v, e]
			e -= 1
			if e == -1 or v + e > n or v == 0:
				continue
			for l1 in range(n - v + 1):
				l2 = n - v - l1
				p1 = ff((2, l1, e))
				p2 = ff((3, l2, v))
				ret += fr * val * fact(n) / fact(v) / fact(l1) / fact(l2) * p1 * p2 / fact(e)
	elif t == 2:
		n = Y[1]
		e = Y[2]
		F = [fr * i * ff((0, i)) / fact(i) for i in range(n + 1)]
		Fa = powpoly(F, e)
		ret = Fa[n] * fact(n)
	elif t == 3:
		n = Y[1]
		v = Y[2]
		G = [v * fr * ff((1, i)) / fact(i) for i in range(n + 1)]
		Ga = ing(G)
		ret = Ga[n] * fact(n)
	memo_ff[Y] = ret
	return ret
memo = {}

def g(Y):
	if Y in memo:
		return memo[Y]
	(k, c) = Y
	if c == 0:
		return ff((0, k))
	if 2 * c >= k:
		return 0
	ret = 0
	for k1 in range(1, 18):
		for k2 in range(1, 18):
			k3 = k - k1 - k2
			if k3 <= 0:
				break
			for c1 in range(18):
				if 2 * c1 >= k1:
					break
				for c2 in range(18):
					if 2 * c2 >= k2:
						break
					c3 = c - 1 - c1 - c2
					if 2 * c3 >= k3:
						continue
					ret += g((k1, c1)) * g((k2, c2)) * g((k3, c3)) * fact(k1 + k2 + k3) / fact(k1) / fact(k2) / fact(k3) * k1 * k2 * k3
	r = ret / (6 * c)
	memo[Y] = r
	return r

def ans(n):
	return sum((g((n, i)) for i in range(n)))

def brute(n):
	m = [(i1, i2, i3) for i1 in range(n) for i2 in range(i1 + 1, n) for i3 in range(i2 + 1, n)]
	init = []
	memob = {}

	def f(vs):
		ret = 0
		if vs:
			g = Graph(n)
			for v in vs:
				(i1, i2, i3) = v
				g.addedge(i1, i2)
				g.addedge(i1, i3)
			a = g.Nconnect()
			for notv in vs:
				g = Graph(n)
				for v in vs:
					if v == notv:
						continue
					(i1, i2, i3) = v
					g.addedge(i1, i2)
					g.addedge(i1, i3)
				if g.Nconnect() == a:
					return 0
			if a == 1:
				return 1
		ret = 0
		for v in m:
			if len(vs) == 0 or v > vs[-1]:
				ret += f(vs + [v])
		return ret
	return f(init)

def brute2(n):
	m = [(i1, i2, i3) for i1 in range(n) for i2 in range(i1 + 1, n) for i3 in range(i2 + 1, n)]
	init = []

	def f(vs):
		ret = 0
		if vs:
			g = Graph(n)
			for v in vs:
				(i1, i2, i3) = v
				g.addedge(i1, i2)
				g.addedge(i1, i3)
			a = g.Nconnect()
			for notv in vs:
				g = Graph(n)
				for v in vs:
					if v == notv:
						continue
					(i1, i2, i3) = v
					g.addedge(i1, i2)
					g.addedge(i1, i3)
				if g.Nconnect() == a or (a == 1 and g.Nconnect() == 3):
					return 0
			if a == 1:
				return 1
		ret = 0
		for v in m:
			if len(vs) == 0 or v > vs[-1]:
				ret += f(vs + [v])
		return ret
	return f(init)

def main():
	t = eval(input())
	z = [0, 1, 0, 1, 6, 25, 495, 5586, 93268, 2052513, 43258365, 1167393700, 34010847486, 1078391538159, 38595111963499, 1476893151785520, 61479081902937000, 2761923686066698561]
	for _ in range(t):
		print(z[eval(input())])
main()