You are given a rectangular parallelepiped with sides of positive integer lengths $A$, $B$ and $C$. 

Find the number of different groups of three integers ($a$, $b$, $c$) such that $1\leq a\leq b\leq c$ and parallelepiped $A\times B\times C$ can be paved with parallelepipeds $a\times b\times c$. Note, that all small parallelepipeds have to be rotated in the same direction.

For example, parallelepiped $1\times 5\times 6$ can be divided into parallelepipeds $1\times 3\times 5$, but can not be divided into parallelepipeds $1\times 2\times 3$.
The first line contains a single integer $t$ ($1 \leq t \leq 10^5$) — the number of test cases.

Each of the next $t$ lines contains three integers $A$, $B$ and $C$ ($1 \leq A, B, C \leq 10^5$) — the sizes of the parallelepiped.
4
1 1 1
1 6 1
2 2 2
100 100 100
1
4
4
165
10
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1
1
1
1
1
1
1
1
1
1
10
9 6 8
5 5 2
8 9 2
2 7 9
6 4 10
1 1 8
2 8 1
10 6 3
7 5 2
9 5 4
41
6
21
12
39
4
7
26
8
18
1
100000 100000 100000
8436
cache = [0 for i in range(10**5 + 10)]

def gcd(a, b):
	if a > b:
		return gcd(b, a)
	elif a == 0:
		return b
	elif a == 1:
		return a
	else:
		return gcd(b % a, a)

def cd(x):
	if cache[x] > 0:
		return cache[x]
	d = 2
	res = 1
	while d**2 <= x:
		cur = 0
		while x % d == 0:
			cur += 1
			x //= d
		res *= (cur + 1)
		d += 1
	if x > 1:
		res *= 2
	cache[x] = res
	return res

def solve(a, b, c):
	return 0

t = int(input())
for tt in range(t):
	a, b, c = list(map(int, input().split()))
	
	dabc = cd(gcd(a, gcd(b, c)))
	dab = cd(gcd(a, b)) - dabc
	dac = cd(gcd(a, c)) - dabc
	dbc = cd(gcd(b, c)) - dabc
	da = cd(a) - dab - dac - dabc
	db = cd(b) - dab - dbc - dabc
	dc = cd(c) - dac - dbc - dabc
	dab = cd(gcd(a, b))
	dac = cd(gcd(a, c))
	dbc = cd(gcd(b, c))

#	print(da, db, dc, dab, dbc, dac, dabc)

	r1 = da * ((db + dab - dabc) * (dc + dac + dbc - dabc) + 
				(dbc - dabc) * (dc + dac) + 
				(dbc - dabc) * (dbc - dabc + 1) * 1./2. + 
				dabc * (dc + dac + dbc - dabc) + 
				dabc * (dabc + 1) * 1./2. )

	r2 = (dab - dabc) * (db * (dc + dac + dbc - dabc) + 
						(dab - dabc + 1) * (dc + dac + dbc - dabc) * 1./2. + 
						(dbc - dabc) * (dc + dac) + 
						(dbc - dabc) * (dbc - dabc + 1) * 1./2. + 
						dabc * (dc + dac + dbc - dabc) + 
						dabc * (dabc + 1) * 1./2. )

	r3 = (dac - dabc) * ((db + dab - dabc) * (dc + dbc) + 
						(db + dab - dabc) * (dac - dabc + 1) * 1./2. + 
						(dbc - dabc) * (dabc + dc) + 
						(dbc - dabc) * (dac - dabc + 1) * 1./2. +
						(dbc - dabc) * (dbc - dabc + 1) * 1./2. + 
						dabc * (dc + dbc - dabc) + 
						dabc * (dabc + 1) * 1./2. + 
						dabc * (dac - dabc) * 1./2. )

	r4 = dabc * ((db + dab - dabc) * (dc + dac - dabc + dbc - dabc) + 
				(db + dab - dabc) * (dabc + 1) * 1./2. + 
				(dabc + 1) * 1./2. * (dc + dac - dabc + dbc - dabc) + 
				(dbc - dabc) * (dc + dac - dabc) + 
				(dbc - dabc) * (dbc - dabc + 1) * 1./2. + 
				(dbc - dabc) * (dabc + 1) * 1./2. )

	r5 = dabc * (dabc + 1) * (dabc + 2) // 6
	print(round(r1 + r2 + r3 + r4 + r5))