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
#!/usr/bin/python3

def factorize(n):
    result = []
    p = 1
    while n > 1:
        p += 1
        while n % p > 0:
            p += 1

        c = 0
        while n % p == 0:
            n //= p
            c += 1

        result.append((p, c))

    return result


def factors(fs):
    N = len(fs)
    if N == 0:
        return set([1])

    result = set()

    ps = [0] * N
    while True:
        f = 1
        for i in range(N):
            f *= fs[i][0] ** ps[i]

        end = False
        for i in range(N):
            ps[i] += 1
            if ps[i] > fs[i][1]:
                if i == N - 1:
                    end = True
                ps[i] = 0
            else:
                break

        result.add(f)

        if end:
            break

    return result


def solve(A, B, C):
    fa = factorize(A)
    fb = factorize(B)
    fc = factorize(C)

    fs = list(factors(fa) | factors(fb) | factors(fc))
    fs.sort()
    N = len(fs)

    rots = ((A, B, C), (A, C, B), (B, A, C), (B, C, A), (C, A, B), (C, B, A))

    c = 0
    for i in range(N):
        for j in range(i, N):
            for k in range(j, N):
                abc = (fs[i], fs[j], fs[k])

                aok = False
                for rot in rots:
                    ok = True
                    for r in range(3):
                        if rot[r] < abc[r] or rot[r] % abc[r] > 0:
                            ok = False
                            break
                    if ok:
                        aok = True
                        break

                if aok:
                    c += 1

    return c


def main():
    N = int(input())
    for _ in range(N):
        A, B, C = [int(e) for e in input().split(' ')]
        print(solve(A, B, C))


if __name__ == '__main__':
    main()
